python基础-- -类的继承、重写、多态

·1、继承

　　python3中所有的类默认继承object类。

class Animal:
    def __init__(self):
        self.age = 2:
        self.__height= 12 ##私有变量

    def eat(self):
        print('eat')
    
    def sleep(self):
        prinit('sleep')


## 语法：class 子类(父类)
## 子类就会有父类的公有属性和方法
class Bird(Animal):  ##Bird继承Animal
    
    def __init__(self):
        super.__init__() ##调用父类的构造方法，保留父类的属性
        self.name = 'Polly'

    def fly(self):
     ##   print(self.__height) ##子类没有继承私有属性
        print('f飞来飞去')

class Maque(Bird):
    def ttt(self):
        print('麻雀')

class Fish(Animal):
    def swim(self):
        print('如鱼得水')

bird = Bird()
bird.eat()  ##调用父类的方法
bird.sleep()
print(bird.age)  ##调用父类的属性（成员变量）
bird.fly()  ## 调用自己的方法

fish = Fish()
fish.eat()  ## 调用父类的方法
fish.swim()  ##调用自己的方法

##python中有单继承和多继承！！
#同时继承多个！！      

多继承

## 多继承

class Father:
    def drink(self):
        print('drink')

    def sleep(self):
        print('Father sleep')

class Mother:
    def shopping(self):
        print('shopping')

    def sleep(self):
        print('Mother Sleep')

class Son(Mother, Father):  ## 多继承 ,这个继承是有顺序的
    def sleep(self):
        print('Son Sleep')
'''
 若是自己存在这个方法，就调用自己的方法！！
 若是自己没有，就会调用先继承的父类的方法
'''

s = Son()

##先重子类找sleep方法，如果没有就找父类，一直往上找，直到完成，或者报错
s.sleep()  ## 调用Father父类的方法
s.shopping()  ##调用Mother父类的方法

print(Son.__mro__)## 获取属性或者方法查找顺序


##判断这个对象是否是某个类的实例（对象）
print(isinstance(s,Son))
print(isinstance(s,Father))
print(isinstance(s,Mother))
print(isinstance(s,object))

 2、方法重写

class Father:

    def drink(self):
        print('喜欢喝酒')

    def sleep(self):
        print('没事就梦游')


class Son(Father):

    def drink(self, item):  ## 对父类的方法进行重写
        print('我不喝酒,喜欢喝%s' % item)

    ## 父类部分满足功能，子类有增加功能
    ## 用super调用父类的方法
    ## 一般是在继承和重写的情况下，使用super调用父类的方法
    def sleep(self):
        # print('没事就梦游')
        super().sleep()
        print('喜欢说梦话')

    def run(self):
        print('run')
        super().sleep()  ## 不是重写也可以super调用父类的方法

s = Son()
s.drink('橙汁')  ##调用重写的方法
s.sleep()

 3、多态

　　所谓多态，就是调用不同的方法，产生不同的表现结果

## 1、继承的多态，类似于java
class Animal：
    def beaten(self): ##被打
        pass
    
class Cat(Animal):
    def beaten(self):
        print('敢打我，挠死你！！')

class Dog(Animal):
     def beaten(self):##重写beaten方法
        print('敢打我，咬死你！！')

## 2、不继承的多态
## 鸭子类型--- 看起来像多态，就是多态！！！
## python中的多态和继承是没有关系的!!!
class Frog:  ##不继承，没有beaten方法，但是自己定义了beaten方法
    def swim(self):
        print('正在游泳')

    def beaten(self):
        print('青蛙被打，呱呱，继续游泳')

class Outman:
    def beatAnimal(self, animal):
        print('打小动物')
        animal.beaten()


dijia = Outman()
cat = Cat()  ##猫
dijia.beatAnimal(cat)
 
dog = Dog()  ##狗
dijia.beatAnimal(dog)

frog = Frog()
dijia.beatAnimal(frog) #没有方法

 总结：

　　1、当类之间有显著的不同，并且较大的类是由较小的类组成的时候，用组合（把小的那个类作为大类的变量）

　　2、当类之间有很多相同的功能，提取这些共同的功能作为基类，用继承比较好

 4、接口继承

## 普通
class Disk：  ##硬盘
    def read(self):
        pass

    def write(self):
        pass

class Cdrom: #光驱
    def read(self):
        pass

    def write(self):
        pass

class Mem：
    def read(self):
        pass

    def write(self):
        pass


## 用继承改造代码：

class All_file:  ##最为父类---基类
    def read(self):
        pass

    def write(self):
        pass

class Disk(All_file)： #硬盘继承all_file
        pass

class Cdrom(All_file): #光驱继承all_file
        pass

class Mem(All_file)：继承all_file
        pass


##接口继承-- 子类必须实现
import abc
class All_file(metaclass = abc.ABCMeta):  ##最为接口类，只定义不实现
    @abc.abstractmethod
    def read(self):
        pass

     @abc.abstractmethod
    def write(self):
        pass

class Disk(All_file)： #硬盘继承all_file接口，实现具体的功能
       def read(self):
        pass

    def write(self):
        pass

class Cdrom(All_file): #光驱继承all_file
        def read(self):
        pass

    def write(self):
        pass

class Mem(All_file)：继承all_file
        def read(self):
        print('Mem read')

    def write(self):
        print('Mem write')

## 接口就是一个函数，在java中有个关键字叫interface