继承和派生
Posted ᰔᩚ. 一怀明月ꦿ
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了继承和派生相关的知识，希望对你有一定的参考价值。
🐶博主主页：@ᰔᩚ. 一怀明月ꦿ
❤️🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章，「初学」C++
🔥座右铭：“不要等到什么都没有了，才下定决心去做”
🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀
目录
🐰继承和派生的概念
面向对象的设计有四个重要的特征：抽象，封装，继承和多态性
所谓的“继承”就是在一个或多个已存在的类的基础上建立一个新的类。已存在的类称为“基类”“父类”或“一般类”。新建立的类称为“派生类”“子类”或“特殊类”
“基类”和“派生类”是相对而言的。一个基类可以派生出多个派生类，每一个派生类又可以作为基类派生出新的派生类。
🐰派生类的声明
单继承派生类的声明：
Class 派生名:继承方式 基类名 派生类新加的成员 ;其中，继承方式可以是public,protected,private，分别对应公有继承，受保护继承，私有继承。此项可选的，如果不写此项，则默认为private。
🐰派生类的构成
派生类中的成员保括从基类继承过来的成员和自己新增加的成员两大部分，从基类继承过来的成员体现了派生类从基类继承而获得的共性，而新增加的成员体现了派生类的个性。
🌸1.从基类接受成员
派生类要接收基类全部的成员（但不包括基类的构造函数和析构函数）也就是说没机会选择的，不能选择接受一部分，而舍弃一部分。
🌸2.调整从基类接受的成员
虽然派生类对基类成员的继承是没有选择的全部继承。但我们对成员做出调整。（1）可以改变基类成员在派生类的访问属性，这是通过指定继承方式来实现的，如果在声明派生类时指定继承方式是私有的，则基类中的公有成员和受保护成员在派生类中的访问属性就是私有的，在派生类外不能访问。（2）可以在派生类中声明一个与基类成员同名的成员，则派生类的新成员会屏蔽与其同名的基类成员。
🌸3.增加新成员
这体现了对基类功能的扩展，在声明派生类时，还应该定义派生类的构造函数和析构函数，因为构造函数和析构函数是不能从基类继承的。
🐰派生类中基类成员的访问属性
派生类中基类成员的访问属性不仅与在声明基类时所声明的访问属性有关，而且与在声明派生类时所指定的对基类继承方式，以及类内using声明语句的使用情况有关
🌸公用继承：
基类的公用成员和受保护成员在派生类中保持原有的访问属性，其私有成员仍为基类私有（派生类不可访问）
🌸私有继承：
基类的公用成员和受保护成员在派生类中成了私有成员，其私有成员仍为基类私有（派生类不可访问）
🌸受保护的继承：
基类的公用成员和受保护成员在派生类中成了受保护成员，其私有成员仍为基类私有（派生类不可访问）
受保护成员的意思：不能被外界访问，但可以被派生类的成员访问
公用继承：采用公用继承的方式时，基类的公用成员和受保护成员在派生类中保持原有的访问属性，而基类的私有成员在派生类中并没有成为派生类的私有成员，它还是基类的私有成员，只有基类的成员函数可以访问它，而不能被派生类的成员函数访问，因此就成为派生类中的不可访问的成员
私有继承：
私有基类的公用成员和受保护成员在派生类中的访问属性相当于派生类的私有成员，即派生类的成员函数能访问它们，而在派生类外不能访问它们。私有基类的私有成员在派生类中成为不可访问的成员，只有基类的成员函数可以访问它们。
保护成员和保护继承：在声明一个派生类时对基类的继承方式指定为protected的，成为保护继承，用保护继承方式建立的派生类称为保护派生类，其基类称为受保护的基类，也称保护基类。
保护继承的特点：保护基类的公用成员和保护成员在派生类中都成了保护成员，而基类的私有成员在派生类中并没有成为派生类的私有成员，它还是基类的私有成员。也就是把基类原有的公用成员也保护起来，不让类外访问。
🐰总结
1.派生类中，成员有四种不同的访问属性
（1）公用的：派生类内外都可以访问。
（2）受保护的：派生类内可以访问，派生类外不能访问，其下一层的派生类可以访问（公用继承）
（3）私有的：派生类内可以访问，派生类外不能访问。
（4）不可访问的：派生类内外都不可以访问。
注意：
（1）这里列出的成员的访问属性是指在派生类中所获得的访问属性
（2）所谓的派生类外部，是指在建立派生类对象的模块中，在派生类范围之外
（3）如果本派生类继续派生，则在不同的继承方式下，成员所获得的访问属性是不同的。
2.类的成员在不同作用域有不同的访问属性。
在学习过派生类之后，再讨论一个类的某成员的访问属性，一个要指明是在哪一个作用域中。如基类Circle的成员函数seRadius,它在基类中的访问属性是公用的，在私有派生类Cylinder中的访问属性私有的。
比较私有继承和保护继承，可以发现，直接派生类中，以上两种继承方式的作用实际上是相同的：在类外不能访问基类中的任何成员，而在派生类中可以通过成员函数访问基类中的公用成员和保护成员。但如果继续派生，在新派生类中，两种继承方式的作用就不同了。例如，如果以公用继承方式派生出一个新派生类，原有私有基类中的成员在新派生类中都成为不可访问的成员，无论在新派生类内或外都不可能访问，而原来保护基类中的公用成员和保护成员在新派生类中为保护成员，可以被新派生类的成员函数访问。
有时我们需要改变派生类继承得基类某个成员的可访问性，通过使用using声明。
#include<iostream> using namespace std; class Base public: size_t size() const return n; protected: size_t n=0; ; class Derived:private Base public: using Base::size; protected: using Base::n; ; int main() Derived s1; cout<<s1.size()<<endl; return 0; 结果为：0
🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸
类的继承和派生
一、类的继承、派生和组合
继承是一种创建新类的方式，在Python中，新类可以继承一个或多个父类，父类又可称为基类或者超类，新建的类称为派生类或子类。
在Python3中，所有类都默认继承object，都是新式类。
在Python2中，有经典类和新式类。
没有继承object类以及object的子类的类都是经典类。
1、继承
Python中类的继承分为：单继承和多继承
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass1
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
查看继承
使用<类名.__base__>查看类的第一个父类
使用<类名.__bases__>查看类的父类
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个父类 (<class \'__main__.ParentClass1\'>,) >>> SubClass2.__bases__ #__bases__则是查看所有继承的父类 (<class \'__main__.ParentClass1\'>, <class \'__main__.ParentClass2\'>)
提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
>>> ParentClass1.__bases__ (<class \'object\'>,) >>> ParentClass2.__bases__ (<class \'object\'>,)
class People:
pass
class Animal:
pass
class Student(People,Animal):
pass
print(Student.__bases__) #(<class \'__main__.People\'>, <class \'__main__.Animal\'>)
print(People.__bases__) #(<class \'object\'>,)
print(Animal.__bases__) #(<class \'object\'>,)
print(Student.__base__) #<class \'__main__.People\'>
继承也是为了解决代码重复的问题，减少代码冗余。
继承是用来创建新的类的一种方式。
继承是一种什么“是”什么的关系。
2、继承与抽象（先抽象再继承）
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。
3、继承与重用性
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时，我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。
class Hero:
def __init__(self,nickname,aggressivity,life_value):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
def attack(self,enemy):
enemy.life_value-=self.aggressivity
class Garen(Hero):
pass
class Riven(Hero):
pass
g1=Garen(\'草丛伦\',100,300)
r1=Riven(\'锐雯雯\',57,200)
print(g1.life_value)
r1.attack(g1)
print(g1.life_value)
\'\'\'
运行结果
243
\'\'\'
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.。
注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。
4、派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。这就是类的派生。
class Riven(Hero):
camp=\'Noxus\'
def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
print(\'from riven\')
def fly(self): #在自己这里定义新的
print(\'%s is flying\' %self.nickname)
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值。
class Riven(Hero):
camp=\'Noxus\'
def __init__(self,nickname,aggressivity,life_value,skin):
Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
self.skin=skin #新属性
def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
Hero.attack(self,enemy) #调用功能
print(\'from riven\')
def fly(self): #在自己这里定义新的
print(\'%s is flying\' %self.nickname)
r1=Riven(\'锐雯雯\',57,200,\'比基尼\')
r1.fly()
print(r1.skin)
\'\'\'
运行结果
锐雯雯 is flying
比基尼
\'\'\'
class People: #定义父类
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def walk(self):
print(\'%s is walking\' %self.name)
def foo(self):
print(\'from father %s\' %self.name)
class Teacher(People): #继承父类
def __init__(self,name,age,sex,level,salary): #新建__init__方法
People.__init__(self,name,age,sex) #还使用父类的方法
self.level = level #新增的内容
self.salary = salary
def tech(self): #子类特有的函数属性
print(\'%s is teaching \' %self.name)
def foo(self):
People.foo(self)
print(\'from Teacher\') #对父类的函数属性引用和新增
class Student(People):
def __init__(self,name,age,sex,group):
People.__init__(self,name,age,sex)
self.group = group
def study(self):
print(\'%s is studying\'%self.name)
t=Teacher(\'egon\',18,\'male\',10,3000)
print(t.salary)
t.tech()
t.foo()
\'\'\'
3000
egon is teaching
from father egon
from Teacher
\'\'\'
5、组合与与重用性
软件重用的重要方式除了继承之外还有一种方式，即：组合。
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。
class Date: #定义一个关于日期的类
def __init__(self,year,mon,day):
self.year = year
self.mon = mon
self.day = day
def tell_birth(self):
print(\'出生于%s年 %s月 %s日\'%(self.year,self.mon,self.day))
class Teacher: #定义一个老师的类
def __init__(self,name,age,year,mon,day):
self.name = name
self.age = age
self.birth = Date(year,mon,day) #使用Date的类
def teach(self):
print(\'%s is teaching\'%self.name)
t=Teacher(\'egon\',18,1990,12,11)
t.birth.tell_birth()
\'\'\'
出生于1990年 12月 11日
\'\'\'
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同。
5.1 继承的方式
通过继承建立了派生类与基类之间的关系，它是一种\'是\'的关系，比如白马是马，人是动物。
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师。
>>> class Teacher: ... def __init__(self,name,gender): ... self.name=name ... self.gender=gender ... def teach(self): ... print(\'teaching\') ... >>> >>> class Professor(Teacher): ... pass ... >>> p1=Professor(\'egon\',\'male\') >>> p1.teach() teaching
5.2 组合的方式
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程。
class BirthDate:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
class Couse:
def __init__(self,name,price,period):
self.name=name
self.price=price
self.period=period
class Teacher:
def __init__(self,name,gender):
self.name=name
self.gender=gender
def teach(self):
print(\'teaching\')
class Professor(Teacher):
def __init__(self,name,gender,birth,course):
Teacher.__init__(self,name,gender)
self.birth=birth
self.course=course
p1=Professor(\'egon\',\'male\',
BirthDate(\'1995\',\'1\',\'27\'),
Couse(\'python\',\'28000\',\'4 months\'))
print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
\'\'\'
运行结果:
1 27
python 28000 4 months
\'\'\'
二、接口与归一化设计
1、什么是接口
继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）。
二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。
class File: #定义接口File类来模仿接口的概念。
def read(self): #定接口函数read
pass
def write(self): #定义接口函数write
pass
class Txt(File): #文本，具体实现read和write
def read(self):
print(\'文本数据的读取方法\')
def write(self):
print(\'文本数据的读取方法\')
class Sata(file): #磁盘，具体实现read和write
def read(self):
print(\'硬盘数据的读取方法\')
def write(self):
print(\'硬盘数据的读取方法\')
class Process(File):
def read(self):
print(\'进程数据的读取方法\')
def write(self):
print(\'进程数据的读取方法\')
#父类要限制
#1：子类必须要有父类的方法
#2：子类实现的方法必须跟父类的方法的名字一样
import abc
class File(metaclass=abc.ABCMeta):
@abc.abstractmethod
def read(self):
pass
@abc.abstractmethod
def write(self):
pass
class Txt(File): #文本，具体实现read和write
def read(self):
pass
def write(self):
pass
t=Txt()
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
2、为何要有接口
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
以上是关于继承和派生的主要内容，如果未能解决你的问题，请参考以下文章