首页 > 其他分享 >面向对象-继承1

面向对象-继承1

时间：2022-12-01 00:11:36浏览次数：50  
标签：__ 继承 self 面向对象 init cake make def

一、继承的概念

　　生活中的继承，一般指的是子女继承父辈的财产。

　　拓展1：经典类或旧式类

　　不由任意内置类型派生出的类，称之为经典类。

　　class  类名：

　　　　代码

　　拓展2：新式类（常用）

　　class 类名（object）：

　　　　代码

　　python面向对象的继承指的是多个类之间的所属关系，即子类继承父类的所有属性和方法。

　　体验：

# 继承：子类默认继承父类的所有属性和方法
# 1. 定义父类
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 2. 定义子类，继承父类
class B(A):
    pass

# 3. 创建对象，验证结论
result = B()
result.info_print()

　　在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

二、单继承

# 1. 师傅类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master):
    pass

# 3. 用徒弟类创建对象，调用实例属性和方法
num = Prentice()

# 4. 对象访问实例属性
print(num.kongfu)

# 5. 对象调用实例方法
num.make_cake()

三、多继承

　　所谓多继承就是一个类同时继承了多个父类。

# 1. 师傅1类，属性和方法
class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')
# 2. 师傅2类，属性和方法
class Master2(object):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master2, Master1):
    pass

# 3. 用徒弟类创建对象，调用实例属性和方法
num = Prentice()

# 4. 对象访问实例属性
print(num.kongfu)

# 5. 对象调用实例方法
num.make_cake()

　　注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。

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

 

# 1. 师傅类，属性和方法
class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master1):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 3. 用徒弟类创建对象，调用实例属性和方法
num = Prentice()

# 4. 对象访问实例属性
# [自创秘籍]
print(num.kongfu)

# 5. 对象调用实例方法
# 运用[自创秘籍]打倒对手
num.make_cake()

# (<class '__main__.Prentice'>, <class '__main__.Master1'>, <class 'object'>)
print(Prentice.__mro__)

 

　　子类和父类具有同名属性和方法，默认使用子类的同名属性和方法。

　　__mro__显示继承顺序，如代码：

(<class '__main__.Prentice'>, <class '__main__.Master1'>, <class 'object'>)
　　Prentice-->Master1-->object

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

class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

class Master2(object):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master1, Master2):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

    def make_cake(self):
        # 加自己初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init属性值
        self.__init__()
        print(f'运用{self.kongfu}打倒对手')

    def make_master1_cake(self):
        # 父类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master1.__init__(self)
        Master1.make_cake(self)

    def make_master2_cake(self):
        Master2.__init__(self)
        Master2.make_cake(self)

# 3. 用徒弟类创建对象，调用实例属性和方法
num = Prentice()

# 4. 对象访问实例属性
# [自创秘籍]
# print(num.kongfu)

# 5. 对象调用实例方法
# 运用[自创秘籍]打倒对手
num.make_cake()

num.make_master1_cake()
num.make_master2_cake()
num.make_cake()

 

六、多层继承

class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

class Master2(object):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master1, Master2):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

    def make_cake(self):
        # 加自己初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init属性值
        self.__init__()
        print(f'运用{self.kongfu}打倒对手')

    def make_master1_cake(self):
        # 父类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master1.__init__(self)
        Master1.make_cake(self)

    def make_master2_cake(self):
        Master2.__init__(self)
        Master2.make_cake(self)

# 步骤：1.创建类Tusun，用这个类创建对象；2. 用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
    pass

xiaoai = Tusun()

# 运用[自创秘籍]打倒对手
xiaoai.make_cake()
# 运用[葵花宝典]打倒对手
xiaoai.make_master1_cake()

七、super（）调用父类方法

class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

class Master2(Master1):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

        # super（）带参数写法
        # super(Master2, self).__init__()
        # super(Master2, self).make_cake()
        # super() 无参数
        super().__init__()
        super().make_cake()

# 2. 徒弟类，继承师傅类
class Prentice(Master2):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

    def make_cake(self):
        # 加自己初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init属性值
        self.__init__()
        print(f'运用{self.kongfu}打倒对手')

    def make_master1_cake(self):
        # 父类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master1.__init__(self)
        Master1.make_cake(self)

    def make_master2_cake(self):
        Master2.__init__(self)
        Master2.make_cake(self)

    # 需求：一次性调用父类Master1 Master2的方法
    def make_old_cake(self):
        # 方法一：父类类名如果变化，这里代码需要频繁修改；代码量庞大，冗余。
        # Master1.__init__(self)
        # Master1.make_cake(self)
        # Master2.__init__(self)
        # Master2.make_cake(self)

        # 方法二：super（）带参数写法
        # 2.1 super(当前类名，self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 2.2 super()无参数
        super().__init__()
        super().make_cake()

num1 = Prentice()

num1.make_old_cake()

 八、私有权限

