Python基础---面向对象2
事物之间都会存在一些相对应的关系,在面向对象中,类与类之间存在着以下关系:
依赖关系
关联,组合,聚合关系,
实现关系,继承关系
01.依赖关系:
将一个类的类名或对象传入到另一个类的方法中
例1. 设计一个场景:把大象装进冰箱,这个场景中存在两个事物,一个是大象,另一个是冰箱
class Elephant: def __init__(self,name): self.name = name def open(self,obj): print('%s说:开门'%(self.name))
obj.be_opened() def close(self,obj): print('%s说:关门'%(self.name))
obj.be_closed() class Refrigerator: def __init__(self,name): self.name = name def be_opened(self): print('%s被打开了'%(self.name)) def be_closed(self): print('%s被关闭了'%(self.name)) ele_obj = Elephant('猛犸') haier = Refrigerator('海尔') xinfei = Refrigerator('新飞')
# 将冰箱类的实例化对象,传到大象类的方法中
ele_obj.open(haier)
ele_obj.close(haier)
02.组合关系:
组合:将一个类的对象或类名,封装到另一个类的对象的属性中
例2. 设计一个场景,男女朋友
class Boy: def __init__(self,name,gf = None): self.name = name self.gf = gf def have_dinner(self): if self.gf: print('%s和女朋友%s一起共度晚餐'%(self.name,self.gf.name)) else: print('%s自己一个玩'%(self.name)) class Girl: def __init__(self,name): self.name = name allen = Boy('allen') ruhua = Girl('如花') allen.gf = ruhua # self.gf 拿到的是一个内存地址 allen.have_dinner() # allen和女朋友如花一起共进晚餐
例3. 游戏人物相互攻击
class GameRole: def __init__(self,name,ad,hp): self.name = name self.ad = ad self.hp = hp def equipment(self,wea): self.wea = wea # 给人物对象封装一个属性,这个属性是武器类的实例化对象 class Weapon: def __init__(self,name,ad): self.name = name self.ad = ad def wea_attack(self,p1,p2): p2.hp -= p1.ad+self.ad print('%s用%s攻击了%s,%s掉了%s血,还有%s血'% (p1.name, self.name, p2.name, p2.name,p1.ad+self.ad, p2.hp )) # 实例化人物对象
yasuo = GameRole('亚索',20,200) mumu = GameRole('木木',10,200) # 实例化武器对象 sword = Weapon('太刀',10) hammer = Weapon('锤子',10) # 给人物封装武器属性 yasuo.wea = sword mumu.wea = hammer yasuo.wea.wea_attack(yasuo,mumu) mumu.wea.wea_attack(mumu.attack)
03.继承关系:
3.1.单继承
3.1.1通过类名或对象执行父类方法:
class Animal:
type_name = '动物类'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print('in Animal eat')
class Person(Animal):
pass
1.执行父类方法
# 类名调用:
print(Person.eat(123))
print(Person.type_name)
# 对象调用:
obj = Person('小一',18,'男')
obj.eat() # in Animal eat
obj.type_name = '123'
print(obj.__dict__) # {'name':'小一','age':18,'sex':男,'type_name':'123'}
执行步骤:
(1)实例化对象obj,执行__init__方法,子类空间没有,就去父类空间找,父类空间如果没有,就继续往上找(python3中的父类默认为object)
(2)obj.eat(),先执行子类空间中的eat方法,没有就去父类空间中找
3.1.2同时执行子类和父类的方法:
class Animal:
def __init__(self,name,age):
self.name = name
self.age = age
def func(self):
print('in Animal func')
class Person(Animal):
def func():
Animal.func(self) # 类名.方法名时,必须要传参
super().func() # super方法,func()中不用传参数
print('in Person func')
p1 = Person('小一',18)
p1.func() in Animal func in Person func
3.1.3同时执行子类和父类的__init__方法:
class Animal: def __init__(self,name,age): self.name = name self.age = age class Person(Animal): def __init__(self,name,age,sex): Animal.__init__(self,name,age) super().__init__(name,age) self.sex = sex p1 = Person('小一',18,'男') print(p1.__dict__) {'name':'小一','age':18,'sex':'男'}
3.1.4 super( )方法:
完全按照对象所在类的mro顺序执行,在多继承中,super(指定类名,self).方法名(),super中指定的类会被跳过,执行mro的下一个顺序的类的方法
class A:
def func1(self):
print('in A func1')
class B(A):
def func1(self):
super(B, self).func1() 跳过B,执行C
print('in B func1')
class C(A):
def func1(self):
print('in C func1')
class D(B,C):
def func1(self):
super(D, self).func1() 跳过D,执行B
print('in D func1')
obj = D()
obj.func1()
print(D.mro()) 继承顺序:D.B.C.A
3.2多继承
3.2.1 python中类的分类: 经典类,新式类
py2x版本中: py2.2之前只有经典类,不继承object类,遵循的是深度优先原则,从左至右一条路走到黑
py2.2之后,出现新式类,继承object类,遵循C3算法,mro顺序
py3x版本中: 所有的类都默认继承object类
3.2.2 经典类的多继承:
深度优先原则,从左至右一条路走到黑
mro顺序: Foo --> H --> G --> F --> E --> D --> B --> A --> C
3.2.3 新式类的多继承: 当两个父类出现了重名的方法时,遵循C3算法,mro顺序
(1)mro序列: 是一个有序的列表,在类被创建时就会计算出来
通用公式为:mro(Child(Base1,Base2)) = [Child] + merge(mro(Base1),mro(Base2),[Base1,Base2])
(2)继承至一个基类: classB(A)
mro(B) = mro(B(A)) = [B] + merge(mro(A),[A]) = [B] + merge([A]+[A]) = [B,A]
(3)继承至多个基类: classB(A1,A2,A3...)
mro(B) = merge(B(A1,A2,A3...)) = [B] + merge(mro(A1),mro(A2),mro(A2)...[A1,A2,A3...])
= ...
(4)表头和表尾:
表头: 列表的第一个元素
表尾: 除第一个元素外其他元素
如计算merge( [E,O], [C,E,F,O], [C] ) 1 2 3 01.merge不为空，取出第一个列表列表1的表头E，进行判断 各个列表的表尾分别是[O], [E,F,O]，E在这些表尾的集合中，因而跳过当前当前列表 02.取出列表2的表头C，进行判断 C不在各个列表的集合中，因而将C拿出到merge外，并从所有表头删除 merge( [E,O], [C,E,F,O], [C] ) = [C] + merge( [E,O], [E,F,O]) 03.进行下一次新的merge操作 ......
例:
mro(A) = mro(A(B,C)) = [A] + merge(mro(B),mro[C],[B,C]) mro(B) = mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E]) = [B] + merge([D,O],[E,O],[D,E]) = [B] + [D] + merge([O],[E,O],[E]) = [B,D,E] + merge([O]) = [B,D,E,O]
mro(C) = mro(C(E,F)) = [C,E,F,O]
mro(A) = [A] + merge([B,D,E,O] + [C,E,F,O] + [B,C])
= [A,B] + merge([D,E,O] + [C,E,F,O] + [C])
= [A,B,D] + merge([E,O] + [C,E,F,O] + [C])
= [A,B,D,C] + merge([E,O] + [E,F,O])
= [A,B,D,C,E] + merge([O] + [F,O])
= [A,B,D,C,E,F,O]
4.面向对象的三大特性:封装,继承,多态
封装:隐藏对象的属性和实现细节，仅对外提供公共访问方式。
优点:便于使用,提高复用性和安全性
继承:可以使子类具有父类的各种属性和方法,而且不需要再次编写相同的代码,在子类继承父类的同时,可以重新定义某些属性,重写某些方法,即覆盖父类中原有的属性和方法,使子类具有不同于父类的功能,此外,给子类追加新的属性和方法也是很常见的做法.
继承的优点: 增强代码的耦合性,减少重复代码,使代码更加规范化,合理化
多态:指一类事物有多种形态.python默认支持多态,一个变量可以是多种数据类型
鸭子类型: 如果看起来是鸭子,那它就是鸭子,两个类虽没有任何关系,但隐形中遵循了一个标准
优点:1.统一标准,减少了词汇量,建立了一种弱关联;2.两个类没有任何的耦合性,但是可以产生关系,A的对象会使用B类的方法
