【Python】第十一部分封装、继承、重写、多态

文章目录

【Python】第十一部分封装、继承、重写、多态
11. 封装、继承、重写、多态
总结

11. 封装、继承、重写、多态

11.1 封装

封装：就是将属性和方法包装在类对象中

作用：提高程序的安全性

# 小案例
"""
    需求是:创建两个类,一个是士兵类,一个是枪类
    枪类拥有名字,子弹数量,装弹方法,发射方法
    士兵拥有名字,当有武器的时候可以开枪
"""


class Gun:
    def __init__(self, name):
        # 枪的名字
        self.name = name
        # 子弹默认一开始是空的
        self.bullet = 0

    # 装弹的方法
    def add_bullet(self, bullet):
        self.bullet = bullet

    # 发射的方法
    def shoot(self):
        # 判断有没有子弹
        if self.bullet <= 0:
            print('没有子弹,请装弹!')
            return

        self.bullet -= 1
        print(f'发射成功!子弹还剩{self.bullet}')


class Soldier:
    def __init__(self, name):
        self.name = name
        # 如果遇到不知给属性添加什么属性值的时候就可以使用None
        self.gun = None

    # 开枪的方法
    def fire(self):
        if self.gun is None:
            print('士兵没有枪,没办法开枪')
            return

        self.gun.add_bullet(50)
        self.gun.shoot()


# 创建一把枪
ak47 = Gun('ak47')

# 创建一个士兵
Jack = Soldier('Jack')

# 给Jack一把枪
Jack.gun = ak47

# Jack开枪
Jack.fire()

11.2 私有属性和方法

简单来说：对象内部的属性和方法只希望在内部被使用,不希望外部能访问得到

使用:我们在定义属性和方法的时候只需要在属性和方法的前面加 __

class Women:
    def __init__(self, name):
        self.name = name
        # 将年龄设为私有属性,外部不能访问,访问的话会报错
        self.__age = 56

    def secret(self):
        # 内部的方法是可以访问得到私有属性的
        print(f'{self.name}的年龄是{self.__age}')

    def __hello(self):
        print('该方法外部访问不到')


w = Women('丽丽')
# 报错为：AttributeError: 'Women' object has no attribute '__age'
# print(w.__age)

w.secret()  # 丽丽的年龄是56

"""
	在python中没有真正意义上的私有,实际上python只是在名称上面做了一些手脚只需要在访问私有属性前加_类名即可以访问
"""
print(w._Women__age)  # 56
w._Women__hello()  # 该方法外部访问不到

11.3 继承

继承：子类继承父类，拥有父类的方法和属性,默认继承Object

作用：提高代码的复用性

# 语法：
"""
    class child(father):
        pass
"""


# 继承的传递性:C类继承B类，B类继承A类，那么C类具有B和A类的所有属性和方法

# 单继承
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print(f'Hello everyone ,I am {self.name}')


class Student(Person):
    def __init__(self, name, age, sno):
        # 使用super()去调用父类的init方法,获取父类的属性
        super().__init__(name, age)
        self.sno = sno


s = Student('Jack', 18, 123)
s.speak()  # Hello everyone ,I am Jack


# 多继承
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('eat')

    def sleep(self):
        print('sleep')


class bird:
    def fly(self):
        print('fly')


class parrot(Animal, bird):
    def __init__(self, name):
        super().__init__(name)

    def speak(self):
        print(f'我是{self.name}，我会说话')


p = parrot('鹦鹉')
p.speak()
p.eat()
p.sleep()
p.fly()

"""
多继承的注意事项：
	如果不同父类中存在同名的方法和属性，那么在子类对象调用方法的时候容易产生混淆，所以这个时候就应该要避免使用多继承
"""

11.4 重写

# 当父类的方法不能够满足子类的需求时，子类可以方法进行重写
class Product:
    def __init__(self, name, lifetime):
        self.name = name
        self.lifetime = lifetime

    def introduce(self):
        print('我是电子产品中的一员')


class Phone(Product):
    def __init__(self, name, lifetime, feature):
        super().__init__(name, lifetime)
        self.feature = feature

    # 方法的重写，取得函数名和父类的一样
    def introduce(self):
        # 如果还想继承父类方法中的功能可以使用super关键字
        super().introduce()
        print(f'我是手机,我的特点是{self.feature}')


phone = Phone('小米手机', '两年', '方便')
phone.introduce()

11.5 多态

定义：Python中本质上是没有真正多态这种思路，只是形式上有这样一个多态的思路。

多态，可以理解为多种状态/多种形态，同一事物，由于条件不同，产生的结果不同。简单来说(个人理解)：不同的对象调用同一个接口(父类)，表现出不同的状态，称为多态。

""" 
    多态必须要满足两个条件：
    1.继承：多态必须发生在父类与子类之间
    2.重写：子类重写父类方法
"""


class Food:
    def __init__(self, name):
        self.name = name

    def introduce(self):
        print('我是美味的食物')


class Rice(Food):
    def __init__(self, name, info):
        super().__init__(name)
        self.info = info

    def introduce(self):
        print(f'我是{self.name}{self.info}')


class Snacks(Food):
    def __init__(self, name, info):
        super().__init__(name)
        self.info = info

    def introduce(self):
        print(f'我是{self.name}{self.info}')


def fun(obj):
    obj.introduce()


fun(Rice('大米', '能喂饱大家的肚子'))
fun(Snacks('零食', '人们最爱我'))