Python入门之面向对象的三大特点--封装继承多态详细讲解

野性酷女 2021-12-09 04:23 380阅读 0赞

**1、封装**

封装是面向对象编程的一大特点,将属性和方法封装到一个抽象的类中

封装：把同一类型的东西放在一起，用self.\*\*\*去调用  
数据被保存在内部，程序的其他部分只有通过被授权的操作（成员方法）才能对数据进行操作。外界使用类创建对象，然后让对象调用方法  
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。对象方法的细节都被封装在类的内部

构造方法在示例化对象时自动执行

练习1需求：

1.小明体重75.0公斤  
2.小明每次跑步都会减肥0.5公斤  
3.小明每次吃东西体重都会增加1公斤

需求  
1.小明和小美都爱跑步  
2.小美体重45.0公斤  
2.每次跑步都会减肥0.5公斤  
3.每次吃东西体重都会增加1公斤

class People():
        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
    
    xiaomei = People('小美',45)
    xiaoming = People('小明',75)
    
    xiaomei.eat()
    print(xiaomei)
    xiaoming.run()
    print(xiaoming)

![20190716112720291.png][]

练习2需求：

1.房子有户型,总面积和家具名称列表  
新房子是没有家具的  
2.家具有名字和占地面积，其中  
床：5  
桌子：4  
椅子：6  
3.将以上三件家具添加到房子中  
4.打印房子的时候，要求输出：户型 总面积 剩余面积 家具名称列表

class Room():
        def __init__(self,house_type,area):
            self.house_type = house_type
            self.area = self.leftarea = area
            self.jiaju = []
        def __str__(self):
            return '户型：%s\n总面积：%s   [剩余面积：%s]\n家具列表名称：%s' %(self.house_type,self.area,self.leftarea,self.jiaju)
    
        def add_furn(self,item):
            if item.area < self.leftarea:
                self.jiaju.append(item.name)
                self.leftarea -= item.area
            else :
                return
    
    class jiaju:
        def __init__(self,name,area):
            self.name = name
            self.area = area
    
        def __str__(self):
            return 'this is %s,and %d square' %(self.name,self.area)
    
    bed = jiaju('bed',5)
    desk = jiaju('desk',4)
    chair = jiaju('chair',6)
    
    room1= Room('三室',120)
    room1.add_furn(bed)
    room1.add_furn(desk)
    room1.add_furn(chair)
    print(room1)

![20190716144004638.png][]

练习3需求：

1.士兵瑞恩有一把AK47  
2.士兵可以开火(士兵开火扣动的是扳机)  
3.枪 能够 发射子弹(把子弹发射出去)  
4.枪 能够 装填子弹 --增加子弹的数量

#枪类
    class Gun():
        def __init__(self,name,count):
            self.name = name
            self.bullet_count = count
            print('%s共有%d枚子弹' %(self.name,self.bullet_count))
    
        def __str__(self,name,count):
            return ('%s还有%d颗子弹' %(self.name,self.bullet_count))
    
         #装子弹方法
        def add_bullet(self,count):
            self.bullet_count+=count
            print('%s成功装了%d枚子弹，目前一共%d枚子弹' %(self.name,count,self.bullet_count))
        
        #射击方法
        def shoot(self):
            if self.bullet_count >=1:
                self.bullet_count-=1
                print("发射子弹，还有%s枚子弹" %(self.bullet_count))
            else:
                print('子弹数量不足')
    
    #士兵类
    class Soldier():
        def __init__(self,name,gun):
            self.name = name
            self.gun = gun
    
        def __str__(self,name,count):
            return ('士兵%s有一把%s' %(self.name,self.gun))
    
        #开火方法
        def fire(self,gun):
            if gun.bullet_count >0:
                gun.bullet_count-=1
                print('士兵%s用%s开枪,还有%d枚子弹' %(self.name,self.gun,gun.bullet_count))
            else:
                print('子弹不足，请装子弹')
    
    
    AK47 = Gun('AK47',100)
    # print(AK47)
    RuiEn = Soldier('RuiEn','AK47')
    RuiEn.fire(AK47)
    RuiEn.fire(AK47)
    AK47.add_bullet(50)

![20190716141352954.png][]

**二 继承**：定义一个类，可以从现有的某个类继承

新的类称为子类 扩展类（Subclass），被继承的称为父类 基类 超类 （Baseclass Superclass）

继承具有传递性

*  继承：实现代码的重用，相同的代码不需要重复写
 *  子类继承自父类，可以直接享受父类中已经封装好的方法
 *  子类重应该根据职责，封装子类特有的属性和方法
 *  如果子类重写了父类的方法
 *  在运行中，只会调用在子类中重写的方法而不会调用父类方法

class Animal():
        def eat(self):
            print('吃')
    
        def drink(self):
            print('喝')
    
        def sleep(self):
            print('睡')
    
    class Cat(Animal):
        def yell(self):
            print('喵')
    
    class Jiqimao(Cat):
        def speak(self):
            print('我会说话')
    
    jqm = Jiqimao()
    jqm.speak()
    jqm.sleep()

![20190717211740923.png][]

*  多继承：子类拥有多个父类叫多继承，拥有所有父类的属性和方法
 *  当父类的方法或属性同名时，按括号中的父类先后顺序执行

class A():
        def test(self):
            print('A --- test 方法')
        def demo1(self):
            print('A --- demo1方法')
    
    class B():
        def test(self):
            print('B --- test 方法')
        def demo(self):
            print('B --- demo方法')
    
    class C(B,A):
        pass
    
    c = C()
    c.test()
    c.demo1()

![20190717211900284.png][]

**三 多态**

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果

class Student():
        def get_score(self):
            print('获取学生成绩...')
    
    class Chinese():
        def get_score(self):
            print('获取语文成绩...')
    
    class Math():
        def get_score(self):
            print('获取数学成绩...')
    
    student1 = Student()
    student2 = Chinese()
    student3 = Math()
    student1.get_score()
    student2.get_score()
    student3.get_score()

![20190717212343296.png][]

[20190716112720291.png]: /images/20211209/63cc4ca77d074c6c957951e60873174b.png
[20190716144004638.png]: /images/20211209/b6367809a3f6474fbd0aa1a50bd9ccb9.png
[20190716141352954.png]: /images/20211209/1c0c3f43cfc54ed8af579f5e6d2f9e53.png
[20190717211740923.png]: /images/20211209/2f4713f2157b4819befe50d6acdf427c.png
[20190717211900284.png]: /images/20211209/85443af8a27e4e499cea7b35cdd6de58.png
[20190717212343296.png]: /images/20211209/9fe24367241c4c4cb40d1a08f33e79ca.png