Python-面向对象的特性(封装,继承和多态)

一.封装

• 面向对象第一步 ： 将属性和方法封装到一个抽象的类中
• 外界使用类创建对象，然后让对象调用方法
• 对象方法的细节都封装在类的内部

练习1：

• 需求1：
  1.小明体重75.0公斤
  2.小明每次跑步会减肥0.5公斤
  3.小明每次吃东西会增重1攻击
  需求2：
  1.小明和小美都爱跑步
  2.小美体重45.0公斤
  3.小明体重75.0公斤
  4.每次跑步会减肥0.5公斤
  5.每次吃东西会增重1攻击
• 程序内容：

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

    def __str__(self):
        return '我的名字叫%s 体重是%.2f' %(self.name,self.weight)

    def run(self):
        print('%s爱跑步' %self.name)
        self.weight -= 0.5

    def eat(self):
        print('%s吃东西' %self.name)
        self.weight += 1

xiaoming = Person('小明',76.0)
print(xiaoming)
xiaoming.run()
print(xiaoming)
xiaoming.eat()
print(xiaoming)

• 测试：
  
  

练习2：

• 需求：
  1.房子有户型，总面积和家具名称列表
  新房子没有任何的家具
  2.家具有名字和占地面积，其中
  床：占4平米
  衣柜：占2平面
  餐桌：占1.5平米
  3.将以上三件家具添加到房子中
  4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
• 程序内容：

class HouseItem():
    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s]占地 %.2f' %(self.name,self.area)

#1.创建家具
# bed = HouseItem('bed',4)
# print(bed)
# table = HouseItem('table',2)
# print(table)

class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩余面积
        self.free_area = area
        self.item_list = []

    def __str__(self):
        return ('户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'
                %(self.house_type,self.area,self.free_area,self.item_list))

    def add_item(self,item):
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s的面积太大，无法添加' %item.name)

        #2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        #3.计算剩余面积
        self.free_area -= item.area

#1.创建家具对象
bed = HouseItem('bed',4)
# print(bed)
yg = HouseItem('yg',2)
# print(yg)
table = HouseItem('table',1.5)
# print(table)

#2.创建房子对象
my_house = House('两室一厅',100)
#3.添加家具
my_house.add_item(bed)
my_house.add_item(yg)
my_house.add_item(table)
print(my_house)

• 测试：
  
  
  
  

练习3：

• 需求：
  
• 程序内容：

class Gun():
    def __init__(self,model):
        self.model = model
        self.bullet_count = 0

    def add_bullet(self,count):
        self.bullet_count += count

    def shoot(self):
        if self.bullet_count <=0:
            print('%s没有子弹了...' %self.model)

        self.bullet_count -= 1
        print('%s~~~~~%s' %(self.model,self.bullet_count))

class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None

    def fire(self):
        if self.gun == None:
            print('%s还没有枪...' %self.name)

        self.gun.add_bullet(10)
        self.gun.shoot()

ak47 = Gun('ak47')
ak47.add_bullet(50)
ak47.shoot()

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

• 测试：
  
  
  

二.继承

• 面向对象中的继承就是继承的类直接拥有被继承类的属性而不需要在自己的类体中重新再写一遍，其中被继承的类叫做父类、基类，继承的类叫做派生类、子类。

详解1：

• 子类继承自父类，可以直接享受父类中已经封装好的方法
• 子类重应该根据职责，封装子类特有的属性和方法

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
        
class Cat(Animal):
    def call(self):
        print('喵～')
fentiao = Cat()
fentiao.eat()
fentiao.run()
fentiao.call()        

详解2：

• 子类可以继承父类的所有属性和方法
• 继承具有传递性，子类拥有父类的父类的属性和方法

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')

class Dog(Animal):
    def bark(self):
        print('汪～')

kt = HelloKitty()
kt.eat()
kt.speak()

详解3：

• 如果子类重写了父类的方法,在运行中，只会调用在子类中重写的方法而不会调用父类方法

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        print('@#@$@$@#@!#')

kt = HelloKitty()
kt.call()

详解4：

• 子类想调用原本在父类中封装的方法

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
class Cat(Animal):
    def call(self):
        print('喵～')
class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        #1.针对子类特有的需求，编写代码
        print('@#@$@$@#@!#')
        #2.调用原本在父类中封装的方法
        # Cat.call(self)
        super().call()
kt = HelloKitty()
kt.call()

详解5：

• 子类继承多个父类即多继承

class A():
    def test(self):
        print('A---->test方法')
    def demo(self):
        print('A---->demo方法')

class B():
    def test(self):
        print('B---->test方法')
    def demo(self):
        print('B---->demo方法')

class C(A,B):
    pass

c = C()
c.test()
c.demo()