面向对象三大特性之——继承
Posted wyh0717
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象三大特性之——继承相关的知识,希望对你有一定的参考价值。
面向对象三大特性之——继承
继承 -- 需要解决代码的重复
继承语法:
class A:
pass
class B(A):
pass
B继承A,A是父类,B是子类
A是父类(基类 超类)
B是子类(派生类)
子类可以使用父类中的 : 方法 静态变量
class Animal:
def __init__(self,name):
self.name = name
def eat(self):
print(‘%s is eating‘%self.name)
def drink(self):
print(‘%s is drinking‘%self.name)
def sleep(self):
print(‘%s is sleeping‘%self.name)
class Cat(Animal):
def climb_tree(self):
print(‘%s is climbing‘%self.name)
class Dog(Animal):
def house_keep(self):
print(‘%s house keeping‘%self.name)
小白 = Cat(‘小白‘)
先开辟空间,空间里有一个类指针-->指向Cat
调用init,对象在自己的空间中找init没找到,到Cat类中找init也没找到,
找父类Animal中的init
小白.eat()
小白.climb_tree()
小黑 = Dog(‘小黑‘)
小黑.eat()
当子类和父类的方法重名的时候,我们只使用子类的方法,而不会去调用父类的方法了
class Animal:
def __init__(self,name):
self.name = name
def eat(self):
print(‘%s is eating‘%self.name)
def drink(self):
print(‘%s is drinking‘%self.name)
def sleep(self):
print(‘%s is sleeping‘%self.name)
class Cat(Animal):
def eat(self):
print(f‘{self.name}吃猫粮‘)
def climb_tree(self):
print(‘%s is climbing‘%self.name)
xbai = Cat(‘小白‘)
xbai.eat() #小白吃猫粮
子类想要调用父类的方法的同时还想执行自己的同名方法
猫和狗在调用eat的时候既调用自己的也调用父类的,
在子类的方法中调用父类的方法 :父类名.方法名(self)
class Animal:
def __init__(self,name,food):
self.name = name
self.food = food
self.blood = 100
self.waise = 100
def eat(self):
print(‘%s is eating %s‘%(self.name,self.food))
def drink(self):
print(‘%s is drinking‘%self.name)
def sleep(self):
print(‘%s is sleeping‘%self.name)
class Cat(Animal):
def eat(self):
self.blood += 100
Animal.eat(self)
def climb_tree(self):
print(‘%s is climbing‘%self.name)
self.drink()
class Dog(Animal):
def eat(self):
self.waise += 100
Animal.eat(self)
def house_keep(self):
print(‘%s is keeping the house‘%self.name)
小白 = Cat(‘小白‘,‘猫粮‘)
小黑 = Dog(‘小黑‘,‘狗粮‘)
小白.eat()#小白 is eating 猫粮
小黑.eat()#小黑 is eating 狗粮
print(小白.__dict__)#{‘name‘: ‘小白‘, ‘food‘: ‘猫粮‘, ‘blood‘: 200, ‘waise‘: 100}
print(小黑.__dict__)#{‘name‘: ‘小黑‘, ‘food‘: ‘狗粮‘, ‘blood‘: 100, ‘waise‘: 200}
继承语法 class 子类名(父类名):pass
父类和子类方法的选择:
子类的对象,如果去调用方法:
永远优先调用自己的
如果自己有 用自己的
自己没有 用父类的
如果自己有 还想用父类的 : 直接在子类方法中调父类的方法 父类名.方法名(self)
思考一:下面代码的输出?
class Foo:
def __init__(self):
self.func() # 在每一个self调用func的时候,我们不看这句话是在哪里执行,只看self是谁
def func(self):
print(‘in foo‘)
class Son(Foo):
def func(self):
print(‘in son‘)
Son() #in son
# 思考二: 如果想给狗和猫定制个性的属性
class Animal:
def __init__(self,name,food):
self.name = name
self.food = food
self.blood = 100
self.waise = 100
def eat(self):
print(‘%s is eating %s‘%(self.name,self.food))
def drink(self):
print(‘%s is drinking‘%self.name)
def sleep(self):
print(‘%s is sleeping‘%self.name)
class Cat(Animal):
def __init__(self,name,food,eye_color):
Animal.__init__(self,name,food) # 调用了父类的初始化,去完成一些通用属性的初始化
self.eye_color = eye_color # 派生属性
# 猫 : eye_color眼睛的颜色
# 狗 : size型号
小白 = Cat(‘小白‘,‘猫粮‘,‘蓝色‘)
print(小白.__dict__)
多继承 有好几个爹
# 有一些语言不支持多继承 java
# python语言的特点 : 可以在面向对象中支持多继承
class B:
def func(self):
print(‘in B‘)
class A :
def func(self):
print(‘in A‘)
class C(B,A):
pass
C().func() #in B
# 单继承
# 调子类的 : 子类自己有的时候
# 调父类的 : 子类自己没有的时候
# 调子类和父类的 :子类父类都有,在子类中调用父类的
# 多继承
# 一个类有多个父类,在调用父类方法的时候,按照继承顺序,先继承的就先寻找
object类- 类祖宗
所有在python3当中的类都是继承object类的
object中有init
所有的类都默认的继承object
class A:pass
print(A.__bases__)#(<class ‘object‘>,)
class C:pass
class B(A,C):pass
print(B.__bases__)#(<class ‘__main__.A‘>, <class ‘__main__.C‘>)
# 绑定方法和普通的函数
from types import FunctionType,MethodType
# FunctionType : 函数
# MethodType : 方法
# isinstance type
a= 1
b = ‘asb‘
print(isinstance(a,int)) #判断a 是int 类型吗 True
print(isinstance(b,float))#判断a 是int 类型吗 False
class Cat:
pass
bai = Cat()
print(type(bai))#<class ‘__main__.Cat‘>
print(isinstance(bai,Cat))#True
from types import FunctionType,MethodType
# FunctionType : 函数
# MethodType : 方法
class A:
def func(self):
print(‘in func‘)
print(A.func) # 函数
a = A()
print(a.func) # 方法
print(isinstance(a.func,FunctionType))#False
print(isinstance(a.func,MethodType))#True
print(isinstance(A.func,FunctionType))#True
print(isinstance(A.func,MethodType))#False
class A:
role = ‘法师‘
def func1(self):pass
def func2(self):pass
class B:pass
class C(B,A):pass
# print(A.__base__)#<class ‘object‘>
# print(C.__bases__)#(<class ‘__main__.B‘>, <class ‘__main__.A‘>)
# print(C.__base__)#<class ‘__main__.B‘>
#
# print(A.__dict__)
print(A.__name__)#A
print(A.__class__)#<class ‘type‘>
print(B.__class__)
# print(C.__class__)
print(C.__module__)#__main__
以上是关于面向对象三大特性之——继承的主要内容,如果未能解决你的问题,请参考以下文章