Python面向对象之继承

一、继承

面向对象的语言：c++，c#，java

面对对象的三大特性（继承、多态、封装）其他语言都有

二、继承和抽象

实例---> 分类 ---> 汇总逐渐抽象

编程实现：先抽象，后继承

继承的好处：继承能提高代码的重用性，还能规范代码

继承分为子类和父类

父类/超类/基类

子类/派生类

class Animal:                     # 父类
    def __init__(self,name,kind):
        self.name = name
        self.kind = kind

    def sleep(self):
        print('%s在睡觉'% self.name)

class Cat(Animal):                  # 子类
    def catch(self):
        print('%s抓老鼠'% self.name)

cat = Cat('小猫','咖啡猫')
print(cat.name)
cat.sleep()
cat.catch()

------------------
小猫
小猫在睡觉
小猫抓老鼠
------------------

继承的语法：

class A:pass

class B(A):pass

class A:            # 父类
    ...
class B(A):         # B 继承 A
    ...

三、单继承

继承与重用

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

　　子类可以使用父类中的名字（变量和方法）

class Animal:                     # 父类
    def __init__(self,name,kind):
        self.name = name
        self.kind = kind

    def sleep(self):
        print('%s在睡觉'% self.name)

class Cat(Animal):                  # 子类
    def catch(self):
        print('%s抓老鼠'% self.name)

class Dog(Animal):
    def walk_the_dog(self):
        print('溜%s' % self.name)

cat = Cat('小猫','咖啡猫')
dog = Dog('小狗','导盲犬')
cat.sleep()
dog.sleep()

-----------------
小猫在睡觉
小狗在睡觉
-----------------

派生

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

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

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

--- 在子类中使用父类的名字：父类名、super()

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

    def drink(self):
        print('%s在喝水'% self.name)

class Cat(Animal):                              # 派生类
    def __init__(self,name,kind,eye_color):
        self.name = name
        self.kind = kind
        self.eye_color = eye_color              # 派生属性

    def catch(self):                            # 派生方法
        print('抓老鼠')

当子类当中有被调用的方法的时候，子类的对象会直接选择子类中的方法或者变量，父类中的方法不会被执行

方法一：子类已存在同名的方法，调用父类的方法

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

    def drink(self):
        print('%s在喝水'% self.name)

class Cat(Animal):                              # 派生类
    def __init__(self,name,kind,eye_color):
        Animal.__init__(self,name,kind)         # 调用父类的方法
        self.eye_color = eye_color              # 派生属性

    def catch(self):                            # 派生方法
        print('抓老鼠')

方法二：子类已存在同名的方法，调用父类的方法

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

    def drink(self):
        print('%s在喝水'% self.name)

class Cat(Animal):                              # 派生类
    def __init__(self,name,kind,eye_color):
        # Animal.__init__(self,name,kind)         # 调用父类的方法，要加参数self
        super().__init__(name,kind)               # 调用父类的方法，super不需要加self  
        self.eye_color = eye_color              # 派生属性

    def catch(self):                            # 派生方法
        print('抓老鼠')

子类和父类有同名的方法，如果既要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中调用父类的方法：

①父类名.方法名(self)

② super().方法名()

super()调用父类的方法，不需要传self，通过父类名调用父类的方法要传self

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 = s1,调用的是Son自己的方法func，所以执行的是子类自身的方法

当self去调用某个方法的时候，不要看self在哪个类里，要看self到底是谁

class Foo:
    city = 'ShenZhen'
    def func(self):
        print(self.city)

class Son(Foo):
    city = 'HONGKONG'

s = Son()
s.func()

'''
结果  HONGKONG
'''

s.func()执行的是父类中的方法，但是调用的属性是Son本身的属性，self就是s，打印的是Son的属性

当self去调用某个方法的时候，不要看self在哪个类里，要看self到底是谁

四、抽象类

抽象类的一个特点是它不能直接被实例化

抽象类的目的就是让别的类继承它并实现特定的抽象方法

