python——封装、继承、多态

继承

class Father:
    __secrect="xxx"
    story='从前有座山...'
    
    def tellAstory(self):
        print("我的故事：",self.story)
    
    def __tellAstory(self):
        #访问prvite属性的时候，需要使用类名进行访问
        print("我的密码：",Father.__secrect)
    
    
 #继承Father类
 class Son(Father):
        
        def tell(self):
            #继承父类 
            #强行调用父类的私有属性
            Father._Father__tellAstory()
            self.tellAstory()
        

# 3.覆盖/重写
#  子类和父类有相同名称和方法
#   可以理解为子类对于父类行为的扩展或者补充
class Pet:
    def __init__(self,name):
        self.name=name
        print(f"一个名叫{self.name}的宠物出生了")
       
    def  eat(self):
        print(f"{self.name}在吃东西....")
        
class Dog(Pet):
    
    def lookAfter(self):
        print(f"{self.name}在看门")
        
    def eat(self):
        print(f"{self.name}在啃骨头")

子类在定义的时候，可以使用supper()调用父类的方法

class Cat(Pet):
    #应用2：对象初始化时，简化重复属性的赋值
    def __init__(self,name，age,sex):
        #self.name=name
        #self.age=age
        #self.sex=sex
    	#print(f"一个名叫{self.name}的宠物出生了")
        #这种方式的代码重复度较大，采用supper()来调用父类
        #supper(Cat,self).__init__(name)
        super().__init__(name)
        self.gae=age
        self.sex=sex
    
    def eat(self):
        #self.cat()#不能这样去调用父类的eat()对象，默认是死循环
        super().eat()#调用父类的eat()对象
        print(f"{self.name}吃完东西后，用唾液洗洗脸")

多继承

#子类可以有多个父类
#例如：狗是脊椎动物，哺乳动物，宠物：

#访问子类的属性或方法时，解析的路径：


class Father:
    def getMoney(self):
        priint("父亲给了零花钱....")
        
  
class Mother:
    def getMoney(self):
        print("母亲给了零花钱....")
        
#继承Father和Mother
class Child(Father,Mother):
    def getMoney(self):
        super().getMoney()
        print("孩子有了零花钱...")
        
  
输出：父亲给了零花钱....
		孩子有了零花钱....

#假设Father类没有getMoney函数


class GrandFather:
    def getMoney(self):
        priint("爷爷给了零花钱....")
   

class Father(GrandFather)
	pass
        
  
class Mother:
    def getMoney(self):
        print("母亲给了零花钱....")
        
#继承Father和Mother
class Child(Father,Mother):
    def getMoney(self):
        super().getMoney()
        print("孩子有了零花钱.....")
       
   
#输出：
#爷爷给了零花钱....
#孩子有了零花钱.....

########################################
子类调用父类时，调用对象的顺序是深度优先
########################################

#打印子类查找顺序的方法
print(Child.mro())
#输出：
<class '__main__.Child'>,<class '__main__.Father'>,<class '__main__.GrandFather'>,<class '__main__.Mother'>,<class 'object'>,
#为什么结尾都是object？
#所有内置的对象的父类，万物皆对象，因为所有的类都是继承object类

#菱形继承
	Human
      |
  |---------|
Faher      Mother
  |---------|
       |
      Child
   
class Human:
    def __init__(self):
        print("人类.......")
        
class Father(Human):
    def __init__(self):
        print("父亲初始化....")
        super().__init__()
        print("父亲初始化结束....")
      
 class Mother(Human):
    def __init__(self):
        print("母亲初始化....")
        super().__init__()
        print("母亲初始化结束....")    
       
 class Child(Father,Mother):
    def __init__(self):
        print("孩子初始化....")
        super().__init__()
        print("孩子初始化结束....")
        
     
 c=Child()
     
 按照原来的理解方式：
 输出：
#孩子初始化....
#父亲初始化....
#人类.......
#父亲初始化结束....
#孩子初始化结束....


而实际的输出为：
#孩子初始化....
#父亲初始化....
#母亲初始化....
#人类.......
#母亲初始化结束....
#父亲初始化结束....
#孩子初始化结束....

查找基础顺序
print(child.mro())

########################################
初始化是广度优先遍历
########################################

多态

概念：一种类的多种形态

同一行为具有多个不同表现形态或形式的能力。是指一个类实例（对象）的相同方法在不同情形下有不同的表现形式

通过继承的方式实现

1.让程序能够有更强的灵活性

2.让程序能够有更好从适应性

class Animal:
    def eating(self):
        print("动物下在吃东西.....")
        
   
class Pet(Animal):
    def eating(self):
        print("宠物在吃东西.....")
       
   
class Dog(Pet):
    def eating(self):
        print("狗在啃骨头.....")
       
   
class Cat(Pet):
    def eating(self):
        print("猫在吃鱼....")
        
       
class Zoo:
    def animallEating(self,animal):
        if isinstance(animal,Animal):
            print("这是展示动物吃东西的地方：")
        else:
            print("这是非动物吃饭的展示")
        animal.eating()

python特有的方式实现

没有继承关系，但是具备有相同的特征/方法，也可以直接使用.

继续在上面的代码后面追加定义：

class venusFlytrap:
    def eating(self):
        print("捕蝇草在吃小虫子.....")
   
v=venusFlytrap()
z=Zoo()
#z是Zoo类但是可以调用venusFlytrap类的对象
z.animallEating(v)
#这里传入的是v,在调用animallEating时需要调用eating对象
#而venusFlaytrap类也具有对象eating，在python中可以直接调用
#即便两个类之间没有继承关系，也可以调用

type和isinstance的区别

#判断类型时，只看直接类型
#type是严格满足类型
print(type(c) is Cat) #True
print(type(c) is Animal) #False
print(type(c) is Pet) #False


#isinstance 判断对象是否为一个类型的实例
# 判断实例类型时，涵盖父类的类型
print("*"*30)
print(isinstance(c,Cat)) #True
print(isinstance(c,Pet)) #True
print(isinstance(c,Animal)) #True
print(isinstance(v,Animal)) #False

类方法和静态方法

类方法

class Dog:
    
    legs=4
    teeth=42
    #类方法
    @classmethod
    def printInfo(cls):
        print(f"狗有{cls.legs}条腿，{cls.teeth}颗牙齿")
       
d=Dog()
d.printInfo()
Dog.printInfo()

静态方法

#静态方法：用@staticmethod装饰的不带self参数的方法叫做静态方法
#        类的静态方法可以没有参数，可以直接使用类调用

class dog:
    @staticmethod
    def bark(self):
        print("wangwang!")
       
  
d=Dog()
d.bark()