python - 面向对象三大特性（继承，多态，封装）

一.继承

1. 继承 ：节约代码，规范代码

2. 被继承的类叫做父类，基类，继承的类叫做派生类，子类

3. 类：分为新式类，和经典类.

　　新式类：继承了object类的类叫做新式类，在python3中默认的所有类都继承了object类，所以都是新式类

　　经典类：没有继承object类的类叫做经典类，在python2中，默认的所有类都是经典类，可以给其添加object类变成新式类

class A:    # A是父类，基类，B是派生类，子类
    pass

class B(object A): # 添加object类，变成新式类
    pass    

4. 继承：分为单继承和多继承

5. 查询顺序

　　单继承：新式类和经典类的查询顺序一样

　　多继承：

　　　　　经典类：在多继承情况下，采用深度优先查找

　　　　　新式类：在多继承情况下，采用广度优先查找

　　　　　深度优先，广度优先：只能是继承2个类的情况

　　　　　深度优先：一条路走到黑

　　　　　广度优先：一条路走到倒数第二级，判断，如果其他路能走到终点，则走另一条路，反之，则走到终点

6.即执行本类，又执行父类的方法

class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,a1):
        print('%s吃%s' % (self.name, a1))
# 即执行本类，又执行父类的方法
class Bird(Animal):
    def __init__(self,name,sex,age,wing):
        # Animal.__init__(self,name,sex,age)    # 父类名.方法名(参数)
        super().__init__(name,sex,age)  # super().方法名(参数(self自动传值))
        self.wing = wing

二.多态

# python:是一个弱类型语言
# 多态：python处处是多态
# python没有多态，不管什么样的类型，传入函数，封装到对象中都可以
# python是鸭子类型
# 这些类，拥有相同功能的方法，统称为鸭子类型
class Str:
    def index(self):
        pass


class List:
    def index(self):
        pass


class Tuple:
    def index(self):
        pass

三.封装

# python 的三大特性之一：封装
# 私有静态字段
# class B:
#     __money = 1000
# class A(B):
#     name = 'alex'
#     __age = 18
#     def func(self):
#         print('今天天气晴朗，阳光明媚')
#         print(a1.__age)
# a1 = A()
# print(a1.name)
# print(a1.__age) # 实例化对象不能访问私有静态字段
# print(A.__age) # 类名不能访问私有静态字段
# print(a1.__money)
# 对于私有静态字段来说，类的外部不能访问

# 对于私有静态字段来说，类的内部可以进行访问
# a1.func()

# 对于私有静态字段来说，类的内部可以进行访问，外部和派生类均不可以访问

# print(A.__dict__)
# 对于私有静态字段，方法 来说，一经执行，就会自动生成_类名_私有静态字段，可以通过实例化对象._类名__私有静态字段访问
# print(a1._A__age)

# 私有静态方法

# class A:
#     def __sport(self):
#         print('跑步')
#     def sport1(self):
#         print('游泳')
#         self.__sport()
# a1 = A()
# a1.__sport() # 实例化对象无法访问私有方法
# A.__sport(11)   # 类名无法访问私有方法
# a1.sport1() # 类的内部可以访问私有方法
# print(A.__dict__)

四.接口类，抽象类

# python没有接口这个概念
# python 接口类，抽象类：制定一个规则
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类，接口类
    @abstractmethod
    def pay(self):pass # 制定了一个规范
class Alipay(Payment):
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('你用支付宝支付了%s元' % self.money)

class Jdpay(Payment):
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('你用京东支付了%s元' % self.money)
class Wechatpay(Payment):
    def __init__(self,money):
        self.money = money
    def weixinpay(self):
        print('你用微信支付了%s' % self.money)
def pay(obj):
    obj.pay()   # 归一化设计
    
a1 = Alipay(100)
a1.pay()
w1 = Wechatpay(100)
w1.weixinpay()  # 报错，没有pay()方法