DAY33继承实现原理、子类调用父类的方法、封装

最新推荐文章于 2024-08-28 08:45:00 发布
最新推荐文章于 2024-08-28 08:45:00 发布
阅读量553 收藏
点赞数
分类专栏： 学习笔记 文章标签： python 继承 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gavin3318/article/details/74483464
版权

继承实现原理

python中的类可以同时继承多个父类，继承的顺序有两种：深度优先和广度优先。
这里写图片描述
一般来讲，经典类在多继承的情况下会按照深度优先的方式查找，新式类会按照广度优先的方式查找

示例解析：

没有共同头部父类的类型
这里写图片描述

class E:
    def test(self):
        print('from E')
    # pass
class F:
    def test(self):
        print('from F')
    # pass

class C:
    def test(self):
        print('from C')
    # pass

class B(C):
    def test(self):
        print('from B')
    # pass

class D(E):
    def test(self):
        print('from D')
    # pass
class A(B,D,F):
    def test(self):
        print('from A')
    # pass
obj=A()
obj.test()

在这种模型下，新式类和经典类的继承顺序都一样。

调用obj.test()，首先找boj对象的dict字典，然后找生成类A的dict字典，如果这两个都没有，会按照以下顺序进行查找，找到为止：

ClassA->ClassB->ClassC->ClassD->ClassE->ClassF

如果都找不到，抛出异常错误。
有共同头部父类的类型
这里写图片描述

class D(object):
    def test(self):
        print('from D')
    # pass
class C(D):
    def test(self):
        print('from C')
    # pass
class B(C):
    def test(self):
        print('from B')
    # pass
class F(D):
    def test(self):
        print('from F')
    # pass
class E(F):
    def test(self):
        print('from E')
    # pass
class H(D):
    def test(self):
        print('from H')
    # pass
class G(H):
    def test(self):
        print('from G')
    # pass

class A(B,E,G):
    def test(self):
        print('from A')
    # pass

obj=A()
obj.test()
print(A.mro())

在这种模型下，新式类和经典类查找继承顺序不同。

新式类使用的是广度优先的方式，调用obj.test()，首先找boj对象的dict字典，然后找生成类A的dict字典，如果这两个都没有，会按照以下顺序进行查找，找到为止：

classA->classB->classC->classE->classF->classG->classH->classD->-classobject

#经典类不继承object
class D:
    def test(self):
        print('from D')
    # pass
class C(D):
    def test(self):
        print('from C')
    # pass
class B(C):
    def test(self):
        print('from B')
    # pass
class F(D):
    def test(self):
        print('from F')
    # pass
class E(F):
    def test(self):
        print('from E')
    # pass
class H(D):
    def test(self):
        print('from H')
    # pass
class G(H):
    def test(self):
        print('from G')
    # pass

class A(B,E,G):
    def test(self):
        print('from A')
    # pass

obj=A()
obj.test()

经典类（python2中才有经典类的概念，python3中都是新式类）使用的是深度优先的方式，调用obj.test()，首先找boj对象的dict字典，然后找生成类A的dict字典，如果这两个都没有，会按照以下顺序进行查找，找到为止：

ClassA->ClassB->ClassC->ClassD->ClassE->ClassF->ClassG
mro方法
python的继承顺序，是按照一定的算法生成的mro表进行顺序查找继承的，只有在新式类中才有该方法：该方法有以下三个特点：

1.子类会先于父类被检查：

2.多个父类会根据它们在列表中的顺序被检查

3.如果对下一个类存在两个合法的选择,选择第一个父类

