Python Diary - Day 13 面向对象中

目录

一、面向对象中

1. 封装

2. property装饰器

3. 继承简介

4. 方法重写

5. super()

6. 多重继承

---

一、面向对象中

1. 封装

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

class Car():

    def __init__(self, name, color):
        # 属性名称   值
        # 这种方式告诉别人这个是私有属性，不要轻易修改
        # __name 叫做完全封装  私有属性
        self.__name = name
        self.__color = color

    # getter方法 setter方法
    # getter方法用查看私有属性  如果只有一个getter方法，没有setter方法：这个属性是一个只读属性
    def get_name(self):
        return self.__name

    # setter方法是用来修改私有属性
    def set_name(self, name):
        self.__name = name


car = Car('奔驰', '黑色')
# car.__name = '雪佛兰'  这种方式是外行 没有工作经验的程序员
print(car.get_name())
car.set_name('宝马')
print(car.get_name())

# print(car.__name)  会报错，因为类外部不能访问私有属性
# _类名__属性名 这种方式可以访问私有属性，但是不建议使用
print(car._Car__name)  

# 运行结果：
奔驰
宝马
宝马

2. property装饰器

• 我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改

class Person():
    def __init__(self, name):
        self._name = name

    # getter 方法
    # property装饰器
    @property
    def name(self):
        print('get 方法执行了')
        return self._name

    # setter方法的property装饰器的使用
    @name.setter
    def name(self, name):
        print('set 方法执行了')
        self._name = name


p1 = Person('邱淑贞')

print(p1.name)
p1.name = '刘亦菲'
print(p1.name)

# 运行结果：
get 方法执行了
邱淑贞
set 方法执行了
get 方法执行了
刘亦菲

3. 继承简介

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

class Animal():

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

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


# 定义一个狗类
# 1. 直接在动物类上面修改   违反ocp
# 2. 创建一个新的类(狗类)   会出现大量重复的代码
# 3. 直接从动物类中间拿到属性和方法 （推荐）=>  继承:就是在定义类名之后的括号里写上继承的父类（超类）


class Dog(Animal):
    pass


dog = Dog()

dog.run()
dog.sleep()


# 检测是否是类创建的实例对象
print('\n检测是否是类创建的实例对象')
res = isinstance(dog, Dog)
print(res)


# 检测是否是当前类的父类  issubclass
print('检测是否是当前类的父类')
res = issubclass(Dog, Animal)
print(res)

# object 是所有类的父类
print('object 是所有类的父类')
res = issubclass(Animal, object)
print(res)

# 运行结果：
动物会跑
动物会睡觉

检测是否是类创建的实例对象
True
检测是否是当前类的父类
True
object 是所有类的父类
True

Process finished with exit code 0

4. 方法重写

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

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


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


class C(B):
    def test(self):
        print('C......')


c = C()
c.test()

# 方法的重写： 子类重写父类的方法，会将父类中的方法所覆盖掉   
# 子类实现父类不能实现的方法，才会重写方法

# 运行结果：
C......

5. super()

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

class Animal(object):

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

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

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

    def get_name(self):
        print('get 方法调用了')
        return self._name


class Dog(Animal):
    def __init__(self, age):
        self.age = age


class Zhonghua(Dog):

    def __init__(self, name, age, gender):
        super().__init__(name)
        super().__init__(age)
        self._name = name
        self.age = age
        self.gender = gender

    def sleep(self):
        super().sleep()
        print('狗会睡觉')

    def run(self):
        print('狗会跑')


dog = Zhonghua('中华田园犬', 18, '男')
dog.sleep()
print(dog.get_name())

# 运行结果：
动物会睡觉
狗会睡觉
get 方法调用了
中华田园犬

6. 多重继承

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

• # 解耦合  1. 提高问题的解决概率   2. 提高问题的解决效率  3. 提高解决问题的速度  4. 降低爆发隐患的可能性
  
  # 多重继承： 兄弟类中都有相同的方法，那么先调用写到前面的那个类的方法