面向对象:封装，继承

封装

• 出现封装的原因：我们需要一种方式增强数据的安全性
  1、属性不能随意更改
  2、属性不能改为任意值
• 封装是面线对象的三大特征之一
• 封装是指封装一些外部不能访问的属性和方法
• 我们也提供了setter()和gerter()方法可以在外部访问私有属性
  1、getter()访问指定的属性
  2、setter()设置指定的属性
• 使用封装，确实增加了代码的复杂难度，但也保证了数据的安全性
  1、隐藏属性名，访问者不能随意的访问属性
  2、增加了getter()和setter()方法，设置属性是否可读
  3、使用setter()设置属性,可以做一个数据的验证
  4、使用getter()访问属性，setter()设置属性时可以在访问属性的时候和修改属性的时候同时进行一些修改
• 对象属性使用双下划线如:__xxx,双下划线开头的属性是隐藏属性，隐藏属性只能在内部访问，不可以通过对象访问
• 其实隐藏属性不过是python对属性名进行了更改，—> _类名__属性
• 这种方式依然可以从外部访问到，不过这种方式我们一般不使用，我们一般使用以_开头

# 私有属性
class Car():

    def __init__(self, name, colour):
        self._name = name  # 私有属性
        self.__colour = colour  # 隐藏属性 不可读属性

    # 通过getter()访问属性
    def get(self):
        return self._name

    # 通过setter()修改属性
    def set(self, name):
        self._name = name

    def run(self):
        print("汽车会跑")

    def didi(self):
        print("汽车会鸣笛")

car = Car("mercedes", "red")
car._name = "ford"
print(car._name)
print(car._Car__colour)
print(car.get())
car.set("fiat")
print(car.get())

property装饰器

• 我们可以通过@property装饰器来创造只读属性，@property可以把方法转化为相应的只读属性，可以和定义的属性配合使用，这样可以防止属性被修改

# property装饰器
class Car():

    def __init__(self, name, colour):
        self._name = name  # 私有属性
        self.__colour = colour  # 隐藏属性 不可读属性

    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, name):
        self._name = name

    def run(self):
        print("汽车会跑")

    def didi(self):
        print("汽车会鸣笛")

car = Car("mercedes", "red")
car._name = "ford"
car.name
print(car._name)
car.name = "peugeot"
print(car._name)
# 使用了property装饰器这种方法调用setter()和getter()时，和普通调用属性没有什么区别

继承

继承的简介

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

方法的重写

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

super()

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

# 继承

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

# super这个方法的使用建立两个基础之上
# 必须要有父类的继承
# 必须要有父类的重写

class Animal(object):  # 括号没有写默认写object，object是所有类最大的父类

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

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

class Dog(Animal):

    def sleep(self):
        print("狗会睡觉")
        # super将覆盖掉的父类方法重新调用
        super().sleep()

dog = Dog()

# 检测实例对象是否由这一个类创建的
print(isinstance(dog, Dog))

# 检测这个类是否这个类的父类
print(issubclass(Dog, Animal))
dog.sleep()

多继承

• 在python中支持多继承的。也就是说我们可以给一个类指定多个父类
• 可以在类名后面的()添加多个类，来实现多继承
• 多继承会使子类拥有多个父类，子类拥有所有父类的方法
• 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个父类有同名的方法，会优先在第一个类中找，如果没有在去第二个类中找以此类推

# 多继承
class Zhangsan():

    def yangmao(self):
        print("长得丑")

    def run(self):
        print("跑得快")

class Lisi():

    def yangmao(self):
        print("长得帅")

    def swim(self):
        print("游泳快")

class Wanwu(Zhangsan, Lisi):
    pass

wanwu = Wanwu()
wanwu.run()
wanwu.swim()
wanwu.yangmao()

# 解耦合原则：就是希望不要太多代码称为 彼此 关联的 代码
# 解耦合的左右：方便维护，提高问题的解决效率，降低了问题的解决难度