26_Python基础_继承

目录

面向对象三大特性:

1.  单继承

1.1 概念

1.2 语法

1.3 方法的重写

1.4  父类的 私有属性 和 私有方法

2.  多继承

2.1  多继承的使用注意事项

2.2  新式类与旧式 (经典) 类


面向对象三大特性:

  1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
  2. 继承 实现代码的重用, 相同的代码不需要重复的编写
  3. 多态 不同的对象调用相同的方法,  产生不同的执行结果,  增加代码的灵活度

1.  单继承

1.1 概念

继承的概念:  子类 拥有 父类 的所有 方法 和 属性

1.2 语法

1)定义格式:

class 类名(父类名):
 
    pass

  • 子类 继承自 父亲,  可以直接 享受 父类中已经封装好的方法,  不需要再次开发
  • 子类 中应该根据 职责,  封装 子类特有的 属性和方法

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog(Animal):
# 子类拥有父类的所有属性和方法
    def bark(self):
        print("汪汪叫")

dahuang = Dog()
dahuang.sleep()
dahuang.bark()
 

2)比如该例中专业术语为:

  • Dog 类是 Animal 类的子类, Animal 类是 Dog 类的父类, Dog 类从 Animal 类继承
  • Dog 类是 Animal 类的派生类, Animal 类是 Dog 类的基类, Dog 类从 Animal 类派生

3)继承具有传递性:

  • C 类从 B 类继承,  B 类又从 A 类继承
  • 那么 C 类就具有 B 类和 A 类的所有属性和方法
class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog(Animal):
# 子类拥有父类的所有属性和方法
    def bark(self):
        print("汪汪叫")

# 创建一个哮天犬类
class XiaoTianQuan(Dog):

    def fly(self):
        print("飞")

dahuang = XiaoTianQuan()
dahuang.bark()
dahuang.sleep()
dahuang.fly()

子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法 (儿子有父亲和爷爷的所有特点)

 

1.3 方法的重写

  • 子类 拥有 父类 的所有 方法 和 属性
  • 子类 继承自 父类,  可以直接 享受 父类中已经封装好的方法,  不需要再次开发

应用场景:

  • 当 父类 的方法实现不能满足子类需求时,  可以对方法进行 重新(voerwrite)。

重新 父类方法有两种情况:

  1. 覆盖 父类的方法
  2. 对父类方法进行 扩展

1)  覆盖父类的方法--子类中重写方法

  • 如果在开发中,  父类的方法实现 和 子类的方法实现, 完全不同,就可以使用 覆盖 的方式,  在子类中 重新编写 父类的方法实现

具体的实现方式,  就于在 子类中 定义了一个 和父类同名的方法并且实现。

重写之后,  在运行时,  只会调用 子类中重写的方法,  而不再回调用 父类封装的方法

2)  对父类方法进行 扩展

  • 如果在开发中,  子类的方法实现 中 包含 父类的方法实现父类 ,原本封装的方法实现 是 子类方法的一部分,就可以使用 扩展 的方式

实现方法:

  1. 在子类中 重写 父类的方法
  2. 在需要的位置使用 super( ).父类方法 来调用父类方法的执行
  3. 代码其他的位置针对子类的需求, 编写 子类特有的代码实现

关于 super:

  • 在 Python 中 super 是一个 特殊的类
  • super() 就是使用 super 类创建出来的对象
  • 最常 使用的场景就是在 重写父类方法时,  调用 父类中封装的方法实现
class Dog():

    def bark(self):
        print("汪汪叫")

class XiaoTianQuan(Dog):

    def fly(self):
        print("I can fly")

    def bark(self):

        # 1. 针对子类特有的需求, 编写代码
        print("我是神犬....")

        # 2. 使用super(), 调用原本在父类中的封装的方法
        super().bark()

        # 3. 增加其他子类的代码
        print("嗷呜嗷呜...")

xiaotianquan = XiaoTianQuan()
xiaotianquan.bark()

1.4  父类的 私有属性 和 私有方法

  1. 子类对象 不能 在自己的方法内部, 直接 访问 父类的 私有属性 或 私有方法
  2. 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法
  • 私有属性, 方法 是对象的隐私,  不对外公开,  外界 以及 子类 都不能直接访问
  • 私有属性, 方法 通常用于做一些内部的事情

实例1:在子类的对象中,访问父类私有属性和方法

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def __test(self):
        print("私有方法 %d %d"(self.num1,self.__num2))


