2021-03-31

1. 封装

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

封装的引入

# 封装的概念：就是为了数据的安全，形成了一个的默认的规则，告诉你的协同开发者，这个属性很重要不要随意修改


class Car():

    def __init__(self, name, color):
        self.name = name
        self.color = color

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

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


car = Car('法拉利', '红色')
car.name = '中华田园犬'
# print(car.name)
car.run()
car.dididi()
相应运行结果：
汽车开始跑起来了
汽车鸣笛了

私有属性

# 封装：私有属性


class Car():

    def __init__(self, name, color):
        self._name = name  # 私有属性
        self.color = color

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

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


car = Car('法拉利', '红色')
car._name = '中华田园犬'
car.run()
car.dididi()
print(car._name)
相应运行结果 ：
汽车开始跑起来了
汽车鸣笛了
中华田园犬

隐藏属性

class Car():

    def __init__(self, name, color):
        self.__name = name  # 隐藏属性,是一个不可读属性
        self.color = color

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

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


car = Car('法拉利', '红色')
# car.__name = '中华田园犬'
car.run()
car.dididi()
# print(car.__name)
print(car._Car__name)
相应运行结果：
汽车开始跑起来了
汽车鸣笛了
法拉利

封装之getter()与setter()方法使用

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.get_name())
car.set_name('玛莎拉蒂')
print(car.get_name())

相应运结果：
汽车开始跑起来了
汽车鸣笛了
法拉利
玛莎拉蒂

2. property装饰器

我们可以使用@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)  # 访问属性
car.run()  # 调用方法
print(car.name)
car.name = '玛莎拉蒂'
print(car.name)
相应运行结果：
汽车开始跑起来了
汽车鸣笛了
法拉利
玛莎拉蒂

3. 继承简介

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

继承引入

class Animal(object):   # 括号中没写，默认继承object

    def sleep(self):
        print('动物会睡觉')

    def run(self):
        print('动物会跑')


class Dog(Animal):
    def sleep(self):
        print('狗会睡觉')


dog = Dog()
dog.sleep()
dog.run()

# 检测实例是否是一个类的实例
print(isinstance(dog, Dog))
print(isinstance(dog, Animal))

# 检测一个类是否是一个类的父类
print(issubclass(Dog, Animal))
print(issubclass(Animal, object))
相应运行结果：
狗会睡觉
动物会跑
True
True
True
True

4. 方法重写

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

# 方法的重启写必须建立在继承的基础之上


class A(object):
    def test(self):
        print('A....')


class B(A):
    pass


class C(A):
    pass


c = C()
c.test()
运行结果：
A....

5.super()方法使用

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

# super 这个方法的使用时建立在两个基础之上的
# 1，必须有父类的继承
# 2. 必须有方法的重写


class A(object):
    def sleep(self):
        print(111111)


class Animal(A):   # 括号中没写，默认继承object

    def sleep(self):
        print('动物会睡觉')

    def run(self):
        print('动物会跑')


class Dog(Animal):
    def sleep(self):
        print('狗会睡觉')
        # super的作用： 将被覆盖了当前继承的父类(或一级父类)方法，重新调用
        super().sleep()


dog = Dog()
dog.sleep()
运行结果：
狗会睡觉
动物会睡觉

……

6 . 多重继承

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

class Person1(object):

    def chuiniu(self):
        print('很会吹牛')

    def cool(self):
        print('貌似潘安')


class Person2(object):

    def paimapi(self):
        print('很会拍马屁')

    def cool(self):
         print('赛过刘德华')


class Son(Person1, Person2): # 多重继承 出现同名的方法调用 从前往后找（即从继承的类的第一个类往后找）
    pass


son = Son()
son.chuiniu()
son.paimapi()
son.cool()


# 解耦合的原则：就是尽量不希望太多的代码成为彼此牵连的代码
# 解耦合的作用：方便维护，提高问题的解决效率，降低了问题解决难度
相应运行结果：
很会吹牛
很会拍马屁
貌似潘安