面向对象的三大特性

面向对象的特性：封装，继承，多态

封装

封装是将类中的某些部分（某些属性或者方法）隐藏起来，对象不能直接使用隐藏起来的属性或者方法，具有保护功能。
1.私有属性格式 ： __属性名=值
在类的外部不能使用（对象不能调用私有属性）
2.私有方法：在方法前添加__
私有方法的作用：就是在开发的过程中保护核心代码
在类的外部不能使用（对象不能调用私有方法）
3.私有化封装后的限制
类中 可以访问
类外/对象外 不可以访问
子类/子类对象 不可以访问

class Girl():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(self.name,self.age)
zs=Girl("张三",18)
zs.show()
# print(zs.__age)#在类的外部不可以调用私有属性，否则会报错

继承

继承就是让类和类之间产生父子关系，子类可以拥有父类的静态属性和方法
【继承就是可以获取一个类中的静态属性和普通方法。（并非所有成员）】
父类：用于被继承的类，称之为父类，也叫基类，或者超类
子类：继承其他类的类，称之为子类，也叫做派生类。
1.继承可以提高代码的重用率

class Animal():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def jiao(self):
        print("叫")
    def eat(self):
        print("吃")
class Cat(Animal):
    def climb(self):
        print("爬")
class Dog(Animal):
    def swimming(self):
        print("游泳")
c=Cat("加菲猫",7,"母")
d=Dog("拉布拉多",8,"公")
c.jiao()
c.climb()
d.eat()
d.swimming()

结果：叫 爬 吃 游泳

查看继承的父类

print(Cat.__bases__)#(<class '__main__.Animal'>,)
print(Animal.__bases__)#(<class 'object'>,)

2.子类和父类相同的时候，子类覆盖父类(方法的重写)

class A():
    def hehe(self):
        print("A:呵呵")
class B(A):
    def hehe(self):
        print("B:呵呵")
a=A()
b=B()
a.hehe()
b.hehe()

结果：A:呵呵
B:呵呵

3.覆写的代码会覆盖父类的对象，用super调用父类

class Animal():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Cat(Animal):
    def jiao(self):
        print("喵喵")
    def __init__(self,name,age,speed):
        self.s=speed
        super().__init__(name,age)
class Dog(Animal):
    def jiao(self):
        print("汪汪")
    def __init__(self,name,age,height):
        self.h=height
        super().__init__(name,age)
c=Cat("波斯猫",4,"345公里")
d=Dog("小黑",7,1.98)
c.jiao()
d.jiao()

结果： 喵喵 汪汪

4.派生属性，子类可以添加属性，对象调用的时候将调用自己的属性，需要注意的是如果添加的属性和父类属性相同，再调用的时候将调用子类的属性，这种现象叫做属性的覆盖。

class A():
    num=4
    __num=2
    def __init__(self,x,y):
        self.x=x
        self.y=y
class B(A):
    num=10
    def __init__(self,x,y,z):
        self.z=z
        super().__init__(x,y)
b=B(1,2,4)
print(b.x)
print(B.num)
print(A.num)
print(super(B,b).num)

结果：1 10 4 4

5.多继承：一个子类可以继承多个父类，就是多继承，并且拥有所有父类的属性和方法。
被继承的父类顺序靠前的优先被继承

class A():
    def tx(self):
        print("A:t1")
class B():
    def tx(self):
        print("B:t2")
class C(A,B):
    def t(self):
        print("C:t3")
c=C()
c.tx()

结果：A:t1

钻石继承，对于定义的每一个类，Python会计算出一方法解析顺序MRO列表，这个MRO列表就是一个简单的所有基类的线性顺序列表。
MRO列表遵循三大准则：1.子类会先于父类被检查
2.多个父类会根据他们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择，选择第一个父类

class A():
    def __init__(self):
        print("A:开始")
        print("A:结束")
class B(A):
    def __init__(self):
        print("B:开始")
        super().__init__()
        print("B:结束")
class C(A):
    def __init__(self):
        print("C:开始")
        super().__init__()
        print("C:结束")
class D(B,C):
    def __init__(self):
        print("D:开始")
        super().__init__()
        print("D:结束")
d=D()

结果：D:开始 B:开始 C:开始 A:开始 A:结束 C:结束 B:结束 D:结束

多态

声明的形参的时候是父类对象，实际运行的时候是子类对象

class Ali():
    def pay(self,money):
        print("阿里支付",money)
class WeiXin():
    def pay(self,money):
        print("微信支付",money)
class Person():
    def consum(self,pay,money):
        pay.pay(money)
ali=Ali()
wx=WeiXin()
p=Person()
p.consum(ali,120)
p.consum(wx,230)

结果：阿里支付 120
微信支付 230