例如示例二有共同头部父类的模型，新式类mro输出表如下，按照表顺序进行继承：
1 print(A.mro())
2 [

子类调用父类的方法（内置函数super）

low版调用方法，还是那个teacher还是那个people：

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def foo(self):
        print('from parent')

class Teacher(People):
    def __init__(self,name,age,sex,salary,level):
        People.__init__(self,name,age,sex) #指名道姓地调用People类的__init__函数
        self.salary=salary
        self.level=level
    def foo(self):
        print('from child')

t=Teacher('bob',18,'male',3000,10)
print(t.name,t.age,t.sex,t.salary,t.level)
t.foo()

low版调用方法，在更改父类的名字之后，需要改动的地方除了子类继承的父类名字，还要改子类里面调用的父类名，比较麻烦

高端大气调用方式：只需要改动子类继承的父类名，即括号里的父类名
字

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def foo(self):
        print('from parent')

class Teacher(People):
    def __init__(self,name,age,sex,salary,level):
        #在python3中
        super().__init__(name,age,sex) #调用父类的__init__的功能，实际上用的是绑定方法，用到了mro表查询继承顺序，只能调用一个父类的功能
        #在python2中
        # super(Teacher,self).__init__(name,age,sex)    #super(Teacher,self)是一个死格式
        self.salary=salary
        self.level=level
    def foo(self):
        super().foo()
        print('from child')

t=Teacher('bob',18,'male',3000,10)
print(t.name,t.age,t.sex,t.salary,t.level)
t.foo()

但是这种方式也有一个缺点，就是当一个子类继承了多个父类的时候，如果多个父类都包含了相同的属性名，当要调用该功能的时候，只能调用第一个父类的功能，无法实现多个父类同时调用。多个父类同时调用还是要用low版方法。

封装

封装是一种隐藏的方式，包括数据封装和功能封装，即类里的数据属性和功能属性，隐藏数据和功能是为了限制直接调用，通过人为的添加调用接口进行数据和功能的调用。

封装不是单纯意义的隐藏：（史上最lowB的解释）

　　1：封装数据的主要原因是：保护隐私（作为男人的你，脸上就写着：我喜欢男人，你害怕么？）

　　2：封装方法的主要原因是：隔离复杂度，提供简单的访问接口（快门就是傻瓜相机为傻瓜们提供的接口，该方法将内部复杂的照相功能都隐藏起来了，拍照只需要通过快门这个接口就可以了，再比如你不必知道你自己的尿是怎么流出来的，你直接掏出自己的接口就能用尿这个功能）

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

封装的两个层面

基础的封装（什么都不用做）：创建类和对象会创建各自的名称空间，通过类名. 或者对象. 的方式去访问类或对象里面的数据属性和功能属性。

还是这个people

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def foo(self):
        print('from parent')
print(People.__dict__)
p=People('natasha',18,'female')
print(p.name)
p.foo()

通过p.name访问到了natasha，通过p.age访问到了18，这一类就是最基础的类和对象的封装，而p.name、p.foo()就是接口，访问数据属性和功能属性的接口。

二层封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

封装方式：在python中用双下划线的方式实现隐藏属性（设置成私有的）

class Teacher:
    __school='oldboy' #实际上转换成了_Teacher__school
    def __init__(self,name,salary):
        self.name=name
        self.__salary=salary #实际上转换成了self._Teacher__salary
    def __foo(self):
        print('====foo====')
t=Teacher('egon',3000)

# print(t.__school)    #无法调用
print(Teacher.__dict__)  
# t.foo()    #无法调用
t._Teacher__foo()
# print(t.salary)     #无法调用
# print(t.__salary)    #无法调用
print(t.__dict__)
print(t._Teacher__salary)

基础类里面的函数

封装数据

__数据属性

封装功能

这种变形操作，只在类的定义阶段发生或者对象定义阶段

在类的外部无法直接使用变形的属性，但是在类中可以直接使用
这里写图片描述

Java基础-day14-Collection接口·List父类接口·ArrayList子类·LinkedList 链表 ·set接口·Map接口·HashMap
weixin_58678891的博客
06-22 425
Collection接口·List父类接口·ArrayList子类可实现类·LinkedList 链表 子类可实现类·set接口·Map接口·HashMap 可实现子类
day12 封装和继承 （二）
weixin_44982904的博客
02-23 479
1.static关键字实现原理 方法区：方法区是SUN公司提出的一个规范，JDK8之前称之为永久代，JDK8开始称之为元数据。 静态区：是指static相关的信息存储的区域。 创建对象的过程： 1.当我们new对象，JVM会先在方法区中检查，是否此类的class文件已经被加载。 如果没有加载，则先将class文件加载到方法区，此时静态相关的信息将初始化 如果已经加载，则直接执行第二步 2.在堆中开辟空间，此时实例属性将有默认值 3.将栈中的引用指向堆中的空间 永久代/元数据：因为在方法区
java子类调用父类的方法中包含子类重写的实例方法
08-25
在本篇文章里小编给大家整理了关于java子类调用父类的方法中包含子类重写的实例方法以及相关知识点，需要的朋友们可以学习下。
Python_子类调用父类的方法
weixin_33939380的博客
04-28 1003
1.方式一子类调用父类的方法，包含2中形式的调用。一种形式是在类内部通过继承的方式调用父类的方法，另外一种形式是子类实例化后之后通过继承的方式来调用父类的方法。如下图所示：注意一点，在子类内部通过继承的方式调用父类的属性时，必须要带上self位置参数（self只在实例化过程中和在实例调用属性时才能省略（self本来的含义就是指向实例自己））；而实例在通过继承调用父类的属性或方法时，则不用传self...
Vue | Vue子组件和父组件如何互相调用对方的方法
最新发布
青春木鱼的博客
08-28 1218
Vue子组件和父组件如何互相调用对方的方法
JavaScript中子类调用父类方法
weixin_30915275的博客
05-01 321
很久之前就在用JavaScript了，只是用的比较表层，会写几个函数而已，也没有深入的研究过。最近一段时间，由于项目的需要，看了一些关于JavaScript的书，也写了不少的JavaScript的代码，慢慢开始对这个东东着迷了。现在JavaScript在Web应用中的比重越来越大，各种好用的库也层出不穷，即使对JavaScript了解的比较浅显，也可以利用各种利器做出很不错的作品。但是，...
Python在子类中调用父类方法
ljh18885466426的博客
08-07 7361
1、在子类中调用父类方法 super（）.方法名（） 类名.方法名（self） spuer（要从哪一个类的上一级类开始查找， self）.方法名（） 子类调用父类方法时，一般都是想对父类方法进行扩展 class Person(object): def __init__(self, name, age): self.name = name self.age = age def driver(self): print('开车太好玩了 ,10迈
Day19：继承实现的原理、子类中调用父类的方法、封装
weixin_30915951的博客
07-05 260
一、继承实现的原来 1、继承顺序 Python的类可以继承多个类。继承多个类的时候，其属性的寻找的方法有两种，分别是深度优先和广度优先。 如下的结构，新式类和经典类的属性查找顺序都一致。顺序为D--->A--->E--->B--->C。 class E: def test(self): print('from E') clas...
Java基础——Day09——封装、继承、包、抽象类
weixin_48228288的博客
05-26 162
Java基础——Day09 今日内容： 封装 包及访问权限控制 基本类型值传递和引用类型传递 继承 1.封装
每日一学（4）——封装、继承功能的实现案例--员工类系列定义
weixin_42517286的博客
06-26 814
案例介绍：某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部员工、维护部员工）。研发部根据所需研发的内容不同，又分为JavaEE工程师、Android工程师；维护部根据所需维护的内容不同，又分为网络维护工程师、硬件维护工程师。公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。 工作内容：1、JavaEE工程师：员工号为xxx的 xxx员工，正在研发淘宝网站2、...
子类调用父类方法
cncnlg的专栏
11-07 812
class Base { public: void f() { cout << "Base::f" << endl; } }; class Derived : public Base { public: void f() { cout << "Derived::f" << endl; Base::f(); } }; int main() { Derived d; d
子类中调用父类方法
weixin_30624825的博客
05-24 1076
可以用中文做变量 实例化和对象调用方法会自动传递self super调用父类方法：super().__init__(name,speed)，不用传self，更爱父类名补收影响 class Dad1: def zou(self): print(123) class Son(Dad1): def _zou(self): su...
子类调用父类的用法
li237的博客
06-03 2264
如果子类没有重写父类的方法，调用父类的方法用不用super关键字结果都一样。 如果子类重写父类的方法，调用父类的方法必须用super关键字。 class TestA{ public void a(){ System.out.println("this is TestA a method"); } public void b(){ System.out.println("this is TestA b method"); } }
C++——子类调用父类方法
c2unix的专栏
08-29 1万+
C++——子类调用父类方法 原创声明：本文系博主原创文章，转载或引用请注明出处。 1. 如果类B是类A的子类，则在类B的成员方法中调用类A的方法时，可以直接以A::method(paramlist);来调用。 2. 若子类B重写(overwrite)了父类A的同名方法，则类A的实例调用的是类A的方法，类B的实例调用的是类B的方法；将类B实例的指针指向类A的指针变量ptr，则通过ptr调用的是类A的方法； 3. 若定义了类B的实例B1，则通过B1调用类A的方法的用法为：B1.A::m...
子类父类方法的互相调用
浩浩的博客
08-18 2687
java子类和父类
【C#】C#中子类调用父类的实现方法
热门推荐
乌药ice
05-02 1万+
本文实例讲述了C#中实现子类调用父类的方法，分享给大家供大家参考之用。具体方法如下：public class Person { public Person() { Console.WriteLine("我是人"); } } public class Student : Person { public Student() { Conso...
子类调用父类java_java在第三方类中子类调用父类方法
weixin_39947396的博客
02-20 115
package com.company;/*** Created by liuyazhou on 2016/9/21.*/public class Test {public Integer fun(Integer a ,Integer b){ ////如果此方法是private 的，则Main.java中 System.out.println( testSon.fun(1,2));报错return...
java中子类调用父类的方法6,java子类调用父类的方法中包含子类重写的实例方法...
weixin_36337756的博客
03-21 175
# 看题目是不是很绕，这个我也不知道怎么才能更简单的表达了# 先看代码：public class Common {public static void main(String[] args) {Sub sub = new Sub();sub.testSub();}}class Parent {protected boolean test() {throw new RuntimeException(...
面向对象进阶：封装、继承、多态与方法重写
"day22 A班笔记——面向对象的封装、继承、多态以及方法的重写、重载与构造方法" 在面向对象编程中，封装、继承和多态是三个核心概念。 封装是面向对象编程的基础，它将数据和操作数据的方法绑定在一起，作为一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值