面向对象的三大特性之继承

面向对象具有三大特性：继承，多态以及封装。

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

单继承：

　　语法：父类，子类

　　继承与重用：

　　　　子类可以使用父类中的名字（变量和方法）
　　继承与派生：

　　　　子类在父类的基础上又新创建了自己想要的方法和属性

　　　　父类有的子类没有：子类对象直接调用就会直接执行父类的方法

　　　　父类有的子类也有：子类对象调用直接执行子类中的方法

　　　　　　　　　　　　　　想在子类中使用父类的名字：父类名.super() 去调用

　　　规范的编程模式：

　　　　　　抽象类。

 

多继承：

　　语法：

　　接口：

　　新式类和经典类：

　　　　新式类：

• • • 所有的多继承关系寻找方法的顺序 ：遵循广度优先算法
    • 继承object
    • mro方法
    • super：super不是单纯的找父类，而是遵循mro顺序

　　　　经典类：

• • • python2.x
    • 不主动继承object
    • 经典类在在父类中方法的过程中，遵循：深度优先
    • 不提供mro方法和super

　

一、继承

继承与重用：父类中所有的属性和方法都可以被子类使用

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    def func(self):
        print('in Son')


s1 = Son()  # in Son

　　

 

 

 

　　当子类中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量。父类中的方法不会被自动执行。

　　如果既要执行子类的方法，也要执行父类的方法，那么需要在子类的方法中调用父类的方法。

父类名.方法名(self,...)
super().方法名(...)

　　

# class Foo:
#     def __init__(self):
#         self.func()
#     def func(self):
#         print('in Foo')
#
# class Son(Foo):
#     def func(self):
#         print('in Son')
#
# s1 = Son()  # in Son

# class Foo:
#     Country = 'China'
#     def func(self):
#         print(self.Country)
#
# class Son(Foo):
#     Country = 'English'
#     def func(self):     # 走这个方法
#         print(self.Country)
#
# s = Son()
# s.func()   # English

# class Foo:
#     Country = 'China'
#     def func(self):  # 走这个方法
#         print(self.Country)
#
# class Son(Foo):
#     Country = 'English'
#
# s = Son()
# s.func()   # English

# class Foo:
#     Country = 'China'
#     def func(self):
#         print(self.Country)
#
# class Son(Foo):pass
#
# s = Son()
# s.func()   # 'China'

 

　

二、抽象类

规范
　　多人开发、复杂的需求、后期的扩展
　　手段 来帮助我们完成规范

抽象类
　　抽象类是一个规范，它基本不会实现什么具体的功能，抽象类是不能被实例化
　　要想写一个抽象类
　　　　from abc import ABCMeta,abstractmethod
　　　　在这个类创建的时候指定 metaclass = ABCMeta
　　　　在你希望子类实现的方法上加上一个 @abstractmethod装饰器
　　使用抽象类
　　　　继承这个类
　　　　必须实现这个类中被@abstractmethod装饰器装饰的方法

# 支付功能

from abc import ABCMeta, abstractclassmethod

class Payment(metaclass=ABCMeta):
    @abstractclassmethod
    def pay(self): pass

    @abstractclassmethod
    def shouqian(self): pass

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


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


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


def pay(obj, money):
    obj.pay(money)


p = Payment()
# a = Alipay()
# # a.pay(100)
# pay(a,100)
#
# we = Wechatpay()
# # we.pay(200)
# pay(we,200)
#
# ap = ApplePay()

　　

三、多继承

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

class FlyAnimal(Animal):
    def fly(self):
        print('%s 在飞' % self.name)

class WalkAnimal(Animal):
    def walk(self):
        print('%s 在走路'% self.name)

class SwimAnimal(Animal):
    def swim(self):
        print('%s在游泳'%self.name)

class Tiger(SwimAnimal,WalkAnimal):
    pass

class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    pass

class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):
        print('%s说话了'%self.name)

swan = Swan('天鹅')
swan.fly()
swan.walk()

　　

四、接口类

# 接口 Interface  接口可以被多继承

# Interface FlyAnimal:  # 规范继承我的类必须实现这个方法
    # def fly():pass

# Interface WalkAnimal:
    # def walk():pass

# Interface SwimAnimal:
    # def swim():pass

# class Tiger(WalkAnimal,SwimAnimal):  继承了一个规范
#     def walk():代码
#     def swim():代码

# 抽象类
# 接口

　　

 

五、新式类与经典类

新式类
在python3.x版本中 所有的类都是新式类
所有的新式类都有一个默认的父类  ： object
class Person1:pass
class Person2():pass
class Person3(object):pass
# p = Person2()  # __init__ 初始化方法
print(Person1.__bases__)
print(Person2.__bases__)
print(Person3.__bases__)

python 2.7
经典类 和 新式类 并存
class Student:pass # 经典类
class Student(object):pass

继承了object的类就是新式类
在py3中所有的类都是新式类
在py2中既有新式类又有经典类

　　

 

 

区别：

新式类中
　　所有的多继承关系寻找方法的顺序 - 遵循广度优先算法
　　继承object
　　mro方法
　　super : super不是单纯的找父类，而是遵循mro顺序的

经典类
　　python2.x
　　不主动继承object
　　经典类在找父类中方法的过程中 遵循 —— 深度优先
　　不提供mro方法和super

 

　　　　　　　

 

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

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

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

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

class E(B, C):
    def func(self):
        print('E')

class F(D, E):
    def func(self):
        print('F')

F().func()  # 新式类 F-->D-->E-->B-->C-->A         经典类：F-->D-->B-->A-->E-->C
print(F.mro())

class A:
    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().func()   # A-->C-->B-->D