本节内容

1. 类的公有属性
2. 析构函数
3. 类的继承
4. 新式类和经典类

一、类的公有属性

一、概述

　　前面我们讲了类的私有属性，现在我们来说说类的公有属性，这边很容易被人弄混淆，有人觉的，在__init__()构造方法中，除了私有属性，其他的都是公有属性了，其实这是一个错误的结论，并不是定义在__init__()初始化方法中的属性是公有属性(除私有属性)，那什么是公有属性呢？揭起了大家的好奇心。

　　定义：指的是所属这个类的所有对象，都可以访问的属性，叫做公有属性。

二、公有属性

2.1 定义

说明：在类中直接定义的，可以提供这个类所属的所有对象都可以访问的属性

这边有个小疑问，d1.name,d2.name也可以访问，也可以修改， 为什么不能叫公有属性呢？代码如下

很明显，上面的name是每个对象的属性，并不是共享，而是独立的 。

2.2 类访问公有属性

说明：公有属性不仅可以通过所属类的所有对象访问，还可以通过类本身直接访问和修改

2.3 公有属性特性

说明：公有属性不是私有属性，它提供所有对象访问和修改，那我们其中有一个对象正在修改公共属性发生什么变化呢？或者类本身直接修改了公共属性，又放生什么变化呢？

 我去，看的我头昏眼花的。。。好吧，下面我就一张图来说明一下：

对上面的图做一下总结：

1. 对象d1去访问nationality属性时，如果在成员属性中找不到，就会找公共属性，也就是说自己的属性找不到就去找父亲的属性
2. d1.nationality="CN" 相当于在自己对象内部又重新创建了一个新的局部变量，这个局部变量已经脱离了class本身，跟这个类已经没有半毛钱关系了，只是名字一样而已，如果不改，还是找全局的。

2.4 公有属性和方法的疑惑

　　从上面我们可以看出公有属性只有一个，而且是在没有定义对象的时候，就已经存在，那么类中的方法是不是每调用一次，就会生成一个呐？答案是肯定不会的。

　　就是说，你去实例化然后调用sayhi方法，只是拿着这块内存中的数据去调公有的sayhi方法而已，并不是有多个。

二、析构函数

一、概述

 　析构函数，第一次听说这个函数的名称，那这个函数到底是干嘛的呢？什么才是析构函数呐？

　 定义：在实例销毁的时候调用的函数

二、析构函数定义

2.1 定义

2.2 析构函数说明时候调用呢？

其实每一个对象都是一个应用，就像每一个房间都有门牌号一样， 只要这个对象的引用被清空时，就会自动执行，就像上面的del d,其实python中有自动垃圾回收机制，会定时去的去回收一些被清空的应用，而析构函数就是在引用被清空之后会自动执行

2.3 析构函数的作用？

比如说server端接受很多客户端的连接，当你手动屏蔽你的sever端的时候，这个时候客户端还在正常的连接，如果sever端用类写的，你就可以delete server端的同时，在__del__()写一些东西，说去close掉很多客户端的连接。说白了，析构函数就是做一些程序的收尾工作。

三、类的继承

一、概述

　　之前我们说到了类的公有属性和类的私有属性，其实就是类的封装，下面我们来讲讲继承，是面向对象的第二大特性。

　　面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

　　通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

　　继承概念的实现方式主要有2类：实现继承、接口继承。

1. 实现继承是指使用基类的属性和方法而无需额外编码的能力。
2. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。

　　在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

　　抽象类仅定义将由子类创建的一般属性和方法，OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段

二、类的继承

2.1 继承的定义

说明：在类名的括号中写入需要继承的类名即可

2.2、构造方法的继承

说明：因为子类有自己的属性，但是又想继承父类的属性，所以需要先继承，再重构

继承类的构造方法2种写法：

1. 经典类写法：父类.__init(self,name,age)
2. 新式类写法：super(子类,self).__init__(name,age)

注：建议使用新式类的写法，因为使用经典类的写法，在多继承的情况下，会出现重复调用参数的可能

代码如下：

这边不禁的有一个疑问？我不能重新写一遍，我为啥要继承父类中的方法呢？因为你重新写一遍的话，只能继承self.name和self.age，那self.sex怎么办，它也需要重写吗？所以啊，只有把父类中的构造函数全部继承过来，只能用上面这种办法？那它是怎么实现的呢？我们来画一个图：

2.3、子类对父类方法的重写

说明：如果我对父类中的方法不满意，我可以重写父类中的方法，当然还可以继承父类中的方法，但是我们一般不这样干。

