Python 面向对象 (二) 继承

Python 面向对象 (二) 继承

面向对象- 继承

• 目标
• 一 继承的概念
• 二 单继承
• 三 多继承
• 四 子类重写父类同名 方法和属性
• 五 类名 __mro__():
• 六 子类调用父类的同名属性和方法
• 七 多层继承
• 八 super 调用父类方法
• 九 获取和修改私有属性
• 自由属性里面
• 定义函数:获取私有属性 get_
• 定义函数: 修改私有属性
• 十 总结 继承

目标

• 继承的概念
• 单继承
• 多继承
• 子类重写父类的 同名属性和方法
• 子类调用分类的 同名属性和方法
• 多层继承
• super()
• 私有属性和私有方法

一 继承的概念

概念 指多个类之间的从属关系, 子类默认继承父类的所有属性和方法
好处 ① 节省了代码量
特别说明 Python中所有类, 默认都继承了顶级类(基类)object.
体验

# 定义父类
class 父():
   # 初始化属性
   def __init__(self):
       self.姓="刘"
   # 方法
   def 打印姓氏(self):
       print(self.姓)
# 定义子类,继承父类
class 子(父):
   # pass  啥都没有  不报错
   pass
   
# 创建对象
大儿=子()
# 验证 属性
print(大儿.姓)  # 返回 刘
# 验证方法
大儿.打印姓氏()  # 返回  刘

二 单继承

一对一 一个老师 ,一个徒弟
故事
王二狗找师父要了配方 做煎饼

[分析步骤]
① 定义师父类 ,初始化属性和方法
@ 定义徒弟类,继承师父的 属性和方法, 自己不要设置属性方法
③ 以徒弟类创建对象,并验证 是否继承了 父类的属性和方法

# 师父类,属性和方法
class 师父():
    # 初始化属性
    def __init__(self):
        self.技能="[古法煎饼制作大法]"
    # 方法
    def 做煎饼(self):
        print(f"用{self.技能},制作大煎饼")
# 徒弟类, 继承师父的方法,本身不设方法和属性
class 徒弟(师父):
    # pass  啥都没有  不报错
    pass
# 用徒弟类创建对象
王二狗=徒弟()
# 验证 属性
print(王二狗.技能)  # 返回 古法煎饼制作大法
# 验证方法
王二狗.做煎饼()  # 返回  用古法煎饼制作大法,制作大煎饼

三 多继承

多对多 多个师父 一个儿子
[故事]
王二狗 ,又找学校 学了一套配方
[步骤分析]
① 定义父类 师父类和学校类 分别初始化属性和方法
@ 创建徒弟类, 继承父类的 属性和方法
③ 创建对象,验证徒弟 如何继承父类
[结论]
不指定的情况下 优先继承第一个父类的同名属性和方法

# 父类-师父类,属性和方法
class 师父():
    # 初始化属性
    def __init__(self):
        self.技能="[古法煎饼制作大法]"
    # 方法
    def 做煎饼(self):
        print(f"用{self.技能},制作大煎饼")
# 父类 --学校
class 学校():
    def __init__(self):
        self.技能="蓝翔精致煎饼法"
    def 做煎饼(self):
        print(f"用{self.技能},做大煎饼")
# 徒弟类, 继承师父的方法,本身不设方法和属性
class 徒弟(师父,学校):
    # pass  啥都没有  不报错
    pass
# 用徒弟类创建对象
王二狗=徒弟()
王大狗=徒弟()
# 验证 属性
print("王二狗继承的技能:",王二狗.技能)  # 返回 王二狗继承的技能: [古法煎饼制作大法]
print("王大狗继承的技能:",王大狗.技能)   # 返回  王大狗继承的技能: [古法煎饼制作大法]
# 验证方法
王二狗.做煎饼() 
 # 返回  用古法煎饼制作大法,制作大煎饼  #优先继承 第一个父类的属性和方法
王大狗.吃煎饼()  
# 学校还教会了,用[古法煎饼制作大法]吃煎饼   (可单独 调用 父类方法 .)

四 子类重写父类同名 方法和属性

父子都有的 以子为主, 子类 覆盖父类属性和方法
[故事]
拥有两套配方的王二狗 ,自己独创了一套配方
[结论]
父子类都有的同名属性和方法 ,以子类的为主

体会

# 父类-师父类,属性和方法
class 师父():
    # 初始化属性
    def __init__(self):
        self.技能="[古法煎饼制作大法]"
    # 方法
    def 做煎饼(self):
        print(f"用{self.技能},制作大煎饼")
class 徒弟(师父):
    # 徒弟也有料了
    def __init__(self):
        self.技能="狗家煎饼秘籍"
    def 做煎饼(self):
        print(f"用{self.技能},做煎饼")
# 用徒弟类创建对象
王二狗=徒弟()
# 验证 属性
print("王二狗继承的技能:",王二狗.技能)  # 返回 王二狗继承的技能: 狗家煎饼秘籍
# 验证方法
王二狗.做煎饼()  # 返回  用狗家煎饼秘籍,做煎饼

五 类名 mro():

查看某个类的继承关系

print(徒弟.__mro__)
=>(, , )

六 子类调用父类的同名属性和方法

[故事推进] 顾客 可以点餐: 徒弟的 师父的 学校的方法制作的不同煎饼
[先上代码]

#--*coding=utf-8*--
"""
[子类调用父类的同名属性和方法]
"""
# 父类
class 师父():
    def __init__(self):
        self.技能="古法煎饼秘籍"
    def 制作煎饼(self):
        print(f"用{self.技能}做煎饼")

