Python面向对象02-封装、继承、多态

面向对象编程三大特性：继承、封装、多态

“is-a”关系(继承)&“has-a”关系(组合)

#组合测试
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
            print("计算")
class Screen:
    def show(self):
        print("显示画面")
c = CPU()
s = Screen()
m = MobilePhone(c,s)
#通过组合，我们也能调用 cpu 对象的方法。
#相当于手机对象间接拥有了“cpu 的方法”
m.cpu.calculate()
m.screen.show()

##print
计算
显示画面

封装

作用：隐藏对象的属性和实现细节，只对外提供必要的方法。
通过“私有属性、私有方法”的方式，实现“封装”。
Python语法层面无严格封装，靠编程者自觉

继承

作用：继承可以让子类具有父类的特性，提高了代码的重用性。也可以增加新的功能，或改进已有的算法

Python 支持多重继承，一个子类可以继承多个父类。

class 子类类名(父类 1[，父类 2，...])： 
	类体

1. 类定义中没有指定父类，默认父类是 object 类（定义一些所有类共有的默认实现，例如__new__()）
2. 定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
   父类名.__init__(self, 参数列表)
   因为子类并不会自动调用父类的__init__()

子类继承内容

1. 成员继承：子类继承了父类除构造方法之外的所有成员。
2. 方法重写：子类重新定义父类方法，就会覆盖父类的方法，也称为“重写”

查看类的继承层次结构MRO()

通过 类名.mro()或者类名.__mro__可以输出这个类的继承层次结构。
通过 mro()方法获得 “类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找

class A:pass
class B(A):pass
class D:pass
class C(B,D):pass
print(C.mro())
print(C.__mro__)

##print
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.D'>, <class 'object'>]
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.D'>, <class 'object'>)

super()获得父类定义

super()代表父类的定义，不是父类对象

class A:
    def say(self):
        print("A: ",self)
        print("say AAA")
class B(A):
    def say(self):
        #A.say(self) 调用父类的 say 方法
        super().say() #通过super()调用父类的方法
        print("B:",self)
        print("say BBB")
b = B()
b.say()

##print
A:  <__main__.B object at 0x00000236D98E7850>
say AAA
B: <__main__.B object at 0x00000236D98E7850>
say BBB

object 根类

object 类是所有类的父类

dir()查看对象属性

内置函数 dir()：看到指定对象所有的属性

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say_age(self):
        print(self.name,"的年龄是：",self.age)
print(dir(object()))
print(dir(Person("王明",18)))

如下为打印结果：
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'say_age']

分析可知：

1. Person 对象增加了六个属性： __dict__ __module__ __weakref__ age name say_age
2. Person 类作为 object 子类，包含所有属性
3. say_age 方法也是属性。只不过这个属性的类型是method而已

多重继承

这样会被“类的整体层次”搞的异常复杂，尽量避免使用

str()方法

object 有一个__str__()方法，用于返回一个对于“对象的描述”，内置函数str()调用的是__str__()方法。

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __str__(self):
        '''将对象转化成一个字符串，一般用于 print 方法'''
        return "名字是：{0},年龄是{1}".format(self.name,self.__age)
print(Person("ming",18))
print(str(Person("wang",20)))

##print
名字是：ming,年龄是18
名字是：wang,年龄是20

多态

作用：同一个方法调用由于对象不同会产生不同的行为。
多态要注意以下 2 点：
1. 多态是方法多态，属性没多态
2. 多态的存在有 2 个必要条件：继承、方法重写

class Animal:
    def shout(self):
        print("动物叫了一声")
class Dog(Animal):
    def shout(self):
        print("小狗，汪汪汪")
class Cat(Animal):
    def shout(self):
        print("小猫，喵喵喵")
def animalShout(a):
    if isinstance(a,Animal):
        a.shout() #传入的对象不同，shout 方法对应的实际行为也不 同。
animalShout(Dog())
animalShout(Cat())

##print
小狗，汪汪汪
小猫，喵喵喵