2021/3/29第十三次python课(面向对象中、下)

一、封装

• 出现封装的原因：我们需要一种方式来增强数据的安全性
• 1. 属性不能随意修改
• 2. 属性不能改为任意的值
• 封装是面向对象的三大特性之一（其他还有继承、多态）
• 封装是指隐藏对象中一些不希望被外部所访问到的属性或方法
• 我们也可以提供给一个getter()和setter()方法是外部可以访问到属性
• getter() 获取对象中指定的属性
• setter() 用来设置对象指定的属性
• 使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
• 1. 隐藏属性名，使调用者无法随意的修改对象中的属性
• 2. 增加了getter()和setter()方法，很好控制属性是否是只读的
• 3. 使用setter()设置属性，可以在做一个数据的验证
• 4. 使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
• 可以为对象的属性使用双下划线开头 __xxx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
• 其实隐藏属性只不过是Python自动为属性改了一个名字 --> _类名__属性名 例如 __name -> _Person__name
• 这种方式实际上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将一些私有属性以_开头
• 一般情况下,使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性
总结：_name：私有属性 (可以商量后更改）可修改可访问
__name:隐藏属性（不可读不可改属性,决不能更改）可修改不可访问 用car._Car__name来访问
记住：这是给程序员看的

class Car():

    def __init__(self, name, color):
        self._name = name  # 隐藏属性 不可读的属性
        self.color = color

    # getter方法  提供给你访问这个属性的方法
    def get_name(self):
        return self._name

    # setter方法  提供给你修改这个属性的方法
    def set_name(self, name):
        self._name = name

    def run(self):
        print('汽车开始跑起来了')

    def dididi(self):
        print('汽车鸣笛了')


car = Car('法拉利', '红色')
# car.__name = '中华田园犬'
car.run()
car.dididi()
# print(car._Car__name)
# print(car.get_name())
car.set_name('玛莎拉蒂')
print(car.get_name())

#结果
汽车开始跑起来了
汽车鸣笛了
玛莎拉蒂

二、property装饰器

Python 中 property() 函数及 @property 装饰器的使用,转自团子大园帅的博客

class Car():

    def __init__(self, name, color):
        self._name = name  # 隐藏属性 不可读的属性
        self.color = color

    # getter方法  提供给你访问隐藏属性的方法
    @property
    def name(self):
        return self._name

    # setter方法  提供给你修改隐藏属性的方法
    @name.setter
    def name(self, name):
        self._name = name

    def run(self):
        print('汽车开始跑起来了')

    def dididi(self):
        print('汽车鸣笛了')


car = Car('法拉利', '红色')
# print(car.name)  # 访问属性
# print(car.get_name)
car.run()  # 调用方法
print(car.name)
car.name = '玛莎拉蒂'
print(car.name)

#结果：
汽车开始跑起来了
汽车鸣笛了
玛莎拉蒂

三、继承

问题：函数不可减少相似代码的数量 为了减少相似代码的数量，就可用类

• 继承是面向对象三大特性之一
• 通过继承我们可以使一个类获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
  继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性
  检测一个类是否是一个类的子类print(issubclass (Dog，Animal))
  object：所有类的最原始的类

四、方法的重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
• 当我们调用一个对象的方法时：
 • 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
 • 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
 • 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了
注：方法的重写必须建立在继承的基础之上

五、super()方法

super方法的使用建立在两个基础之上
1.必须要有继承
2.必须要有方法的重写

• super()可以获取当前类的父类
• 并且通过super()返回对象调用父类方法时，不需要传递self

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
  

结果：

Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.

*注：Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx *

六、多重继承

在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
可以在类名的()后边添加多个类，来实现多重继承
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

解耦合的原则…就是不希望太多的代码成为彼此相牵连的代码

解耦合的作用:.方便维护.提高问题的解决效率.隆低了问题的解决难度