面向对象

继承的两种用途：

一： 继承基类的方法，并做出自己的改变或者扩展---意义不大，容易使得父类与子类直接出现强耦合

二： 声明某个子类兼容于基类，定义一个接口类interface， 接口类中定义了一些函数名（没有实习功能），子类继承接口类，并实现接口中的功能----接口继承（归一化）

归一化：只要是基于一个接口实现的类，所有类产生的对象在使用时候，从用法上是一样的。用户无需关心对象的类。只需要知道这些类具备哪些功能就行了。

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        self.money = money

class WechatPay(Payment):
    def pay(self, money):
        self.money = money

class AliPay(Payment):
    def pay(self, money):
        self.money = money

在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口

接口隔离原则： 使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些不需要的接口-- 面向对象开发的思想规范。都是面向对象的开发规范。不能实例化

依赖倒置原则： 高层模块不应该依赖于底层模块，二者应该依赖于抽象； 抽象不应该依赖于细节；细节应该依赖抽象；即：针对接口编程，而不是针对实现编程。 

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

class laoying(Walk_Animal, Fly_Animal):
    def walk(self):
        pass
    def fly(self):
        pass
class dulk(Walk_Animal, Swim_Animal):
    pass
l = laoying()

封装 

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

　　方法变属性

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)

　

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self): #方法名不能和属性名重名
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price
#只有在property后才能定setter,deleter
obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 print(obj.price) del obj.price # 删除商品原价

　　@Classmethod

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)
Classmethod_Demo.func()

@staticmethod

 class staticmethod_method():
    role = 'dog'
    
    @staticmethod
    def func():
        print('普通方法')

staticmethod_method.func()