xinyin025/learn.lianglianglee.com
1
0
Fork 0
mirror of https://github.com/zhwei820/learn.lianglianglee.com.git synced 2025-09-17 08:46:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
learn.lianglianglee.com/专栏/白话设计模式 28 讲（完）/00 生活中的设计模式：启程之前，请不要错过我.md.html
周伟 d9c5ffd627 u
2022-05-11 19:04:14 +08:00

1127 lines
33 KiB
HTML
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html>
<!-- saved from url=(0046)https://kaiiiz.github.io/hexo-theme-book-demo/ -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no">
<link rel="icon" href="/static/favicon.png">
<title>00 生活中的设计模式：启程之前，请不要错过我.md.html</title>
<!-- Spectre.css framework -->
<link rel="stylesheet" href="/static/index.css">
<!-- theme css & js -->
<meta name="generator" content="Hexo 4.2.0">
</head>
<body>
<div class="book-container">
<div class="book-sidebar">
<div class="book-brand">
<a href="/">
<img src="/static/favicon.png">
<span>技术文章摘抄</span>
</a>
</div>
<div class="book-menu uncollapsible">
<ul class="uncollapsible">
<li><a href="/" class="current-tab">首页</a></li>
</ul>
<ul class="uncollapsible">
<li><a href="../">上一级</a></li>
</ul>
<ul class="uncollapsible">
<li>
<a class="current-tab" href="/专栏/白话设计模式 28 讲（完）/00 生活中的设计模式：启程之前，请不要错过我.md.html">00 生活中的设计模式：启程之前，请不要错过我.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/01 监听模式：坑爹的热水器.md.html">01 监听模式：坑爹的热水器.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/02 适配模式：身高不够鞋来凑.md.html">02 适配模式：身高不够鞋来凑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/03 状态模式：人与水的三态.md.html">03 状态模式：人与水的三态.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/04 单例模式：你是我生命的唯一.md.html">04 单例模式：你是我生命的唯一.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/05 职责模式：我的假条去哪了.md.html">05 职责模式：我的假条去哪了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/06 中介模式：找房子问中介.md.html">06 中介模式：找房子问中介.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/07 代理模式：帮我拿一下快递.md.html">07 代理模式：帮我拿一下快递.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/08 装饰模式：你想怎么穿就怎么穿.md.html">08 装饰模式：你想怎么穿就怎么穿.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/09 工厂模式：你要拿铁还是摩卡.md.html">09 工厂模式：你要拿铁还是摩卡.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/10 迭代模式：下一个就是你了.md.html">10 迭代模式：下一个就是你了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/11 组合模式：自己组装电脑.md.html">11 组合模式：自己组装电脑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/12 构建模式：想要车还是庄园.md.html">12 构建模式：想要车还是庄园.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/13 克隆模式：给你一个分身术.md.html">13 克隆模式：给你一个分身术.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/14 策略模式：怎么来不重要，人到就行.md.html">14 策略模式：怎么来不重要，人到就行.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/15 命令模式：大闸蟹，走起！.md.html">15 命令模式：大闸蟹，走起！.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/16 备忘模式：好记性不如烂笔头.md.html">16 备忘模式：好记性不如烂笔头.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/17 享元模式：颜料很贵必须充分利用.md.html">17 享元模式：颜料很贵必须充分利用.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/18 外观模式：学妹别慌，学长帮你.md.html">18 外观模式：学妹别慌，学长帮你.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/19 访问模式：一千个读者一千个哈姆雷特.md.html">19 访问模式：一千个读者一千个哈姆雷特.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/20 生活中的设计模式：与经典设计模式的不解渊源.md.html">20 生活中的设计模式：与经典设计模式的不解渊源.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/21 生活中的设计模式：那些未完待续的设计模式.md.html">21 生活中的设计模式：那些未完待续的设计模式.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html">22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/23 深入解读对象池技术：共享让生活更便捷.md.html">23 深入解读对象池技术：共享让生活更便捷.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/24 深入解读回调机制：把你技能亮出来.md.html">24 深入解读回调机制：把你技能亮出来.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/25 谈谈我对设计模式的理解.md.html">25 谈谈我对设计模式的理解.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/26 谈谈我对设计原则的思考.md.html">26 谈谈我对设计原则的思考.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/27 谈谈我对项目重构的看法.md.html">27 谈谈我对项目重构的看法.md.html</a>
</li>
</ul>
</div>
</div>
<div class="sidebar-toggle" onclick="sidebar_toggle()" onmouseover="add_inner()" onmouseleave="remove_inner()">
<div class="sidebar-toggle-inner"></div>
</div>
<script>
function add_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.add('show')
}
function remove_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.remove('show')
}
function sidebar_toggle() {
let sidebar_toggle = document.querySelector('.sidebar-toggle')
let sidebar = document.querySelector('.book-sidebar')
let content = document.querySelector('.off-canvas-content')
if (sidebar_toggle.classList.contains('extend')) { // show
sidebar_toggle.classList.remove('extend')
sidebar.classList.remove('hide')
content.classList.remove('extend')
} else { // hide
sidebar_toggle.classList.add('extend')
sidebar.classList.add('hide')
content.classList.add('extend')
}
}
function open_sidebar() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.add('show')
overlay.classList.add('show')
}
function hide_canvas() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.remove('show')
overlay.classList.remove('show')
}
</script>
<div class="off-canvas-content">
<div class="columns">
<div class="column col-12 col-lg-12">
<div class="book-navbar">
<!-- For Responsive Layout -->
<header class="navbar">
<section class="navbar-section">
<a onclick="open_sidebar()">
<i class="icon icon-menu"></i>
</a>
</section>
</header>
</div>
<div class="book-content" style="max-width: 960px; margin: 0 auto;
overflow-x: auto;
overflow-y: hidden;">
<div class="book-post">
<p id="tip" align="center"></p>
<div><h1>00 生活中的设计模式：启程之前，请不要错过我</h1>
<p>两年前 CSDN 出了一个产品叫 ink，旨在提供一个高质量的写作环境，那时就有写设计模式这一系列的想法了，而且也确实写了，在 ink 里写了三篇文章，后来不知道什么原因这个产品下架了，写的三篇文章也没了，这事也就一直被搁置了；直到今天，我想重新开始，以全新的方式和思路重新写这一系列内容！</p>
<ul>
<li><strong>文章的特点：</strong> 从生活的小故事开始，由浅入深，逐步阐述设计模式的思想，并抽象出代码模型（骨架）。</li>
<li><strong>追求的境界：</strong> 用最通俗的语言阐述最难懂的概念；用最简单的语法实现最复杂的逻辑；用最短小的代码写出最强悍的程序！</li>
</ul>
<h3>为什么叫设计模式</h3>
<h4>什么是设计模式</h4>
<p><strong>设计模式</strong>最初是被 GoF 于 1995 年提出的，GoF（Gang of Four，四人帮）即 Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides。他们四人于 1995 年出版了一本书《Design Patterns：Elements of Reusable Object-Oriented Software》（翻译成中文是《设计模式 可复用面向对象软件的基础》），第一次将设计模式提升到理论高度，并将之规范化，该书提出了 23 种经典的设计模式。</p>
<p>设计模式（Design Pattern）是一套被反复使用、多数人知晓的、无数工程师实践的代码设计经验的总结，它是面向对象思想的高度提炼和模板化，使用设计模式是为了让代码具有更高的可重用性，更好的灵活性和可拓展性，更易被人阅读和理解。GoF 提到的模式有四个基本要素：</p>
<ul>
<li>模式名称：助记名，方便讨论、交流、传播；</li>
<li>问题：该模式是用来解决哪类实际问题，即它的应用场景；</li>
<li>解决方案：设计的组成部分，它们之间的相互关系及各自的职责和协作方式；</li>
<li>效果：使用模式能达到的效果，即对使用条件的权衡取舍。</li>
</ul>
<h4>设计模式与生活有什么联系</h4>
<p>我一直坚信：程序源于生活，又高于生活！程序的灵魂在于思维的方式，而思维的灵感来源于生活的精彩。互联网是一个虚拟的世界，而程序本身就是对生活场景的虚拟和抽象，每一个模式我都能在生活中找到他的影子。比如，说到状态模式我能想到水有冰、水、气三种状态，而人也有少、壮、老三个不同的阶段；提起中介模式我能立马想到房产中介；看到单例模式，脑海中会即刻浮现心目中的那个她……</p>
<p>设计模式是面向对象的高度抽象和总结，而越抽象的东西越难以理解。本系列文章的目地就是为了降低设计模式的阅读门槛，以生活中的小故事开始，用风趣的方式，由浅入深地讲述每一个模式。让你再次看到设计模式时不只是一个模式，还是生活中的一个个小确幸！程序不是冷冰冰的代码，它还有生活的乐趣和特殊意义。</p>
<h3>为什么要学设计模式</h3>
<p>设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。所以不管你是新手还是老手，学习设计模式将对你都有莫大的帮助。</p>
<p>学习设计模式的理由有很多，这里只列出几个最实现的：</p>
<ul>
<li>摆脱面试的窘境，不管是前端工程师还是后端工程师，亦或是全端工程师，设计模式是面试时必问的一道题。</li>
<li>让程序设计能力有一个质的提升，不再是写一堆结构复杂、难以维护的烂代码。</li>
<li>对面向对象的思想有一个更高层次的理解。</li>
</ul>
<h3>如何进行学习</h3>
<p><strong>熟悉一门面向对象语言</strong></p>
<p>首先，至少要熟悉一门面向对象的计算机语言。如果没有，请根据自己的学习爱好，或希望从事的工作，先选择一门面向对象语言（C++、Java、Python、Go 等都可以）进行学习和实战，对抽象、继承、多态、封装有一定的基础之后，再来看本系列的文章内容。</p>
<p><strong>了解 Python 的基本语法</strong></p>
<p>对 Python 的基本语法有一个简单了解。Python 语法非常简单，只要有一定的编程语言基础，通过下文的介绍很快就能理解的。</p>
<p><strong>学会阅读 UML 图</strong></p>
<p>UML（Unified Modeling Language）称为统一建模语言或标准建模语言，是面向对象软件的标准化建模语言。UML 规范用来描述建模的概念有：类（对象的）、对象、关联、职责、行为、接口、用例、包、顺序、协作以及状态。</p>
<p>UML 类图表示不同的实体（人、事物和数据）如何彼此相关；换句话说，它显示了系统的静态结构。想进一步了解类图中的各种关系，可参考以下文章：</p>
<ul>
<li><a href="http://www.tk4479.net/luoweifu/article/details/25817471">UML 类图关系大全</a></li>
<li><a href="https://www.cnblogs.com/olvo/archive/2012/05/03/2481014.html">UML 类图关系（泛化 、继承、实现、依赖、关联、聚合、组合）</a></li>
</ul>
<p><strong>阅读本系列文章</strong></p>
<p>通过阅读本系列文章，以轻松愉快的方式学习设计模式和编程思想。本系列文章没有阅读的先后顺序，每一章都是单独成文，可从任意一篇文章开始。</p>
<h3>为什么选择 Python</h3>
<p>虽然说设计模式与编程语言没有关系，它是对面向对象思想的灵活应用和高度概括，可以用任何一种语言来实现它，但总归是需要用一种语言进行举例的。本系列文章的所有示例代码均使用 Python 语言编写，为什么选择 Python，主要是基于以下两个原因。</p>
<h4>弥补市场空缺</h4>
<p>设计模式于 1995 被 GoF 提出，被广泛应用于热门的面对象语言。目前用 Java、C++ 描述的设计模式的书籍和资料已经非常多了，但用 Python 来描述的真是太少了；我在当当上搜索了一下“Python 设计模式”关键字，发现只有那零星的几本书。而作为已经挤进 Top4 的 Python 语言，这明示是不够的。Python 已经越来越成熟，也越来越多地被使用，作为一个有技术追求的 IT 儿有必要了解一下基于 Python 代码设计。</p>
<h4>大势所趋，Python 已然成风</h4>
<ul>
<li>C 语言诞生于 1972 年，确随着 Unix 的诞生才深深植根于各大操作系统；</li>
<li>C++ 语言诞生于 1983 年，确因微软的可视化桌面操作系统才得以广泛传播；</li>
<li>Java 语言诞生于 1995 年，确因互联网的迅速崛起才变得家喻户晓；</li>
<li>Python 语言诞生于 1991 年，而下一场技术革命已然开始，AI 时代已然成风。在 AI 领域中已经被广泛使用的 Python 语言必将成为下一个时代的第一开发语言！</li>
</ul>
<p>最热门的 AI 开源框架 PyTorch 和 TensorFlow 都已经采用了 Python 作为接口和开发语言。除此之外，还有一堆的 AI 相关的框架库，也都纷纷采用，如 AIMA、pyDatalog、SimpleAI、PyBrain、PyML 等。</p>
<p>作为这么一门有前途的语言，必然是要去学习和使用的。</p>
<h3>简单的 Python 基础</h3>
<p>如果已经熟悉 Python 语言，这一部分的内容可直接跳过！</p>
<h4>Python 的特点</h4>
<p>Python 崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。</p>
<p>与 Java 和 C++ 这些语言相比，Python 最大的两个特点是：</p>
<ul>
<li>语句结束不用分号“;”。</li>
<li>代码块用缩进来控制，而不用大括号“{}”。</li>
</ul>
<p>刚转过来的时候可能会有点不适，用一段时间就好了！</p>
<p>个人觉得，在所有的高级计算机语言中，Python 是最接近人类自然语言的。Python 的语法、风格都与英文的书写习惯非常接近，Python 的这种风格被称为 Pythonic，如条件表达式，在 Java 和 C++ 中是这样的：</p>
<pre><code class="language-java">int min = x &lt; y ? x : y
</code></pre>
<p>而 Python 是这样的：</p>
<pre><code class="language-python">min = x if x &lt; y else y
</code></pre>
<p>有没有觉得第二种方式更接近人类的自然思维？</p>
<h4>基本语法</h4>
<p><strong>数据类型</strong></p>
<p>Python 是一种弱类型的语言，变量的定义不需要在前面加类型说明，而且不同类型之间可以方便地相互转换。Python 有五个标准的数据类型：</p>
<ul>
<li>Numbers（数字）</li>
<li>String（字符串）</li>
<li>List（列表）</li>
<li>Tuple（元组）</li>
<li>Dictionary（字典）</li>
</ul>
<p>其中 List、Tuple、Dictionary 为容器，将在下一部分介绍。Python 支持四种不同的数字类型：int（有符号整型）、long（长整型）、float（浮点型）、complex（复数）。</p>
<p>每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。</p>
<p>Demo：</p>
<pre><code class="language-python">age = 18 # int
weight = 62.51 # float
name = &quot;Tony&quot; # string
print(&quot;age:&quot;, age)
print(&quot;weight:&quot;, weight)
print(&quot;name:&quot;, name)
# 变量的类型可以直接改变
age = name
print(&quot;age:&quot;, age)
a = b = c = 5
# a,b,c三个变量指向相同的内存空间，具有相同的值
print(&quot;a:&quot;, a, &quot;b:&quot;, b, &quot;c:&quot;, c)
print(&quot;id(a):&quot;, id(a), &quot;id(b):&quot;, id(b), &quot;id(c):&quot;, id(c))
</code></pre>
<p>结果：</p>
<pre><code>age: 18
weight: 62.51
name: Tony
age: Tony
a: 5 b: 5 c: 5
id(a): 1457772400 id(b): 1457772400 id(c): 1457772400
</code></pre>
<h4>常用容器</h4>
<h5><strong>List（列表）</strong></h5>
<p>List（列表）是 Python 中使用最频繁的数据类型，用 [ ] 标识。</p>
<p>列表可以完成大多数集合类的数据结构实现。类似于 Java 中的 ArrayList，C++ 中的 Vector。此外，一个 List 中还可以同时包含不同类型的数据，支持字符、数字、字符串，甚至可以包含列表（即嵌套）。</p>
<ul>
<li>列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。</li>
<li>加号（+）是列表连接运算符，星号（*）是重复操作。</li>
</ul>
<p>Demo：</p>
<pre><code class="language-python">list = ['Thomson', 78, 12.58, 'Sunny', 180.2]
tinylist = [123, 'Tony']
print(list) # 输出完整列表
print(list[0]) # 输出列表的第一个元素
print(list[1:3]) # 输出第二个至第三个元素
print(list[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2) # 输出列表两次
print(list + tinylist) # 打印组合的列表
list[1] = 100 # 修改第二个元素的值
print(list) # 输出完整列表
list.append(&quot;added data&quot;)
print(list) # 输出增加后的列表
</code></pre>
<p>结果：</p>
<pre><code>['Thomson', 78, 12.58, 'Sunny', 180.2]
Thomson
[78, 12.58]
[12.58, 'Sunny', 180.2]
[123, 'Tony', 123, 'Tony']
['Thomson', 78, 12.58, 'Sunny', 180.2, 123, 'Tony']
['Thomson', 100, 12.58, 'Sunny', 180.2]
['Thomson', 100, 12.58, 'Sunny', 180.2, 'added data']
</code></pre>
<h5>Tuple（元组）</h5>
<p>Tuple（元组）是另一个数据类型，元组用“()”标识，内部元素用逗号隔开。元组不能二次赋值，相当于只读列表，用法与 List 类似。Tuple 相当于 Java 中的 final 数组，C++ 中的 const 数组。</p>
<p>Demo：</p>
<pre><code class="language-python">tuple = ('Thomson', 78, 12.58, 'Sunny', 180.2)
tinytuple = (123, 'Tony')
print(tuple) # 输出完整元组
print(tuple[0]) # 输出元组的第一个元素
print(tuple[1:3]) # 输出第二个至第三个的元素
print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2) # 输出元组两次
print(tuple + tinytuple)# 打印组合的元组
# tuple[1] = 100 # 不能修改元组内的元素
</code></pre>
<p>结果：</p>
<pre><code>('Thomson', 78, 12.58, 'Sunny', 180.2)
Thomson
(78, 12.58)
(12.58, 'Sunny', 180.2)
(123, 'Tony', 123, 'Tony')
('Thomson', 78, 12.58, 'Sunny', 180.2, 123, 'Tony')
</code></pre>
<h5>Dictionary（字典）</h5>
<p>Dictionary（字典）是 Python 中除列表以外最灵活的内置数据结构类型。字典用“{ }”标识，字典由索引（key）和它对应的值 value 组成，相当于 Java 和 C++ 中的 Map。</p>
<p>列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。</p>
<p>Demo：</p>
<pre><code class="language-python">dict = {}
dict['one'] = &quot;This is one&quot;
dict[2] = &quot;This is two&quot;
tinydict = {'name': 'Tony', 'age': 24, 'height': 177}
print(dict['one']) # 输出键为'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values())# 输出所有值
</code></pre>
<p>结果：</p>
<pre><code>This is one
This is two
{'name': 'Tony', 'age': 24, 'height': 177}
dict_keys(['name', 'age', 'height'])
dict_values(['Tony', 24, 177])
</code></pre>
<h4>类的定义</h4>
<p>使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾，如下实例：</p>
<pre><code>class ClassName:
'类的帮助信息' #类文档字符串
class_suite #类体
</code></pre>
<p>类的帮助信息可以通过 ClassName.<code>__doc__</code> 查看，class_suite 由类成员，方法，数据属性组成。如：</p>
<pre><code>class Test:
&quot;这是一个测试类&quot;
def __init__(self):
self.__ivalue = 5
def getvalue(self):
return self.__ivalue
</code></pre>
<p>其中，<code>__init__</code> 为初始化函数，相当于构造函数。</p>
<p><strong>访问权限：</strong></p>
<ul>
<li><code>__foo__</code>：定义的是特殊方法，一般是系统定义名字，类似 <code>__init__</code>() 之类的。</li>
<li><code>_foo</code>：以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *。</li>
<li><code>__foo</code>：双下划线的表示的是私有类型（private）的变量，只能是允许这个类本身进行访问了。</li>
</ul>
<p><strong>类的继承：</strong></p>
<p>继承的语法结构如下：</p>
<pre><code>class 派生类名（基类名）：
类体
</code></pre>
<p>Python 中继承中的一些特点：</p>
<ul>
<li>在继承中基类的构造（<code>__init__()</code> 方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。</li>
<li>在调用基类的方法时，需要使用 super() 前缀。</li>
<li>Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找（先在本类中查找调用的方法，找不到才去基类中找）。</li>
</ul>
<p>如果在继承元组中列了一个以上的类，那么它就被称作“多重继承”。</p>
<p><strong>基础重载方法</strong></p>
<p>Python 的类中有很多内置的方法，我们可以通过重写这些方法来实现一些特殊的功能，这些方法有：</p>
<table>
<thead>
<tr>
<th align="left">序号</th>
<th align="left">方法</th>
<th align="left">描述</th>
<th align="left">简单的调用</th>
</tr>
</thead>
<tbody>
<tr>
<td align="left">1</td>
<td align="left"><code>__init__</code>(self [,args…] )</td>
<td align="left">构造函数</td>
<td align="left">obj = className(args)</td>
</tr>
<tr>
<td align="left">2</td>
<td align="left"><code>__del__</code>(self)</td>
<td align="left">析构方法, 删除一个对象</td>
<td align="left">del obj</td>
</tr>
<tr>
<td align="left">3</td>
<td align="left"><code>__repr__</code>(self)</td>
<td align="left">转化为供解释器读取的形式</td>
<td align="left">repr(obj)</td>
</tr>
<tr>
<td align="left">4</td>
<td align="left"><code>__str__</code>(self)</td>
<td align="left">用于将值转化为适于人阅读的形式</td>
<td align="left">str(obj)</td>
</tr>
<tr>
<td align="left">5</td>
<td align="left"><code>__cmp__</code>(self, x)</td>
<td align="left">对象比较</td>
<td align="left">cmp(obj, x)</td>
</tr>
</tbody>
</table>
<h4>Demo 让你顿悟</h4>
<p>我们将一段 Java 的代码对应到 Python 中来实现，进行对比阅读，相信很快就能明白其中的用法。Java 代码如下：</p>
<pre><code class="language-java">class Person {
public static int visited;
Person(String name, int age, float height) {
this.name = name;
this.age = age;
this.height = height;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void showInfo() {
System.out.println(&quot;name:&quot; + name);
System.out.println(&quot;age:&quot; + age);
System.out.println(&quot;height:&quot; + height);
System.out.println(&quot;visited:&quot; + visited);
Person.visited ++;
}
private String name;
protected int age;
public float height;
}
class Teacher extends Person {
Teacher(String name, int age, float height) {
super(name, age, height);
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public void showInfo() {
System.out.println(&quot;title:&quot; + title);
super.showInfo();
}
private String title;
}
public class Test {
public static void main(String args[]) {
Person tony = new Person(&quot;Tony&quot;, 25, 1.77f);
tony.showInfo();
System.out.println();
Teacher jenny = new Teacher(&quot;Jenny&quot;, 34, 1.68f);
jenny.setTitle(&quot;教授&quot;);
jenny.showInfo();
}
}
</code></pre>
<p>对应的 Python 代码：</p>
<pre><code class="language-python">class Person:
&quot;人&quot;
visited = 0
def __init__(self, name, age, height):
self.__name = name
self._age = age
self.height = height
def getName(self):
return self.__name
def getAge(self):
return self._age
def showInfo(self):
print(&quot;name:&quot;, self.__name)
print(&quot;age:&quot;, self._age)
print(&quot;height:&quot;, self.height)
print(&quot;visited:&quot;, self.visited)
Person.visited = Person.visited +1
class Teacher(Person):
&quot;老师&quot;
def __init__(self, name, age, height):
super().__init__(name, age, height)
self.__title = None
def getTitle(self):
return self.__title
def setTitle(self, title):
self.__title = title
def showInfo(self):
print(&quot;title:&quot;, self.__title)
super().showInfo()
def testPerson():
&quot;测试方法&quot;
tony = Person(&quot;Tony&quot;, 25, 1.77)
tony.showInfo()
print();
jenny = Teacher(&quot;Jenny&quot;, 34, 1.68);
jenny.setTitle(&quot;教授&quot;);
jenny.showInfo();
testPerson()
</code></pre>
<p>自己测试一下，会发现结果是一样的：</p>
<pre><code>name: Tony
age: 25
height: 1.77
visited: 0
title: 教授
name: Jenny
age: 34
height: 1.68
visited: 1
</code></pre>
<h3>重要说明</h3>
<ul>
<li>为了降低程序复杂度，本系列文章中用到的所有示例代码均不考虑多线程安全，望借鉴 Demo 的读者注意。</li>
<li>本系列所有 Demo 均是在 Python 3.6.3 下编写的，Python 3.0 以上应该都可以正常运行。</li>
</ul>
</div>
</div>
<div>
<div style="float: right">
<a href="/专栏/白话设计模式 28 讲（完）/01 监听模式：坑爹的热水器.md.html">下一页</a>
</div>
</div>
</div>
</div>
</div>
</div>
<a class="off-canvas-overlay" onclick="hide_canvas()"></a>
</div>
<script defer src="https://static.cloudflareinsights.com/beacon.min.js/v652eace1692a40cfa3763df669d7439c1639079717194" integrity="sha512-Gi7xpJR8tSkrpF7aordPZQlW2DLtzUlZcumS8dMQjwDHEnw9I7ZLyiOj/6tZStRBGtGgN6ceN6cMH8z7etPGlw==" data-cf-beacon='{"rayId":"70997b78486b3cfa","version":"2021.12.0","r":1,"token":"1f5d475227ce4f0089a7cff1ab17c0f5","si":100}' crossorigin="anonymous"></script>
</body>
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-NPSEEVD756"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag() {
dataLayer.push(arguments);
}
gtag('js', new Date());
gtag('config', 'G-NPSEEVD756');
var path = window.location.pathname
var cookie = getCookie("lastPath");
console.log(path)
if (path.replace("/", "") === "") {
if (cookie.replace("/", "") !== "") {
console.log(cookie)
document.getElementById("tip").innerHTML = "<a href='" + cookie + "'>跳转到上次进度</a>"
}
} else {
setCookie("lastPath", path)
}
function setCookie(cname, cvalue) {
var d = new Date();
d.setTime(d.getTime() + (180 * 24 * 60 * 60 * 1000));
var expires = "expires=" + d.toGMTString();
document.cookie = cname + "=" + cvalue + "; " + expires + ";path = /";
}
function getCookie(cname) {
var name = cname + "=";
var ca = document.cookie.split(';');
for (var i = 0; i < ca.length; i++) {
var c = ca[i].trim();
if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
}
return "";
}
</script>
</html>
Reference in New Issue View Git Blame Copy Permalink