　　8.1 定义私有属性和方法

　　在python中，可以为实例属性和方法设置私有属性，即设置某个实例属性或实力方法不继承给子类。

　　设置私有权限的方法：在属性名或方法名 前面 加上两个下划线__。

　　从Prentice类开始添加：

 

class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

class Master2(object):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master1, Master2):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

        # 定义私有属性
        self.__money = 2000000

    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        # 加自己初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init属性值
        self.__init__()
        print(f'运用{self.kongfu}打倒对手')

    def make_master1_cake(self):
        # 父类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master1.__init__(self)
        Master1.make_cake(self)

    def make_master2_cake(self):
        Master2.__init__(self)
        Master2.make_cake(self)

# 步骤：1.创建类Tusun，用这个类创建对象；2. 用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
    pass

xiaoai = Prentice()

# 对象不能访问私有属性和私有方法
# print(xiaoai.__money)
# xiaoai.__info_print()

xiaohong = Tusun()
print(xiaohong.__money)  # 无法访问实例属性__money
xiaohong.__info_print()

 

　　注意：私有属性和私有方法只能在类里面访问和修改

　　8.2 获取和修改私有属性值

　　在python中，一般定义函数名get__xx用来获取私有属性，定义set__xx用来修改私有属性值。

 

class Master1(object):
    def __init__(self):
        self.kongfu = '[葵花宝典]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

class Master2(object):
    def __init__(self):
        self.kongfu = '[九阴白骨爪]'

    def make_cake(self):
        print(f'运用{self.kongfu}打倒对手')

# 2. 徒弟类，继承师傅类
class Prentice(Master1, Master2):
    def __init__(self):
        self.kongfu = '[自创秘籍]'

        # 定义私有属性
        self.__money = 2000000

    # 获取私有属性
    def get__money(self):
        return self.__money

    # 修改私有属性
    def set__money(self):
        self.__money =15000

    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        # 加自己初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init属性值
        self.__init__()
        print(f'运用{self.kongfu}打倒对手')

    def make_master1_cake(self):
        # 父类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master1.__init__(self)
        Master1.make_cake(self)

    def make_master2_cake(self):
        Master2.__init__(self)
        Master2.make_cake(self)

# 步骤：1.创建类Tusun，用这个类创建对象；2. 用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
    pass

xiaoai = Tusun()

# 调用get__money函数获取私有属性money的值
print(xiaoai.get__money())
# 调用set__money函数修改私有属性money的值
xiaoai.set__money()
print(xiaoai.get__money())

 

标签：__,继承,self,面向对象,init,cake,make,def
From： https://www.cnblogs.com/yz-b/p/16923962.html

相关文章

  • python-面向对象-类的封装-私有方法私有属性
    1.封装，就是把客观事物封装成抽象的类，并规定类中的数据和方法只让可信的类或对象操作。封装可分为两个层面：（1）第一层面的封装，创建类和对象时，分别创建两者的名称，只能通过类名或......
  • 实验5 继承和多态
    实验任务4pets.hpp#pragmaonce#include<iostream>usingstd::string;classMachinePets{private:stringnickname;public:MachinePets(conststri......
  • 实验5 继承和多态
    2022.11.23OOP实验课实验5继承和多态任务1验证性实验。C++标准库提供了一个容器类模板map，称为关联数组或字典，可以用来描述键-值对映射关系。在C++编码环境中，输入代......
  • js面向对象，封装构造函数
    面向对象and面向过程面向对象，只关注对象面向对象更适合软件，他不关注步骤，只关注结果面向过程，只关注过程面向过程更适合硬件，它有每一个步骤，而且它更关注每一步的过程构......
  • python基础-面向对象
    1.面向对象  面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性，所以可以先了解下什么是面向过程编程：  面向过程编程的核心是......
  • python中面向对象特性
    1.类的继承#面向对象的特性：封装，继承，多态#先有封装，才有继承#先有封装和继承，才有多态#1.类的继承#富二代继承财产#定义类，不写括号，也继承基类objectclassW......
  • 实验五 继承和多态
    任务四代码：pets.hpp:#pragmaonce#include<iostream>#include<string>usingnamespacestd;classMachinePets{public:MachinePets(conststring......
  • 实验五 继承和多态
    Pets.hpp#pragmaonce#include<iostream>#include<string>usingnamespacestd;classMachinePets{private:stringnickname;public:MachinePets(const......
  • 实验5 继承和多态
    实验任务4pets.hpp:#pragmaonce#include<iostream>#include<string>usingnamespacestd;classMachinePets{public:stringnickname;MachinePets(cons......
  • css三大特性——层叠性、继承性、优先级
    1.层叠性：就近原则，执行第二个div操作。2.继承性：p标签属于div，在div中写，p标签也会执行。3.优先级：继承 body{  }元素 div{ }、p {  }类选择器  .text{  }......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99