2019/08/28 学习整理

python面向对象

类的组合

一、什么是组合

组合就是一个类的对象具备某一个属性，该属性的值是指向另外一个类的对象

二、为什么要用组合

组合是用来解决类与类之间代码冗余的问题

三、如何使用组合

需求：假如我们需要给学生增添课程属性，但是又不是所有的学生一进学校就有课程属性，课程属性是学生来后选出来的，也就是说课程需要后期学生们添加进去的
实现思路：如果我们直接在学生中添加课程属性，那么学生刚被定义就需要添加课程属性，这就不符合我们的要求，因此我们可以使用组合能让学生未来添加课程属性

类的多态和多态性

一、多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

序列数据类型有多种形态：字符串，列表，元组
动物有多种形态：人，狗，猪

二、多态性

注意：多态与多态性是两种概念

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

动物形态的多态性的使用

# 多态性：一种调用方式，不同的执行效果（多态性）
def func(obj):
    obj.run()


func(peo1)
func(pig1)
func(d1

人正在走
pig is walking
dog is running

# 多态性依赖于：继承
# 多态性：定义统一的接口
def func(obj):  # obj这个参数没有类型限制，可以传入不同类型的值
    obj.talk()  # 调用的逻辑都一样，执行的结果却不一样


func(peo2)
func(pig2)
func(d2)

say hello
say aoao
say wangwang

三、多态性的好处

增加了程序的灵活性：以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
增加了程序额可扩展性：通过继承Animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用

类的封装

一、封装什么

数据（属性）
方法（函数）

二、为什么要封装

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

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

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

三、两个层面的封装

封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）

3.1 第一个层面

注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口

3.2 第二个层面

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

类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N = 0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):
        self.__X = 10  # 变形为self._A__X

    def __foo(self):  # 变形为_A__foo
        print('from A')

    def bar(self):
        self.__foo()  # 只有在类内部才可以通过__foo的形式访问到.

这种自动变形的特点：

类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
这种变形其实正是针对内部的变形，在外部是无法通过__x这个名字访问到的。
在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

这种变形需要注意的问题是：

这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

# 对象测试
a = A()
print(a._A__N)
0
# 对象测试
print(a._A__X)
10
# 类测试
print(A._A__N)
0
# 类测试
try:
    print(A._A__X)  # 对象私有的属性
except Exception as e:
    print(e)
type object 'A' has no attribute '_A__X'

变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形

a = A()
print(a.__dict__)
{'_A__X': 10}
a.__Y = 1
print(a.__dict__)
{'_A__X': 10, '__Y': 1}

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

# 正常情况
class A:
    def fa(self):
        print('from A')

    def test(self):
        self.fa()


class B(A):
    def fa(self):
        print('from B')


b = B()
b.test()
from B
# 把fa定义成私有的，即__fa
class A:
    def __fa(self):  # 在定义时就变形为_A__fa
        print('from A')

    def test(self):
        self.__fa()  # 只会与自己所在的类为准,即调用_A__fa


class B(A):
    def __fa(self):
        print('from B')


b = B()
b.test()
from A

day25学习整理-Python面向对象