python 面向对象的三大特性

继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。

class A():pass   # 父类，基类，超类
class B:pass   # 父类，基类，超类
class C(A,B):pass # 子类，派生类
class D(A):pass # 子类，派生类

# 一个类 可以被多个类继承
# 一个类 可以继承多个父类——python里

__bases__查看所有继承的父类
__bases__则是查看所有继承的父类
print(A.__bases__)
(<class 'object'>,)
print(C.__bases__)
(<class '__main__.A'>, <class '__main__.B'>)

 python3 只存在新式类

没有继承父类时默认继承object，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

继承与抽象（先抽象再继承）
抽象即抽取类似或者说比较像的部分。

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

（子类 是 父类）

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。

函数名的重用

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.func()
    def func(self):
        print(123)
#
class Dog(Animal):
    def func(self):
        print(456)
    def bite(self,person):
        person.hp -= self.aggr
d = Dog()
#--> 456
只要是子类的对象调用，子类中有的名字 一定用子类的

 在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，

即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值.

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

    def eat(self):
        print('吃药回血')
        self.hp+=100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)  #
        self.kind = kind       # 派生属性
    

　  def eat(self):
        Animal.eat(self)   # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
        self.teeth = 2
    
 
　　def bite(self,person):   # 派生方法
        person.hp -= self.aggr

 在python3中，子类执行父类的方法也可以直接用super方法.（super只在python中存在）

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)  # 只在新式类中有，python3中所有类都是新式类
        # super(Animal,self).__init__(name,aggr,hp)
        # Animal.eat(self)
        self.kind = kind       # 派生属性
    

　　def eat(self):print('dog eating')
jin = Dog('金老板',200,500,'teddy')
print(jin.name)
jin.eat()
super(Dog,jin).eat()

小结

父类中没有的属性 在子类中出现 叫做派生属性
父类中没有的方法 在子类中出现 叫做派生方法
只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错# 如果父类、子类都有，用子类的。
    # 如果还想用父类的，单独调用父类的:
    #       父类名.方法名 需要自己传self参数
    #       super().方法名 不需要自己传self
 正常的代码中 单继承 === 减少了代码的重复
 继承表达的是一种 子类 是 父类的关系

多继承

单继承 ： 子类有的用子类 ，子类没有用父类。
多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？

class F:
    def func(self): print('F')
class A(F):pass
    # def func(self): print('A')
class B(A):
    pass
    # def func(self): print('B')
class E(F):pass
    # def func(self): print('E')
class C(E):
    pass
    # def func(self): print('C')

class D(B,C):
    pass
    # def func(self):print('D')

d = D()
# d.func()

python2.7 新式类和经典类共存，新式类要继承object
python3 只有新式类，默认继承object

经典类中 ,深度优先
新式类中 ,广度优先

经典类和新式类还有一个区别 mro方法只在新式类中存在
super 只在python3中存在
super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

class A(object):
    def func(self): print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')

b = D()
b.func()
print(B.mro())#[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>] 

钻石问题

新式类 ： 顺序如图所示，以根节点D为依据，在保证每个类里的函数都能取到的基础上，广度优先。

经典类：深度优先 图1 B->A 　　图2 dbafce(不再走f，因为之前走过) 　　图3 dbace 

小结

继承 ： 什么是什么的关系(子类是父类)
单继承 *****
    先抽象再继承，几个类之间的相同代码抽象出来，成为父类
    子类自己没有的名字，就可以使用父类的方法和属性
    如果子类自己有，一定是先用自己的
    在类中使用self的时候，一定要看清楚self指向谁
多继承 ***
    新式类和经典类：
        多继承寻找名字的顺序 ： 新式类广度优先，经典类深度优先
        新式类中 有一个类名.mro方法，查看广度优先的继承顺序
        python3中 有一个super方法，根据广度优先的继承顺序查找上一个类

 抽象类和接口类

java ： 面向对象编程
设计模式 —— 接口
接口类 ： python原生不支持(只是一种思想)
抽象类 ： python原生支持的

class Wechat(Payment):
    def pay(self,money):
        print('已经用微信支付了%s元'%money)

class Alipay(Payment):
    def pay(self,money):
        print('已经用支付宝支付了%s元' % money)

class Applepay(Payment):
    def pay(self,money):
        print('已经用applepay支付了%s元' % money)

def pay(pay_obj,money):  # 统一支付入口
    pay_obj.pay(money)

w = Wechat()
ap = Apple()
# a = Ali() #TypeError: Can't instantiate abstract class Ali with abstract methods pay
# pay(w,100)  #微信支付了100
# pay(ap,100) #苹果支付了100
# pay(a,100)
p = Payment() #Can't instantiate abstract class Payment with abstract methods pay 不能创建

