python 封装 多态 继承 重写

面向对象的三大特征

• 封装:提高程序的安全性

• 继承:提高代码的复用性(继承包括重写)

• 多态:提高程序的可扩展性和可维护性

三大特征的实现：

• 封装:将数据(属性)和行为(方法)包装到类对象

• 中继承：单继承、多继承

1. 如果一个类没有继承任何类，则默认继承object
2. 定义子类时，必须在其结构函数中调用父类的构造函数（表示继承父类的构造函数）

• 方法重写：

1. 如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
2. 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

• 多态的三个必要条件：继承、方法重写、父类引用指向子类对象

'''
封装：就是将属性和方法包装在类对象中     
作用：提高程序的安全性
    需求是:创建两个类,一个是士兵类,一个是枪类；
    枪类拥有名字,子弹数量,装弹方法,发射方法；
    士兵拥有名字,当有武器的时候可以开枪
'''
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
        self.gun = None # 如果遇到不知给属性添加什么属性值的时候就可以使用None
    # 开枪的方法
    def fire(self):
        # 这里self.gun是一个对象，可以通过实例化后再赋值
        if self.gun is None:
            print('士兵没有枪,没办法开枪')
            return
        self.gun.add_bullet(50)
        self.gun.shoot()

ak47 = Gun('ak47')  # 创建一把枪
Jack = Soldier('Jack') # 创建一个士兵
Jack.gun = ak47 # 给Jack一把枪
Jack.fire()  # Jack开枪

'''
继承:单继承、多继承
    如果一个类没有继承任何类，则默认继承object
    定义子类时，必须在其结构函数中调用父类的构造函数
'''
class Person(object): #Person继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
#定义子类
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name, age) # 定义子类时，必须在其结构函数中调用父类的构造函数
        self.stu_no=stu_no

stu=Student('张三',20,'1001')
stu.info()

'''
# 多继承
class A(object):
    pass
class B(object):
    pass
class C(A,B):
    pass
#C有两个父类，分别是A和B

'''

'''
方法重写：
如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
'''

class Person(object): #Person继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,"年龄:",self.age , end=' ')

#定义子类
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name, age)
        self.stu_no=stu_no
 
    def info(self):  # 方法重写
        super().info() # 重写方法时一定要在子类重写的方法中调用父类被重写的方法
        print("学号:",self.stu_no)
 
class Teacher(Person):
    def __init__(self,name,age,teachofvear):
        super().__init__(name,age) # 不继承父类的构造方法，相当于重新创建了构造函数
        self.teachofvear=teachofvear
 
    def info(self):
        # 如果不继承父类的构造方法，直接执行super().info()会报错  'Teacher' object has no attribute 'name'
        super().info() # 重写方法时一定要在子类重写的方法中调用父类被重写的方法        
        print('教龄:',self.teachofvear)
 
stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)
 
stu.info()
teacher.info()

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

多态必须要满足两个条件：
    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() # 函数实现的功能是调用对象的introduce方法

fun(Rice('大米', '能喂饱大家的肚子')) # 传参时需传入对象的自己的参数
fun(Snacks('零食', '人们最爱我'))

# 不带参数的多态
class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')
 
class Person:
    def eat(self):
        print('人吃五谷杂粮')
 
#定义一个函数
def fun(obj):
    obj.eat()
 
#开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
 
fun(Person())