继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。
继承
任何类都可以直接或间接的继承自object类。object类是一切类的超类。默认是继承object类。
1
2
|
class Animal(object):
pass
|
和
是一样的。都是继承自object类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class Animal:
#类属性
name = "Animal"
#父类中的方法
def run(self):
print('Animal is running...')
#定义子类Dog，继承自Animal
class Dog(Animal):
#子类中的方法
def wanwan(self):
print('Dog is wanwan...')
d = Dog()
d.run() # 调用继承的Animal类的方法
d.wanwan() # 调用本身的方法
print(d.name) # 打印继承的类属性
a = Animal()
print(a.name) # 打印类属性
|
执行以上程序会输出如下结果：
1
2
3
4
|
Animal is running...
Dog is wanwan...
Animal
Animal
|
base属性
此属性用来记录类的父类。
1
2
3
4
5
6
7
8
9
|
class Animal:
pass
class Dog(Animal):
pass
print(Animal.__base__) # 打印Animal的父类
print(Dog.__base__) # 打印Dog的父类
print(Dog.__base__.__base__) # 打印Dog的父类的父类，也就是Animal的父类
|
结果是
1
2
3
|
<class 'object'>
<class '__main__.Animal'>
<class 'object'>
|
bases
此属性用来记录类对象的基类的元组。
1
2
3
4
5
6
7
8
|
class Animal:
pass
class Dog(Animal):
pass
print(Animal.__bases__) # 打印Animal父类的元组
print(Dog.__bases__) # 打印Dog的父类的元组
|
结果是
1
2
|
(<class 'object'>,)
(<class '__main__.Animal'>,)
|
构造函数init()的继承
python默认子类是不继承父类的构造函数。
1
2
3
4
5
6
7
8
9
10
11
|
class Animal:
def __init__(self,name):
self.name = name
print("Animal对象初始化完成")
class Dog(Animal):
def __init__(self,name):
self.name = name
print("Dog对象初始化完成")
d = Dog("Dog")
|
执行以上程序会输出如下结果：
Dog对象初始化完成
继承父类构造函数，必须显式声明。有两种写法(推荐2)。
- 父类名称.__init__(self,参数1，参数2，…)
super().__init__(参数1，参数2，….)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Animal:
def __init__(self,name):
self.name = name
print("Animal对象初始化完成")
class Dog(Animal):
def __init__(self,name):
print("Dog对象初始化开始")
Animal.__init__(self,"Animal") #相当于super().__init__("Animal")
self.name = name
print("Dog对象初始化完成")
a = Animal("Animal")
d = Dog("Dog")
|
执行以上程序会输出如下结果：
1
2
3
4
|
Animal对象初始化完成
Dog对象初始化开始
Animal对象初始化完成
Dog对象初始化完成
|
覆盖：override
是指在有继承派生关系的类中，子类中实现了与基类（超类）同名的方法，在子类实例调用方法时，实际调用的是子类中的覆盖版本，这种现象叫做覆盖。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class Animal:
def __init__(self,name):
self.name = name
print("Animal对象初始化完成")
#父类中的方法
def run(self):
print('Animal is running...')
#定义子类Dog，继承自Animal
class Dog(Animal):
def __init__(self,name):
print("Dog对象初始化开始")
Animal.__init__(self,"Animal") #相当于super().__init__("Animal")
self.name = name
print("Dog对象初始化完成")
#子类中的方法
def wanwan(self):
print('Dog is wanwan...')
#子类 重构方法
def run(self):
print('Dog is running...')
a = Animal("Animal")
d = Dog("Dog")
a.run()
d.run()
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
|
Animal对象初始化完成
Dog对象初始化开始
Animal对象初始化完成
Dog对象初始化完成
Animal is running...
Dog is running...
|
类属性修改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
class Animal:
#父类属性age
age = 0
#父类属性name
name = "Animal"
#定义子类Dog，继承自Animal
class Dog(Animal):
#覆盖父类的属性name
name = "Dog"
a = Animal()
d = Dog()
print(a.age) # 打印Animal的类属性
print(d.age) # 打印继承自父类的属性
print(a.name) # 打印Animal的类属性
print(d.name) # 打印Dog类覆盖的属性
Animal.age = 100 # 父类age属性重新赋值
print(a.age) # 重新复制后，打印Animal的类属性
print(d.age) # 重新复制后，打印Dog类属性
Animal.name = "Animal's name" # 父类name属性重新赋值
print(a.name) # 重新复制后，打印Animal的类属性
print(d.name) # 重新复制后，打印Dog类覆盖的属性
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
|
0
0
Animal
Dog
100
100
Animal's name
Dog
|
从上面的实验可以看出，子类继承父类后，初始状态下，继承了父类的属性。
当在子类中修改继承过来的类属性时，并不会修改父类的同名类属性。以后只要是通过子类访问该属性，访问的都是子类的属性；
通过父类修改了父类属性后，子类访问该属性时，会访问父类修改后的属性值。前提是子类没有对该属性重新赋值过，如果子类修改过该属性，则会遵循上面的规则
转载请注明本网址。