高级编程继承，多态

#继承是什么

继承就是得到对应的特征，继承类型包括父类和子类

理解：父类可以传基因，子类去继承他的基因

#继承有单继承和多继承

单继承：

         一个子类继承一个父类

        注意：隐藏属性不可以继承

#创建一个父类
class Qun:
    def __init__(self):
        self.money=100000
        self.__height=180

#创建子类
class Qun1(Qun):#这里的子类Qun1继承了Qun的属性
    pass
qun1=Qun1()
print(qun1.money)

如果子类要修改，或者添加父类的属性需要super 拿到权限

注意: 私有属性不可以继承

#创建一个父类
class Qun:
    def __init__(self):
        self.money=100000
        self.__height=180

#创建子类
class Qun1(Qun):#这里的子类Qun1继承了Qun的属性
    def __init__(self):
        super(Qun1, self).__init__()
        self.house="北京"
        self.money=100
qun1=Qun1()
print(qun1.money)
print(qun1.house)

#多继承，意思就是可以继承多个父类

格式：( 父类  1, 父类2  )

补充：__mro__可以查询继承顺序

#创建一个父类
class A:
    def __init__(self):
        self.age=18
    def fun(self):
        print(f"A今年{self.age}岁了")
class B:
    def __init__(self):
        self.name="B"
    def fun1(self):
        print(f"我的名字是{self.name}")
#C继承A，B
class C(A,B):
    def __init__(self):
        super(C, self).__init__()
        self.name="B"
        self.age=18

#实例化
c=C()
#调用继承的方法
c.fun()
c.fun1()
#可以查看继承顺序
print(C.__mro__)

#多态

一个对象的多种形态，调用同一个方法表现出不同形式

遵守两个原则：1.必须要有类的继承   2.子类需要重写父类的方法

class Money:
    def ticke(self):
        print("车票单价")
class Bus(Money):
    def ticke(self):
        print("票价为150元")
class Car(Money):
    def ticke(self):
        print("票价为200元")

bus=Bus()
car=Car()
#继承之后，一个方法有不同形式
bus.ticke()
car.ticke()

#绑定

绑定（类方法）

类方法：通过装饰器@classmethod进行装饰，绑定类cls

class Student:
    #这个就是类的属性
    num=0
    def __init__(self,name):
        self.name=name
    def sleep(self):
        print(f"{self.name}在睡觉")
    @classmethod
    #类的装饰器
    #cls是类的本身
    def count(cls):
        cls.num+=1
        return cls.num
#实例化之后调用count，sleep的方法
stu1=Student("小鱼")
print(stu1.count())
stu1.sleep()

stu2=Student("小虎")
print(stu2.count())
stu2.sleep()

#静态属性，不用cls本身来操作

用@staticmetho操作

class Student:
    #这个就是类的属性
    num=0
    def __init__(self,name):
        self.name=name
    def sleep(self):
        print(f"{self.name}在睡觉")
    @staticmethod
    #类的装饰器
    #cls是类的本身
    def count():
        print("用不了cls本身，无法计算个数")
#实例化之后调用count，sleep的方法
stu1=Student("小鱼")
stu1.count()
stu1.sleep()

#内置方法

1.信息格式化方法

__str__   该方法就是用来返回文本信息的，说明类的内容

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"我可以直接返回{self.name}是{self.age}"
a=A("小鱼",16)
#这里打印类就会直接输出文本信息{我可以直接返回小鱼是16}
print(a)

2.析构方法（魔法方法）

__del__  当检测对象被引用时会自动删除占用内存

简单的来说：就是亡语，最后输出

class A:
    def __init__(self,name):
        self.name=name
    def fun(self):
        print(f"{self.name}还活着")
    def __del__(self):
        print(f"{self.name}没了")
a=A("小鱼")
#这里的内容就算先被调用也是最后输出
a.__del__()
a.fun()

__new__ 是内置的静态方法，返回一个对象的引用

new必须有返回值

那么与init有什么不同呢

相同点：都可以初识化

不同点：new可以控制初识化的多少，但是init不可以

class A:
    #先设置一个空的类私有属性
    __age=None
    def __new__(cls, *args, **kwargs):
        #这里控制空间大小
        if cls.__age==None:
            #super().__new__(cls)代表占用的内存
            cls.__age=super().__new__(cls)
            return cls.__age
    def __init__(self,naem):
        self.name=naem
a=A("小鱼")
print(a.name)
#第二个实例化就会报错，因为被限制1个内存了
b=A("小艾")
print(b.name)