##python中继承，多态，类方法和静态方法##

1.继承

“”"
封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同的代码不需要重复的写
“”"

class Animal:
    def eat(self):
        print('吃～!!!!～～!!!!!～')
    def drink(self):
        print('喝～～～!!!!!～')
    def run(self):
        print('跑～～～～')
    def sleep(self):
        print('睡～～～～')
class Cat(Animal):
    # def eat(self):
    #     print('吃～～～～')
    # def drink(self):
    #     print('喝～～～～')
    # def run(self):
    #     print('跑～～～～')
    # def sleep(self):
    #     print('睡～～～～')
    def call(self):
        print('喵喵～～～')

class Dog(Animal):
    def bark(self):
        print('汪汪～～～～')
# 创建一个猫对象
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.sleep()
fentiao.call()

#创建一个狗对象
dahuang = Dog()
dahuang.eat()
dahuang.drink()
dahuang.bark()

#子类继承自父类，可以直接享用父类中已经封装好的方法
#子类中应该根据职责，封装子类特有的属性和方法

“”"
继承具有传递性
当父类方法的实现不能满足子类的需求的时候，
可以对方法进行重写(覆盖父类的方法)
对父类方法进行扩展
“”"

class Animal:
    def eat(self):
        print('吃～!!!!～～!!!!!～')
    def drink(self):
        print('喝～～～!!!!!～')
    def run(self):
        print('跑～～～～')
    def sleep(self):
        print('睡～～～～')


class Cat(Animal):
    def call(self):
        print('喵喵～～～')

class Hellokitty(Cat):
    def speak(self):
        print('我可以说日语～～～')

    def call(self):
        # 1.针对子类特有的需求，编写代码
        print('#$@#%@%#$%@%@#')
        # 2.调用原本在父类中封装的方法
        # Cat.call(self)
        super().call()
kt = Hellokitty()
kt.call()
kt.drink()
kt.eat()
kt.sleep()
kt.run()

2.多态

“”"
多态(以封装和继承为前提)
不同的子类对象调用相同的方法，产生不同的执行结果
Person()
work(self)

“”"

class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s 开心的玩～～～' % (self.name))


class Gaofei(Dog):
    # 父类的方法不能满足子类的需求，重写game方法
    def game(self):
        print('%s 和米老鼠一起玩～～～' % (self.name))


class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 玩～～～' % (self.name, dog.name))
        dog.game()


# 创建一个狗对象
# wangcai = Gaofei('高飞')
wangcai = Dog('大黄')
# 创建一个人对象
xiaoming = Person('小明')
# 让小明和狗玩
xiaoming.game_with_dog(wangcai)
Tom = Gaofei('tom')
Tom.game()

3.类方法

“”"
类方法:针对类对象定义的方法 在类方法内部可以直接访问类属性或者调员工其他的类方法
类属性:针对类对象定义的属性 使用赋值语句在class关键字下可以定义类属性
类属性用于记录与这个类相关的特性
“”"

class Toy(object):
    # 1.使用赋值语句定义类属性，记录所有玩具的数量
    count = 0
    def __init__(self,name):
        self.name = name
        # 让类属性 +1
        Toy.count += 1
    @classmethod
    def show_toy_count(cls):
        print('玩具对象的数量 %d' %(cls.count))
# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('泰迪熊')
# 调用类方法
Toy.show_toy_count()

4.静态方法

“”"
静态方法：
在开发中，如果需要在一个类中封装一个方法 这个方法
既不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候，我们就可以把这个方法封装成一个镜头方法

“”"

class Cat(object):
    @staticmethod
    def call():
        print('喵喵～')
# 通过 类名. 调用静态方法
Cat.call()

# 不需要创建对象，直接就可以使用

5.私有属性和私有方法

“”"
私有属性和私有方法
应用场景及定义方式
应用场景
在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，
而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 对象 不希望公开的 方法
定义方法
在定义属性或方法时，在属性名或者方法名前增加两个下划线，
定义的就是私有属性或方法
“”"

class Women(object):
    def __init__(self,name):
        self.name = name
        self.__age = 18
    def __secrte(self):
        print(self.__age)

lily = Women('lily')
print(lily.name)
#print(lily.__age)
lily.__secrte()