面向对象：继承、多态、封装

类、对象：

• 类：抽象的
• 对象：具体的

class Person:  # 类名
    def __init__(self, name, hp, aggr, gender):
    # __init__为初始化方法
        self.name = name
        self.hp = hp
        self.aggr = aggr
        self.gender = gender

    def walk(self, n):  # 定义方法，一般情况下必须传self参数，且必须写在第一个；后面还可以传其他参数，想传多少就多少
        print("{}走了{}步".format(self.name, n))

p = Person("王者", "100", "5", "男")  # 对象 = 类(参数)，这个过程叫实例化
print(p.name)      # 查看属性值
print(p.__dict__)  # 查看所有属性
p.walk(10)         # 调用这个对象拥有的方法

类有静态属性和方法，类中的静态属性和方法可以被对象和类调用。

class Person(object):
    money = 0

    def work(self):
        Person.money += 100

mother = Person()
father = Person()
mother.work()
father.work()
print(Person.money)  #200

类的组合：在一个类中以另外一个类的对象作为数据属性

class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

class Battery:
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

class ElectricCar(Car):
    """电动汽车特殊之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性，再初始化电动汽车特有的属性"""
        super().__init__(make, model, year)
        self.battery = Battery()

my_tesla = ElectricCar("tesla", "model s", 2016)
my_tesla.battery.describe_battery()  #This car has a 70-kWh battery.

面向对象三大特性：继承、多态、封装

继承

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

python中类的继承分为：单继承和多继承

　　一个类可以被多个类继承
　　一个类可以继承多个父类（python独有）

class A(object):  # 定义父类
    pass
class B(object):  # 定义父类
    pass
class C(A):       # 单继承，父类是A，子类是C
    pass
class D(A,B):     # 多继承（python独有），用逗号分隔开多个继承的类
    pass

########## 查看继承 ##########
# __base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
print(D.__base__)     # <class '__main__.A'>
print(D.__bases__)    # (<class '__main__.A'>, <class '__main__.B'>)

#在python3中,没有继承父类就默认继承object
print(A.__bases__)    # (<class 'object'>,)

派生

• 父类中没有的属性，在子类有，叫做派生属性
• 父类中没有的方法，在子类有，叫做派生方法

注意：

　　子类可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），一旦重新定义了自己的属性且与父类重名，调用时就以自己为准；
　　要是子类的对象调用属性，子类中有的名字就用子类的, 子类中没有才找父类的, 如果父类也没有就报错

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

class Base1(object):
    def func(self):
        print("Base1.func")

class Base2(object):
    def func(self):
        print("Base2.func")

class Foo(Base1, Base2):
    def func(self):
        # 方式一：根据mro的顺序执行方法
        super().func()           # Base1.func
        super(Foo, self).func()  # Base1.func
        # 方式二：主动执行父类类的方法
        Base2.func(self)         # Base2.func
        print("Foo.func")

obj = Foo()
obj.func()              # Foo.func
super(Foo, obj).func()  # Base1.func  在类外调用父类方法

print(Foo.mro())  # [<class '__main__.Foo'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class 'object'>]

继承顺序：

单继承：子类有的用子类，子类没有就用父类
多继承：
　　经典类中：深度优先
　　新式类中：广度优先

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

super的本质（python3才有，即只有新式类，广度优先）：不是单纯找父类，而是根据调用者的节点位置的广度优先顺序来的

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")

d = D()
d.func()
print(D.mro())  # mro()方法可查看类的继承顺序
# [<class "__main__.D">, <class "__main__.B">, <class "__main__.C">, <class "__main__.A">, <class "object">]

多态

多态指的是一类事物有多种形态
动物有多种形态：人、狗、猪

import abc

class Animal(metaclass=abc.ABCMeta):  # 动物类
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal):  # 动物的形态之一：人
    def talk(self): 
        print("你好！")

class Dog(Animal):  # 动物的形态之二：狗
    def talk(self):
        print("旺旺！")

class Cat(Animal):  # 动物的形态之三：猫
    def talk(self):
        print("喵喵！")

# 类List与类Tuple都有相似的方法，那么这两个类就是鸭子类型，都可以使用len()方法，而不需要像其他语言一样告诉len()自己是什么类型
# 在强类型语言中，叫多态
# 在python中，叫鸭子类型

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

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

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

l = List()  # 或者T = Tuple()
len(l)

封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：
　　1.将变化隔离；
　　2.便于使用；
　　3.提高复用性；
　　4.提高安全性。

封装原则：
　　1.将不需要对外提供的内容都隐藏起来；
　　2.把属性都隐藏，提供公共方法对其访问。

在python中用双下划线开头的方式将属性隐藏起来（设置成私有属性）

class Person:
    __country = "china"   # 私有静态属性

    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 私有实例属性

    def __get_age(self):  # 私有方法
        return self.__age

    def func(self):
        return self.__get_age()  # 调用私有xx的正确方式

p = Person("pd", 18)
print(p.func())          # 正确使用方式
# print(p._Person__age)  # 对象._类名__属性名（不建议这样使用！！！）

封装与扩展性

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

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

    def get_age(self):
        return self.__age

    def set_age(self, n):
        if 0 < n and n.isdigit():
            self.__age = n
        else:
            return "年龄不合法"

p = Person("pd", 18)
print(p.get_age())     # 18
print(p.set_age(-18))  # 年龄不合法

会用到私有的这个概念的场景：

　　1.隐藏一个属性，不让类的外部直接调用
　　2.保护一个属性，不让属性随意被改变
　　3.保护一个属性，不被子类继承

小结

接口类、抽象类：
　　python中没有接口类，有抽象类，abc模块中的metaclass = ABCMeta，@abstructmethod
　　本质是做代码规范用的，希望在子类中实现和父类方法名字完全一样的方法

接口类与抽象类的区别：
　　在java的角度上看是有区别的
　　　　java没有多继承，所以为了接口隔离原则，设计了接口这个概念，以便实现多继承；
　　　　java本来就支持单继承，所以就有了抽象类。
　　python既支持单继承也支持多继承，所以对于接口类和抽象类的区别就没有那么明显；python中没有内置接口类

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