抽象基类的一个主要用途是在代码中检查某些类是否为特定类型，实现了特定接口

抽象类的场景：

① 工作中公司有使用抽象类开发的规则

② 看源码，别人的源码使用了抽象类

python使用抽象类的不多

抽象类用来规范代码：

多人开发，复杂的需求、后期的扩展和版本的更新，用新的手段（抽象）来完成规范

抽象类的描述：

抽象类是一个规范，它基本不会实现具体的功能，是由于抽象类不能被实例化

写抽象类:

from abc import ABCMeta,abstractmethod

在这个类创建的时候指定metaclass=ABCMeta

在子类实现的方法加上一个@abstractmethod 装饰器

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod                 # abstractmethod 是一个装饰器，装饰器放在函数/类的上一行
    def pay(self):
        pass

class GooglePay(Payment):
    def pay(self,money):
        print('支付了%s元'% money)

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

G = GooglePay()
a = pay(G,10000)

'''
支付了10000元
'''

装饰器一般放在函数或者类的上一行，表示装饰下一行的函数或者类

使用装饰器：

① 继承这个类

② 必须实现这个类（子类创建同名的方法）被abstractmethod 装饰器装饰的方法

定义了抽象类必须实行抽象方法，否则会报错

五、多继承

不支持的继承的语言：java，C#

支持多继承的语言：C++，python

多继承的弊端：继承的父类有同名的方法

多继承的定义：python一个子类可以调用多个父类的方法

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

class Land(Animal):
    def walk(self):
        print('%s 在步行'% self.name)

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

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

class Drogon(Land,Sea,Air):
    pass

class Frog(Sea,Land):
    pass

drogon = Drogon('东海龙')
drogon.fly()
drogon.swim()
drogon.walk()

'''
东海龙 在飞行
东海龙 在游泳
东海龙 在步行
'''

六、接口类

java C# 接口可以被多继承，接口的方法不能有代码。

不允许类的多继承语言，规范继承类必须实现这个方法。

python 中没有接口，抽象类相当于接口

七、新式类和经典类

新式类：python3的版本中，所有的类都是新式类

所有的新式类都有一个默认的父类：object

class Person1:pass              # 定义类的写法1
class Person2():pass            # 定义类的写法2
class Person3(object):pass      # 定义类的写法3

print(Person1.__bases__)
print(Person2.__bases__)
print(Person3.__bases__)

'''
(<class 'object'>,)
(<class 'object'>,)
(<class 'object'>,)
'''

定义类的三种写法：

① 类名:

② 类名():

③ 类名(object):

python2.7版本是经典类和新式类并存

继承了object的类就是新式类：

python3中所有的类都是新式类

python2.7既有新式类又又经典类

不主动继承object都是经典类

新式类和经典类之间多继承顺序的区别：

新式类：

　　所有的多继承关系寻找方法的顺序是---遵循广度优先算法

　　① 走过的路不能重复

　　② 所有的点都要走到

　　新式类中可以使用类.mro() 查看继承顺序

　　super() 不是单纯的找父类，而是遵循mro顺序的

经典类：

　　经典类在找父类中方法的过程中---遵循深度优先

　　深度优先：①一条路走到底

　　　　　　 ② 走过的路不走

class A:pass
class B(A):pass
class C(A):pass
class D(B,C):pass

print(D.mro())

'''
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
'''

super() 不是单纯的找父类，而是遵循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')

print(D.mro())
D().func()


'''
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
A
C
B
D
'''

新式类与经典类的区别：

新式类：

①所有的多继承关系寻找方法的顺序---遵循广度优先算法

②继承object

③mro方法

④super(): super不是单纯的找父类，而是遵循mro顺序的

经典类：

① python2版本

② 不主动继承object

③ 经典类在找父类中方法的过程中遵循---深度优先

④ 不提供mro方法和super()

posted @ 2018-08-28 16:55 st--st 阅读(226) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Python小白白白白白白

Python面向对象之继承

公告