什么是继承
继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。
子类会“”遗传”父类的属性，从而解决代码重用问题（比如练习7中Garen与Riven类有很多冗余的代码）
python中类的继承分为：单继承和多继承
class
ParentClass1
:
#定义父类
pass
class
ParentClass2
:
#定义父类
pass
class
SubClass1
(
ParentClass1
)
:
#单继承，基类是ParentClass1，派生类是SubClass
pass
class
SubClass2
(
ParentClass1
,
ParentClass2
)
:
#python支持多继承，用逗号分隔开多个继承的类
pass
查看继承
>>
>
SubClass1
.
__bases__
#__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(
<
class
'__main__.ParentClass1'
>
,
)
>>
>
SubClass2
.
__bases__
(
<
class
'__main__.ParentClass1'
>
,
<
class
'__main__.ParentClass2'
>
)
继承与抽象（先抽象再继承）
继承描述的是子类与父类之间的关系，是一种什么是什么的关系。要找出这种关系，必须先抽象再继承
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1 将奥巴马和梅西这俩对象比较像的部分抽取成类；
2 将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，==让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，==实现代码重用
class
Hero
:
def
__init__
(
self
,
nickname
,
aggressivity
,
life_value
)
:
self
.
nickname
=
nickname
self
.
aggressivity
=
aggressivity
self
.
life_value
=
life_value
def
move_forward
(
self
)
:
print
(
'%s move forward'
%
self
.
nickname
)
def
move_backward
(
self
)
:
print
(
'%s move backward'
%
self
.
nickname
)
def
move_left
(
self
)
:
print
(
'%s move forward'
%
self
.
nickname
)
def
move_right
(
self
)
:
print
(
'%s move forward'
%
self
.
nickname
)
def
attack
(
self
,
enemy
)
:
enemy
.
life_value
-=
self
.
aggressivity
class
Garen
(
Hero
)
:
pass
class
Riven
(
Hero
)
:
pass
g1
=
Garen
(
'草丛伦'
,
100
,
300
)
r1
=
Riven
(
'锐雯雯'
,
57
,
200
)
print
(
g1
.
life_value
)
r1
.
attack
(
g1
)
print
(
g1
.
life_value
)
'''
运行结果
'''
注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找…直到最顶级的父类。
派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）， 需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
class
Riven
(
Hero
)
:
camp
=
'Noxus'
def
attack
(
self
,
enemy
)
:
#在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
print
(
'from riven'
)
def
fly
(
self
)
:
#在自己这里定义新的
print
(
'%s is flying'
%
self
.
nickname
)
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值
class
Riven
(
Hero
)
:
camp
=
'Noxus'
def
__init__
(
self
,
nickname
,
aggressivity
,
life_value
,
skin
)
:
Hero
.
__init__
(
self
,
nickname
,
aggressivity
,
life_value
)
#调用父类功能
self
.
skin
=
skin
#新属性
def
attack
(
self
,
enemy
)
:
#在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
Hero
.
attack
(
self
,
enemy
)
#调用功能
print
(
'from riven'
)
def
fly
(
self
)
:
#在自己这里定义新的
print
(
'%s is flying'
%
self
.
nickname
)
r1
=
Riven
(
'锐雯雯'
,
57
,
200
,
'比基尼'
)
r1
.
fly
(
)
print
(
r1
.
skin
)
'''
运行结果
锐雯雯 is flying
比基尼
'''
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，
1.继承的方式
通过继承建立了派生类与基类之间的关系，它是一种’是’的关系，比如白马是马，人是动物。
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人
2.组合的方式
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3…
class
People
:
def
__init__
(
self
,
name
,
age
,
sex
)
:
self
.
name
=
name
self
.
age
=
age
self
.
sex
=
sex
class
Course
:
def
__init__
(
self
,
name
,
period
,
price
)
:
self
.
name
=
name
self
.
period
=
period
self
.
price
=
price
def
tell_info
(
self
)
:
print
(
'<%s %s %s>'
%
(
self
.
name
,
self
.
period
,
self
.
price
)
)
class
Teacher
(
People
)
:
def
__init__
(
self
,
name
,
age
,
sex
,
job_title
)
:
People
.
__init__
(
self
,
name
,
age
,
sex
)
self
.
job_title
=
job_title
self
.
course
=
[
]
self
.
students
=
[
]
class
Student
(
People
)
:
def
__init__
(
self
,
name
,
age
,
sex
)
:
People
.
__init__
(
self
,
name
,
age
,
sex
)
self
.
course
=
[
]
egon
=
Teacher
(
'egon'
,
18
,
'male'
,
'沙河霸道金牌讲师'
)
s1
=
Student
(
'牛榴弹'
,
18
,
'female'
)
python
=
Course
(
'python'
,
'3mons'
,
3000.0
)
linux
=
Course
(
'lunix'
,
'3mons'
,
3000.0
)
#为老师egon和学生s1添加课程
egon
.
course
.
append
(
python
)
egon
.
course
.
append
(
linux
)
s1
.
course
.
append
(
python
)
#为老师egon添加学生s1
egon
.
students
.
append
(
s1
)
#使用
for
obj
in
egon
.
course
:
obj
.
tell_info
(
)
#输出：
#
接口与归一化设计
什么是接口
==
==
==
==
==
==
==
==
=
第一部分：Java 语言中的接口很好的展现了接口的含义
:
IAnimal
.
java
/*
* Java的Interface接口的特征:
* 1)是一组功能的集合,而不是一个功能
* 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作
* 3)接口只定义函数,但不涉及函数实现
* 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */
package
com
.
oo
.
demo
;
public
interface
IAnimal
{
public
void
eat
(
)
;
public
void
run
(
)
;
public
void
sleep
(
)
;
public
void
speak
(
)
;
}
==
==
==
==
==
==
==
==
=
第二部分：Pig
.
java：猪”的类设计
,
实现了IAnnimal接口
package
com
.
oo
.
demo
;
public
class
Pig
implements
IAnimal
{
//如下每个函数都需要详细实现
public
void
eat
(
)
{
System
.
out
.
println
(
"Pig like to eat grass"
)
;
}
public
void
run
(
)
{
System
.
out
.
println
(
"Pig run: front legs, back legs"
)
;
}
public
void
sleep
(
)
{
System
.
out
.
println
(
"Pig sleep 16 hours every day"
)
;
}
public
void
speak
(
)
{
System
.
out
.
println
(
"Pig can not speak"
)
;
}
}
==
==
==
==
==
==
==
==
=
第三部分：Person2
.
java
/*
*实现了IAnimal的“人”,有几点说明一下:
* 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样
* 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */
package
com
.
oo
.
demo
;
public
class
Person2
implements
IAnimal
{
public
void
eat
(
)
{
System
.
out
.
println
(
"Person like to eat meat"
)
;
}
public
void
run
(
)
{
System
.
out
.
println
(
"Person run: left leg, right leg"
)
;
}
public
void
sleep
(
)
{
System
.
out
.
println
(
"Person sleep 8 hours every dat"
)
;
}
public
void
speak
(
)
{
System
.
out
.
println
(
"Hellow world, I am a person"
)
;
}
}
==
==
==
==
==
==
==
==
=
第四部分：Tester03
.
java
package
com
.
oo
.
demo
;
public
class
Tester03
{
public
static
void
main
(
String
[
]
args
)
{
System
.
out
.
println
(
"===This is a person==="
)
;
IAnimal person
=
new
Person2
(
)
;
person
.
eat
(
)
;
person
.
run
(
)
;
person
.
sleep
(
)
;
person
.
speak
(
)
;
System
.
out
.
println
(
"\n===This is a pig==="
)
;
IAnimal pig
=
new
Pig
(
)
;
pig
.
eat
(
)
;
pig
.
run
(
)
;
pig
.
sleep
(
)
;
pig
.
speak
(
)
;
}
}
为何要用接口
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
继承的两种用途
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）：实践中，继承的这种用途意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
二：声明某个子类兼容于某基类，定义一个接口类（模仿java的Interface），接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
#_*_coding:utf-8_*_
__author__
=
'Linhaifeng'
#一切皆文件
import
abc
#利用abc模块实现抽象类
class
All_file
(
metaclass
=
abc
.
ABCMeta
)
:
all_type
=
'file'
@abc
.
abstractmethod
#定义抽象方法，无需实现功能
def
read
(
self
)
:
'子类必须定义读功能'
pass
@abc
.
abstractmethod
#定义抽象方法，无需实现功能
def
write
(
self
)
:
'子类必须定义写功能'
pass
# class Txt(All_file):
# pass
#
# t1=Txt() #报错,子类没有定义抽象方法
class
Txt
(
All_file
)
:
#子类继承抽象类，但是必须定义read和write方法
def
read
(
self
)
:
print
(
'文本数据的读取方法'
)
def
write
(
self
)
:
print
(
'文本数据的读取方法'
)
class
Sata
(
All_file
)
:
#子类继承抽象类，但是必须定义read和write方法
def
read
(
self
)
:
print
(
'硬盘数据的读取方法'
)
def
write
(
self
)
:
print
(
'硬盘数据的读取方法'
)
class
Process
(
All_file
)
:
#子类继承抽象类，但是必须定义read和write方法
def
read
(
self
)
:
print
(
'进程数据的读取方法'
)
def
write
(
self
)
:
print
(
'进程数据的读取方法'
)
wenbenwenjian
=
Txt
(
)
yingpanwenjian
=
Sata
(
)
jinchengwenjian
=
Process
(
)
#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian
.
read
(
)
yingpanwenjian
.
write
(
)
jinchengwenjian
.
read
(
)
print
(
wenbenwenjian
.
all_type
)
print
(
yingpanwenjian
.
all_type
)
print
(
jinchengwenjian
.
all_type
)
抽象类与接口
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
继承实现的原理
class
A
(
object
)
:
def
test
(
self
)
:
print
(
'from A'
)
class
B
(
A
)
:
def
test
(
self
)
:
print
(
'from B'
)
class
C
(
A
)
:
def
test
(
self
)
:
print
(
'from C'
)
class
D
(
B
)
:
def
test
(
self
)
:
print
(
'from D'
)
class
E
(
C
)
:
def
test
(
self
)
:
print
(
'from E'
)
class
F
(
D
,
E
)
:
# def test(self):
# print('from F')
pass
f1
=
F
(
)
f1
.
test
(
)
print
(
F
.
__mro__
)
#只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类
继承顺序
子类**中**调用父类的方法
方法一：指名道姓，即父类名.父类方法()
#_*_coding:utf-8_*_
class
Vehicle
:
#定义交通工具类
Country
=
'China'
def
__init__
(
self
,
name
,
speed
,
load
,
power
)
:
self
.
name
=
name
self
.
speed
=
speed
self
.
load
=
load
self
.
power
=
power
def
run
(
self
)
:
print
(
'开动啦...'
)
class
Subway
(
Vehicle
)
:
#地铁
def
__init__
(
self
,
name
,
speed
,
load
,
power
,
line
)
:
Vehicle
.
__init__
(
self
,
name
,
speed
,
load
,
power
)
self
.
line
=
line
def
run
(
self
)
:
print
(
'地铁%s号线欢迎您'
%
self
.
line
)
Vehicle
.
run
(
self
)
line13
=
Subway
(
'中国地铁'
,
'180m/s'
,
'1000人/箱'
,
'电'
,
13
)
line13
.
run
(
)
#输出：
#地铁13号线欢迎您
#开动啦...
方法二：super()
class
Vehicle
:
# 定义交通工具类
Country
=
'China'
def
__init__
(
self
,
name
,
speed
,
load
,
power
)
:
self
.
name
=
name
self
.
speed
=
speed
self
.
load
=
load
self
.
power
=
power
def
run
(
self
)
:
print
(
'开动啦...'
)
class
Subway
(
Vehicle
)
:
# 地铁
def
__init__
(
self
,
name
,
speed
,
load
,
power
,
line
)
:
# super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
super
(
)
.
__init__
(
name
,
speed
,
load
,
power
)
self
.
line
=
line
def
run
(
self
)
:
print
(
'地铁%s号线欢迎您'
%
self
.
line
)
super
(
)
.
run
(
)
#super()也可以传入参数
class
Mobike
(
Vehicle
)
:
# 摩拜单车
pass
line13
=
Subway
(
'中国地铁'
,
'180m/s'
,
'1000人/箱'
,
'电'
,
13
)
line13
.
run
(
)
强调：二者使用哪一种都可以，但最好不要混合使用
指名道姓与super()的区别
#指名道姓
class
A
:
def
__init__
(
self
)
:
print
(
'A的构造方法'
)
class
B
(
A
)
:
def
__init__
(
self
)
:
print
(
'B的构造方法'
)
A
.
__init__
(
self
)
class
C
(
A
)
:
def
__init__
(
self
)
:
print
(
'C的构造方法'
)
A
.
__init__
(
self
)
class
D
(
B
,
C
)
:
def
__init__
(
self
)
:
print
(
'D的构造方法'
)
B
.
__init__
(
self
)
C
.
__init__
(
self
)
pass
f1
=
D
(
)
#A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''
#使用super()
class
A
:
def
__init__
(
self
)
:
print
(
'A的构造方法'
)
class
B
(
A
)
:
def
__init__
(
self
)
:
print
(
'B的构造方法'
)
super
(
B
,
self
)
.
__init__
(
)
class
C
(
A
)
:
def
__init__
(
self
)
:
print
(
'C的构造方法'
)
super
(
C
,
self
)
.
__init__
(
)
class
D
(
B
,
C
)
:
def
__init__
(
self
)
:
print
(
'D的构造方法'
)
super
(
D
,
self
)
.
__init__
(
)
f1
=
D
(
)
#super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''
当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）
转：https://www.cnblogs.com/linhaifeng/articles/7340153.html
