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

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

继承分为单继承和多继承:

单继承:

  语法:父类,子类

  继承与重用:

    子类可以使用父类中的名字(变量和方法)
  继承与派生:

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

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

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

              想在子类中使用父类的名字:父类名.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().方法名(...)

  

 1 # class Foo:
 2 #     def __init__(self):
 3 #         self.func()
 4 #     def func(self):
 5 #         print('in Foo')
 6 #
 7 # class Son(Foo):
 8 #     def func(self):
 9 #         print('in Son')
10 #
11 # s1 = Son()  # in Son
12 
13 # class Foo:
14 #     Country = 'China'
15 #     def func(self):
16 #         print(self.Country)
17 #
18 # class Son(Foo):
19 #     Country = 'English'
20 #     def func(self):     # 走这个方法
21 #         print(self.Country)
22 #
23 # s = Son()
24 # s.func()   # English
25 
26 # class Foo:
27 #     Country = 'China'
28 #     def func(self):  # 走这个方法
29 #         print(self.Country)
30 #
31 # class Son(Foo):
32 #     Country = 'English'
33 #
34 # s = Son()
35 # s.func()   # English
36 
37 # class Foo:
38 #     Country = 'China'
39 #     def func(self):
40 #         print(self.Country)
41 #
42 # class Son(Foo):pass
43 #
44 # s = Son()
45 # 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

  

 

posted @ 2018-08-28 17:02  3DX2Y  阅读(168)  评论(0编辑  收藏  举报