class 学校():
    def __init__(self):
        self.技能="黑马技术"
    def 制作煎饼(self):
        print(f"用{self.技能}煎饼")

# 子类  多层继承  添加父类的同名属性方法
class 徒弟(师父,学校):
    def __init__(self):
        self.技能="独创奈哌煎饼大法"
    def 制作煎饼(self):
        # 如果调用了下面的父类方法和属性,父类就会覆盖子类的属性和方法,故要用 init初始化
        self.__init__()
        print(f"用{self.技能}做大煎饼")
    # 子类调用父类同名方法和属性:把父类的同名方法和属性再次封装
    def 师父教的(self):
        # 这里调用init的原因:调用父类的同名属性,如果不init初始化,会显示子类的属性和方法
        师父.__init__(self)
        # 父类名.函数
        师父.制作煎饼(self)
    def 学校教的(self):
        学校.__init__(self)
        学校.制作煎饼(self)


# 用子类创建对象 并验证 调用属性和方法

王二狗=徒弟()
print(王二狗.技能)     #独创奈哌煎饼大法
王二狗.制作煎饼()   #用独创奈哌煎饼大法做大煎饼

王二狗.师父教的()  #用古法煎饼秘籍做煎饼
王二狗.学校教的()   # 用古法煎饼秘籍做煎饼

王二狗.制作煎饼()

[几个点]
1 子类 写函数是 用init再次初始化
2 子类在调用父类同名属性和方法的时候 也要先初始化

七 多层继承

[故事] 徒弟老了 ,要传徒孙
[上代码 片段]

#孙子类
class 徒孙(徒弟) :
    pass

# 用孙子类创建对象 并调用子类和父类属性和方法
王小狗 = 徒孙()
print("徒孙")
print(王小狗.技能)  # 调用子类: 独创奈哌煎饼大法
王小狗.师父教的()  #调用父类:用古法煎饼秘籍做煎饼

八 super 调用父类方法

super()
无参数 调用父类的属性和方法,只适合在 单继承中使用
[语法]

def 师父教的(self):
	super().__init__()
	super().制作煎饼()

[代码]

# --*coding:utf-8*--
"""
[super]
super 无参数调用父类,只能用在单继承
"""
# 父类
class 师父():
    def __init__(self):
        self.技能="古法煎饼"
    def 制作煎饼(self):
        print(f"用{self.技能},制作煎饼")
class 学校():
    def __init__(self):
        self.技能="黑马技术"
    def 制作煎饼(self):
        print(f"用{self.技能},制作煎饼")

# 子类
class 徒弟(师父,学校): #  只调用第一个父类
    def __init__(self):
        self.技能="独创神功"
    def 制作煎饼(self):
        self.__init__()
        print(f"用{self.技能}.做大煎饼")
    def 师父教的(self):
        super().__init__()
        super().制作煎饼()
    def 学校教的(self):     
        super().__init__()   # 只默认 师父, 学校被覆盖
        super().制作煎饼()
        super(学校.self).技能()  #这段是无效的  不会调用多继承  

王二狗=徒弟()

print(王二狗.技能)
王二狗.制作煎饼()
王二狗.师父教的()
王二狗.学校教的()

九 获取和修改私有属性

• 在类里面定义函数进行修改和获取
  [故事]
  师父教的技能,自有属性 学费,为2w元,
  如何 调用这个学费和修改它
  [语法]

  自由属性里面

  def init():
  self.学费=2000

  定义函数:获取私有属性 get_

  def get_学费(self):
  return self.学费

  定义函数: 修改私有属性

  def set_学费(self,欲修改值):
  self.学费=欲修改值

•   # 创建对象
    王二狗=徒弟()
    王二狗.set_学费(500)
  

[代码]

# --*coding:utf-8*--
"""
get_函数  和 set_函数 获取和修改类里面的类的私有属性
"""
# 父类
class 师父():
    def __init__(self):
        self.技能="古法煎饼"
    def 制作煎饼(self):
        print(f"用{self.技能},制作煎饼")
class 学校():
    def __init__(self):
        self.技能="黑马技术"
    def 制作煎饼(self):
        print(f"用{self.技能},制作煎饼")

# 子类
class 徒弟(师父):
    def __init__(self):
        self.技能="独创神功"
        #在 super的代码基础之上
        # 再定义一个 自由属性,联系 get_xx和 set_xx
        self.学费=20000
    # 定义函数  :获取私有属性值
    def get_学费(self):
        return self.学费
    # 定义函数 :修改私有属性值  set_xx
    def set_学费(self,学费):
        self.学费=学费
    def 制作煎饼(self):
        self.__init__()
        print(f"用{self.技能}.做大煎饼")
    def 师父教的(self):
        super().__init__()
        super().制作煎饼()


王二狗=徒弟()

print(王二狗.技能)
王二狗.制作煎饼()
王二狗.师父教的()

print(王二狗.get_学费())  # 20000

王二狗.set_学费(10000)
print(王二狗.get_学费())   # 10000

十 总结 继承

• 继承的特点

  • 子类拥有父类的所有方法和属性 class 子类(父类):
  • 子类重写父类方法和属性 覆盖
  • 子类调用父类的方法和属性

• super 方法,快速调用父类属性和方法

   super().__init__()
   super().函数名()
  

  自动寻找,单继承

• 私有权限 属性名和函数前 加__

  • 不能继承给子类的方法和属性 ,需要添加私有权限

  • 语法

      class 类名():
      	#  私有属性
      	__属性名=值
      	#  私有方法
      	def _函数名(self):
      		代码
    

[版权声明] 文字整理 b
站视频 https://www.bilibili.com/video/BV1kT4y1971R?p=27
原作者不明,侵删