接口类的多继承问题

接口隔离原则
使用多个专门（Fly_Animal、Walk_Animal等）的接口，而不使用单一（Animal）的总接口。即客户端不应该依赖那些不需要的接口。

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 Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        pass
    def swim(self):
        pass
class OldYing(Fly_Animal,Walk_Animal):pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

抽象类 ： 
规范
一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中


抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
java ：
java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题

python
python中没有接口类  ：
   python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类  ： 一般情况下 单继承  不能实例化
   且可以实现python代码

#一切皆文件
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        with open('filaname') as f:
            pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

什么是多态

多态 python 天生支持多态，python 动态强类型的语言

鸭子类型

不崇尚根据继承所得来的相似
我只是自己实现我自己的代码就可以了。
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的

class List():
    def __len__(self):pass
class Tuple():
    def __len__(self):pass

def len(obj):
    return obj.__len__()

l = Tuple()
len(l)

优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉
封装

广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
只让自己的对象能调用自己类中的方法

狭义上的封装 —— 面向对象的三大特性之一
属性 和 方法都藏起来 不让你看见

class Person:
    __key = 123  # 私有静态属性
    def __init__(self,name,passwd):
        self.name = name
        self.__passwd = passwd   # 私有属性

    def __get_pwd(self):         # 私有方法
        return self.__passwd   #只要在类的内部使用私有属性，就会自动的带上_类名

    def login(self):          # 正常的方法调用私有的方法
        self.__get_pwd()

alex = Person('alex','alex3714')
print(alex._Person__passwd)   # _类名__属性名
print(alex.get_pwd())

所有的私有 都是在变量的左边加上双下划綫
    对象的私有属性
    类中的私有方法
    类中的静态私有属性
所有的私有的 都不能在类的外部使用（自觉_person）

class Room:
    def __init__(self,name,length,width):
        self.__name = name
        self.__length = length
        self.__width = width
    def get_name(self):
        return self.__name
    def set_name(self,newName):
        if type(newName) is str and newName.isdigit() == False:
            self.__name = newName
        else:
            print('不合法的姓名')
    def area(self):
        return self.__length * self.__width

jin = Room('金老板',2,1)
print(jin.area())
jin.set_name('2')
print(jin.get_name())

# 假设父类的私有属性 能被 子类调用么
class Foo:
    __key = '123'       # _Foo__key

class Son(Foo):
    print(Foo.__key)     # _Son__key 不能


# 会用到私有的这个概念de场景
# 1.隐藏起一个属性 不想让类的外部调用
# 2.我想保护这个属性，不想让属性随意被改变
# 3.我想保护这个属性，不被子类继承

接口类 抽象类
python中没有接口类，有抽象类，abc模块中的metaclass = ABCMeta，@abstructmethod
本质是做代码规范用的，希望在子类中实现和父类方法名字完全一样的方法
在java的角度上看 是有区别的
    java本来就支持单继承 所以就有了抽象类
    java没有多继承 所以为了接口隔离原则，设计了接口这个概念，支持多继承了
python及支持单继承也支持多继承，所以对于接口类和抽象类的区别就不那么明显了
甚至在python中没有内置接口类

多态和鸭子类型
多态 —— python天生支持多态
鸭子类型 —— 不依赖父类的情况下实现两个相似的类中的同名方法

封装 —— 私有的
在python中只要__名字
在python中只要__名字，就把这个名字私有化了
私有化了之后 就不能能从类的外部直接调用了
静态属性 方法 对象属性 都可以私有化
这种私有化只是从代码级别做了变形，并没有真的约束
变形机制 _类名__名字 在类外用这个调用，在类的内部直接__名字调用

property
内置装饰器函数 只在面向对象中使用

# 属性 查看 修改 删除
class Person:
    def __init__(self,name):
        self.__name = name
        self.price = 20
    @property
    def name(self):
        return self.__name
    @name.deleter
    def name(self):
        del self.__name
    @name.setter
    def name(self,new_name):
        self.__name = new_name
brother2 = Person('二哥')
# del Person.price
brother2.name = 'newName'
brother2
# del brother2.name
print(brother2.name)

method 方法
staticmathod  静态的方法 ***
classmethod   类方法    ****

类的操作行为
class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
    def change_discount(cls,new_discount):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)
Goods.change_discount(0.5)   # Goods.change_discount(Goods)
print(apple.price)
当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

# 在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()

类方法和静态方法 都是类调用的。

对象可以调用类方法和静态方法，一般情况下 推荐用类名调用。

类方法 有一个默认参数 cls 代表这个类  cls
静态方法 没有默认的参数 就象函数一样