class B(A):

    def demo(self):
        # 1.在子类的对象中,不能访问父类私有属性
        #print("访问父类的私有属性 %d" % self.__num2)
        # 2. 在子类对象中,不可调用父类的私有方法
        self.__test()
        pass


# 创建一个子类对象
b = B()
print(b)
# 在外界不能直接访问对象的私有属性/调用私有方法
#print(b.__num2)
#b.__test()
b.demo()

输出:

Traceback (most recent call last):
<__main__.B object at 0x0000021935D6F588>
  File "C:/Users/10428/Desktop/Py-project/面向对象特性/ky_07_父类的私有属性和私有方法.py", line 26, in <module>
    b.demo()
  File "C:/Users/10428/Desktop/Py-project/面向对象特性/ky_07_父类的私有属性和私有方法.py", line 16, in demo
    self.__test()
AttributeError: 'B' object has no attribute '_B__test'

Process finished with exit code 1

结论:子类对象 不能 在自己的方法内部, 直接 访问 父类的 私有属性 或 私有方法

实例二:在子类的对象中,通过父类方法,间接访问父类私有属性和方法

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def __test(self):
        print("私有方法 %d %d"%(self.num1,self.__num2))

    def test(self):
        print("父类的公有方法")
        self.__test()

class B(A):

    def demo(self):
        # 1.在子类的对象中,不能访问父类私有属性
        #print("访问父类的私有属性 %d" % self.__num2)
        # 2. 在子类对象中,不可调用父类的私有方法
        #self.__test()
        # 3.访问父类的公有属性
        print("子类方法 %d" % self.num1)
        # 4.调用父类的公有方法
        self.test()

        pass


# 创建一个子类对象
b = B()
b.demo()

2.  多继承

概念:

  • 子类 可以拥有 多个父类,  并且具有 所有父类  属性  方法
  • 例如: 孩子 会继承自己 父亲  母亲 的 特性

语法:

class 子类名(父类名1, 父类名2...):
    pass
class A:

    def test(self):
        print("test方法")


class B:

    def demo(self):
        print("demo方法")


class C(A, B):
    """多继承可以让子类对象, 同时具有多个父类的属性和方法"""
    pass


# 创建子类
c = C()
c.test()
c.demo()

2.1  多继承的使用注意事项

问题的提出

  • 如果 不同的父类 中存在 同名的方法,  子类对象 在调用方法时,  会调用 哪一个父类中的方法呢?

提示 : 开发时,  应该尽量避免这种容易产生混淆的情况!  ---- 如果 父类之间 存在 同名的属性或者方法,  应该 尽量避免 使用多继承

class A:
 
    def test(self):
        print("父类A")
 
 
class B:
 
    def test(self):
        print("父类B")
 
 
class C(A, B):
    """多继承可以让子类对象, 同时具有多个父类的属性和方法"""
    pass
 
 
# 创建子类
c = C()
c.test()

Python 中的 MRO ---- 方法搜索顺序 (科普)

  • Python 中针对 类 提供了一个 内置属性 __mro__ 可以查看 方法 搜索顺序
  • MRO 是 method resolution order , 主要用于 在多继承时判断 方法, 属性, 的调用 路径

print(C.__mro__)

输出结果 :

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

小结: 

  • 在搜索方法时,  是按照 __mro__的输出结果 从左至右 的顺序查找的
  • 如果在当前类中 找到方法,  就直接执行,  不再搜索
  • 如果 没有找到, 就查找下一个类 中是否有对应的方法,  如果找到,  就直接执行,  不再搜索
  • 如果找到最后一个类,  还没找到方法,  程序报错

2.2  新式类与旧式 (经典) 类

object 是 Python 为所有对象提供的 基类,  提供有一些内置的属性和方法,  可以使用 dir 函数查看

  • 新式类 :  以 object 为基类的类,  推荐使用
  • 经典类 :  不以 object 为基类的类,  不推荐使用
  • 在 Python 3.x 中定义类时,  如果没有指定父类,  会 默认使用 object 作为该类的 基类  ----  Python 3.x 中定义的类都是 新式类
  • 在 Python 2.x 中定义类时,  如果没有指定父类,  则不会以 object 作为 基类

新式类 和 经典类 在多继承时 ---- 会影响到方法的搜索顺序

为了保证保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行!

今后在定义类时,  如果没有父类,  建议统一继承自 object

class 类名(object):
    pass

提示: 可以使用 dir(对象),查看内部属性和方法

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值