# 继承的引子
# 假设我们现在有一个游戏，游戏中有这些具体的事物（对象 ）： 梅西、奥巴马、史努比、史派克、小猪配齐、猪八戒。
# 采取面向对象设计的方法，是要对游戏中的具体对象，进行分门别类的抽象，抽取中相似对象的共同特征和行为来，作为一种规范，
# 一种模板来，梅西和奥巴马，它们的相似，具有人的特征，因此，我们把它们归为一类，即人类，就抽象出人类这一概念来了。
# 史努力和史派克 具有共同的特征和行为，我们把它们归为一类，并取名为狗类，完成具体到综合的第一次抽象，而小猪配齐和希猪八戒，
# 它们两个具体的事物，又具有共性的东西，因此将它们归为一类，并取名为猪类。
# 以上，通过对抽取相似具体事物的共同特征，归为一类，完成了事物的第一层抽象。
# 梅西、奥巴马、史努比、史派克、小猪配齐、猪八戒 ===》 人类 、狗类 、 猪类 # 基本的分类
# 人类 、狗类 、 猪类 ===》 经过再一次抽象，抽象出 动物类。
# 因此面向对象的过程，就是由具体 到 抽象 的过程。从宏观上，概念上 统领相似事物。抽象的层次，越高，能够描述和规范的事物就越多。
# # 猫类：
# 属性： 名字，品种，食物
# 方法： 叫，抓老鼠，吃，喝
# 狗类：
# 属性： 名字，品种，食物
# 方法：叫，看家，吃，喝
# 人类：
# 属性：名字，品种，食物
# 方法：说话，工作，吃，喝
# 虽然，我们从具体的事物，抽象出三个类别，但是我们发现，这三类之间，还有共同的代码，没有提高代码的重用性。
# 于是乎，我们可以将三个类别的共同代码，再抽取出来，建立一个类别，比如说叫动物类，它让猫类、狗类、人类隶属于这个类，
# 也就具有这个类的属性。
# 那么用puthon代码如何实现呢？
# 定义 一个 Animal() 的父类
class Animal: # 父类，超类，基类
def __init__(self,name,kind,food,language):
self.name = name
self.kind = kind
self.food = food
self.language = language
def yell(self):
print("%s叫" % self.language)
def eat(self):
print("吃%s" % self.food)
def drink(self):
print("喝水")
# 定义 类的 时候 ，继承某个类，它将继承父类的所有属性 和 方法，继承的写法，就是将类 要继承的父类，放在类名后面的小括号里。
class Cat(Animal): # 派生类
def catch_mouse(self):
print("抓老鼠")
class Dog(Animal): # 派生类
def __init__(self,name,kind,food,language,eye_color): # 子类重写父类的方法，并通过super()方法，调用父类的同名方法
self.eye_color = eye_color # 派生属性
super().__init__(name,kind,food,language) # self ,不用传，会自动传
def swim(self): # 派生方法
print("游泳")
def look_afte_home(self):
print("看家")
class Human(Animal): # 派生类
def __init__(self): # 这里子类对父类的方法，进行了重写，即覆盖了父类，此时父类的同名方法，对子类就不可见了。
self.walk_way = "直立行走"
def work(self):
print("工作")
# 在继承关系中，被继承的类，我们称之为超类/基类/父类, : 比如上面的 Animal类
# 继承的类，叫做子类/派生类： 比如上面的 Cat, Dog, Person
# 继承与重用：是同一个事物的两方面，类的继承就是了为提高代码的重用性，提高代码的重用性，除了函数，类就是别外一种的实现方式。
# 比如说：写了两个类或多个类，它们有共同的代码或逻辑，这时候就可以为它们创建一个父类，把共同的代码或逻辑放到父类里，这时通过继承
# 就实现了代码的重用性。
# 继承与重用，父类中的所有方法和属性都被子类中使用了。
阿猫 = Cat("阿猫","花猫","鱼","喵喵")
阿猫.yell()
阿猫.eat()
阿猫.drink()
print(阿猫.name)
yellDog = Dog("黄狗","土狗","骨头","汪汪","蓝色")
yellDog.eat()
yellDog.drink()
yellDog.yell()
print(yellDog.name)
xiaomin = Human() # 因为子类对父类的 __init__方法，进行了重写，除了self以外，没有参数，不需要手动传参。
print(xiaomin.walk_way)
yellDog.swim()
# 总结：当子类当中有要被调用的方法 和 属性的时候，子类的对象会直接选择子类中的方法、变量，父类中的同名方法不会被自动执行。
# 如果我们既想要执行子类中方法，也想要执行父类中的同名方法，那么需要在子类的方法中调用父类的方法：有两种方式：
# 父类名.方法名（...）
# super().方法名(...)
# 面试题：
class Foo:
def __init__(self): # 初始化对象实例的函数，此函数仅在调用 类名() 时执行一次
self.func() # 对象调用
def func(self):
print('in Foo')
class Son(Foo):
# def func(self):
# print("in Son")
pass
s1 = Son() # 创建了一个Son类的对象实例，并赋值给对象引用 s1。过程是，在内存中开辟一个对象空间，根据对象所属的直接类的类
#对象指针 找寻 __init__方法执行，子类没有，在父类中寻找，找到将对象传递参数self,执行 __init__函数体，执行self.func()语句，
# 对象执行一个方法，先在对象所属直接类中，找到，直接执行，没有找到，再到父类找，所以此处是打印 in Son
# class Foo:
# Country = 'China'
# def func(self):
# print(self.Country)
#
# class Son(Foo):
# Country = 'English'
# def func(self): # 走这个方法
# print(self.Country)
#
# s = Son()
# s.func()
# class Foo:
# Country = 'China'
# def func(self): # 走这个方法
# print(self.Country)
#
# class Son(Foo):
# Country = 'English'
#
# s = Son()
# s.func() # English
# class Foo:
# Country = 'China'
# def func(self):
# print(self.Country)
#
# class Son(Foo):pass
#
# s = Son()
# s.func() # 'China'
# 结论：始终注意，那个对象调用 ，self就是哪个对象
# 抽象类
# 工作中 公司使用抽象类 ，来规范 开发的规则。
# 源码 别人使用抽象类
from abc import ABCMeta,abstractmethod # 从 abc 这个外部模块中，导入 ABCMeta 类 和 abstracmethod这个用于装饰函数的装饰器
class Payment(metaclass=ABCMeta): # 给类的元类，传递一个关键字参数
@abstractmethod
def pay(self):pass # 抽象方法，仅有定义，没有方法的实现
@abstractmethod
def shouqian(self):pass # 假如，把这两行的注释打开，如果子类不实现这个方法，程序会报错
# a = Alipay()
# TypeError: Can't instantiate abstract class Alipay with abstract methods shouqian
def abstract(self):
print("我继承抽象类")
class Alipay(Payment):
def pay(self,money):
print("使用支付宝支会了%s元" % money)
def shouqian(self,money):
print("使用收款方式收到%s元" % money)
class Wechatpay(Payment):
def pay(self,money):
print("使用微信支付了%s元" % money)
def shouqian(self,money):
print("使用收款方式收到%s元" % money)
class Applepay(Payment):
def pay(self,money):
print("使用applepay支付了%s元" % money)
def shouqian(self,money):
print("使用收款方式收到%s元" % money)
# def pay(obj,money):
# obj.pay(money)
a = Alipay()
a.pay(100)
a.shouqian(2000)
a.abstract() # 抽象类，也可以有普通方法，子类继承
wechat = Wechatpay()
wechat.pay(260)
wechat.shouqian(489)
apple = Applepay()
apple.pay(159)
apple.shouqian(6000)
# 以上多个子类，继承同一个抽象类，子类必须去实现抽象类中用@abstractmethod装饰器装饰的方法，否则会报错。
# 实现了不同的对象，调用相同的方法
# 在上面的基础上，我们来定义 一个 统一的函数，也可以叫接口
def 付钱(obj,money):
obj.pay(money)
# 这样，func()就是一个统一的支付接口
付钱(wechat,1600)
付钱(a,3500)
def 收钱(obj,money):
obj.shouqian(money)
收钱(a,10000)
收钱(apple,30000)
# p = Payment() # 抽象类 ， 不能实例化 TypeError: Can't instantiate abstract class Payment with abstract methods pay, shouqian
# 总结： 抽象类 是一种 规范
# 多人开发、复杂的需求、后期的扩展
# 手段，来帮助我们完成规范。
# 抽象类 如何创建
# 抽象类是一个规范，它基本上不会实现什么具体的功能，抽象类是不能被实例化的。
# 要想写一个抽象类的步骤：
# from abc import ABCMeta,abstractmethod
# 在创建这个类的时候，指定 metaclass = ABCMeta
# 在你希望子类实现的方法上加一个 @abstractmethond 装饰器
# 使用抽象类：
# 继承这个类
# 必须实现这个类中被 @abstractmehond 装饰器装饰的方法