其实重写不是上面说的那么简单，只需要子类的方法名和父类的中的方法名一样就算重写了，其实不然，那怎么样才算重写呢？

重写的条件：

1. 重写方法的方法名必须和父类中被重写的方法名一模一样
2. 重写方法的传入的参数名和参数的个数必须和父类中被重写的方法一样

我们再来看看下面的例子：

 有些同学说，这明明是重写了呀！其实不是重写，根据重写的条件明显两个方法的传入参数名和参数的个数都不一样，其实上面这种只是子类自己写了一个talk方法，只是名字一样，但是传入的参数和参数的个数不一样，并不是重写了父类中的方法。下面这个才是真正的重写：

三、练习

3.1 类的继承练习

四、新式类和经典类

一、概述

 　在python还支持多继承，但是一般我们很少用，有些语言干脆就不支持多继承，有多继承，就会带来两个概念，经典类和新式类，下面我就来学学什么是多继承，什么是经典类和新式类？

二、类的多继承

2.1 多继承

说明：之前我们都是讲的单继承，那么什么是多继承呢？说白了，就是：子类可以继承多个父类，就叫多继承

三、经典类VS新式类

3.1、新式类

1、概念

新式类定义时必须继承object类，被定义继承了object类的，就叫做新式类

2、继承构造方法

新式类初始化构造方法用super关键字去继承

3、调用父类中相同方法或者相同属性的顺序

新式类多继承的调用方法是顺序是：广度优先查询，如下图：

代码实验如下：

①全部代码

 class A(object):  #新式类
     def __init__(self):
         self.n = "A"
 
 class B(A):
     def __init__(self):
         self.n = "B"
 
 class C(A):
     def __init__(self):
         self.n = "C"
 
 class D(B,C):
     def __init__(self):
         self.n = "D"
 
 d = D()
 print(d.n)
 
 #输出
 D

没有问题，先找自己的属性，输出D

②注释D类中代码

 class A(object):
     def __init__(self):
         self.n = "A"
 
 class B(A):
     def __init__(self):
         self.n = "B"
 
 class C(A):
     def __init__(self):
         self.n = "C"
 
 class D(B,C):
     pass
 
 d = D()
 print(d.n)
 
 #输出
 B

③注释B类中的代码

 class A(object):
     def __init__(self):
         self.n = "A"
 
 class B(A):
     pass
 
 class C(A):
     def __init__(self):
         self.n = "C"
 
 class D(B,C):
     pass
 
 d = D()
 print(d.n)
 
 #输出
 C

④注释C类中的代码

 class A(object):
     def __init__(self):
         self.n = "A"
 
 class B(A):
     pass
 
 class C(A):
     pass
 
 class D(B,C):
     pass
 
 d = D()
 print(d.n)
 
 #输出
 A 

3.2 经典类

1、概念

经典类定义，什么都不继承

2、继承构造方法

3、调用父类中相同方法或者相同属性的顺序

经典类多继承的调用方法是顺序是：深度优先查询，如下图：

 代码实验如下：

①全部代码

class A:#经典类
    def __init__(self):
        self.n = "A"

class B(A):
    pass
    def __init__(self):
        self.n = "B"

class C(A):
    def __init__(self):
        self.n = "C"

class D(B,C):
    def __init__(self):
        self.n = "D"

d = D()
print(d.n)

#输出
D

②注释D类中代码

class A:
    def __init__(self):
        self.n = "A"

class B(A):
    def __init__(self):
        self.n = "B"

class C(A):
    def __init__(self):
        self.n = "C"

class D(B,C):
    pass

d = D()
print(d.n)

#输出
B

③注释B类中的代码

class A:
    def __init__(self):
        self.n = "A"

class B(A):
    pass

class C(A):
    def __init__(self):
        self.n = "C"

class D(B,C):
    pass

d = D()
print(d.n)

#输出
A

④注释A类中的代码

class A:
    pass

class B(A):
    pass

class C(A):
    def __init__(self):
        self.n = "C"

class D(B,C):
    pass

d = D()
print(d.n)

#输出
C

三、总结

1. 新式类继承object类，经典类不继承任何类
2. 新式类用super关键字继承构造方法，经典类用 父类.__init(self)来继承
3. 新式类：广度优先查询，经典类：深度优先查询(因为新式类讲究的是新，所以要找最近的，最新的；然后经典的讲究古老，所以更远更深的)
4. 值得注意的是，我们上面是在python2中做的，在python3中不管是经典类还是新式类，都是采用的是广度优先查询，已经废弃2中的深度查询了

面向对象【day07】：类的属性-继承-经典类