19，面向对象

class Person:
    def __init__(self,name,sex,hp,ad):  # 初始化方法
        self.user = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self,dog):
        print('%s攻击了%s'%(self.user,dog.user))
        dog.hp -= self.ad
        print('%s掉了%s点血，当前血量为%s'%(dog.user,self.ad,dog.hp))

class Dog:
    def __init__(self,name,kind,hp,ad):  # 初始化方法
        self.user = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬了%s' % (self.user, person.user))
        person.hp -= self.ad
        if person.hp>0:
            print('%s掉了%s点血，当前血量为%s' % (person.user, self.ad, person.hp))
        else:
            person.hp = 0
            print('%s掉了%s点血，当前血量已为0' % (person.user, self.ad))
alex = Person('alex', None, 10, 1)  # 实例化
egon = Person('egon', None, 10, 1)  # 实例化
taibai = Dog('哮天犬','teddy', 100, 50)  # 实例化
# print(alex.user)
# print(egon.user)
# print(taibai.user)
alex.attack(taibai)   # <==>Person.attack(alex,taibai)
print(taibai.hp)

# 首先静态变量之所以出现 ： 所有的对象都共享的值
# 调整静态变量的值 ： 直接用类名去调整 是最准确的
# 对象对一个静态变量重新赋值的过程
    # 实际上是在对象所在的内存空间中添加了一个同名属性而已
# 方法并没有真正存储在对象的空间中
    # 之所以能找到，是因为每一个对象在创建之初都有一个执行类的指针

# 类名
    # 查看修改静态属性
    # 实例化
# 对象名
    # 查看对象的属性
    # 调用方法
# 对象使用名字的特点 ： 自己有的时候用自己的 自己没有的时候用类中的

 面向对象三大特性

继承

1，单继承

所有面向对象语言都支持

class A():
    def __init__(self):
        pass
class B(A):
    pass

print(B.__bases__)#查看父类类名。

2，多继承

继承的好处：可以解决代码的重复使用性质。

python天生支持多继承

java语言不支持多继承

继承的语法，在子类定义的时候，括号里的父类的名字。

对象在寻找名字的时候：先找到自己对象空间里有没有该属性，如果没有，通过类对象指针，在从父类属性里面查找有没有该值，如果还没有，就去object里找。在自己的类中调用父类中的同名方法，指名道姓法，第一种  类名.__init__(self,属性)，第二种方法super.__init__(self,属性)

class Role:
    def __init__(self,name,hp,ad):
        print('in Role init')
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s回了10点血'%self.name)
        self.hp += 10
class Person(Role):
    def __init__(self,name,sex,hp,ad):
        self.sex = sex                     # 派生属性
        self.money = 100
        Role.__init__(self,name,hp,ad)     # 指名道姓
        # super().__init__(name,hp,ad)                   # super()代表父类
        # super(Person,self).__init__(name,hp,ad)                   # super()代表父类
    def attack(self,dog):                  # 派生方法
        dog.hp -= self.ad
    def eat(self):
        if self.money >= 10:
            self.money -= 10
            # super().eat()
            Role.eat(self)
class Dog(Role):
    def __init__(self,name,kind,hp,ad):
        super().__init__(name,hp,ad)
        self.kind = kind                 # 派生属性
    def bite(self,person):
        person.hp -= self.ad

抽象类和接口类型

规范

from abc import ABCMeta,abstractmethod
class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass

class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        print('walk')
    def swim(self):
        print('swim')

class Parrot:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')

class Swan:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')
    def swim(self):
        print('swim')

 归一化设计：

class WechatPay(Pay):
    def pay(self,money):
        print('微信支付了%s元'%money)

class AliPay(Pay):
    def pay(self, money):
        print('支付宝支付了%s元' % money)

class ApplePay(Pay):
    def pay(self,money):
        print('apple支付了%s元' % money)

def payment(obj,money):obj.pay(money)
wp = WechatPay()
payment(wp,100)     # 编程的习惯 —— 归一化设计
wp.pay(100)
ap = AliPay()
payment(ap,100)
ap.pay(100)

app = ApplePay()
payment(app,100)

抽象类：

在类的位置制定metaclass 是ABCMeta

在制定的方法上面添加@abstractmethod装饰器

目的：规范所有集成这个类的子类，必须实现被@abstractmethod装饰器的这个方法

多态

封装