三大特征 封装 继承 多态

'''

1、面向对象与面向过程

    面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么

    基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式

    优点：复杂的过程流程化

    缺点：扩展性差

 

    面向对象：核心是对象二字，对象指特征与技能的结合体

    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式

    优点：可扩展性强

    缺点：变成复杂度高，极容易出现过度设计的问题

 

2、类

    对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体

    在现实生活中：一定是先有一个个具体的对象，后总结出类

    在程序中：一定是先定义类，后产生对象

 

'''

 
# class Students:
#     school = '中心小学'
#     def __init__(self,name, age, job):
#         self.name = name
#         self.age = age
#         self.job = job
#     def run(self):
#         # return 'running......'
#         print('running....')
# stu1 = Students('张三', 18, 'IT')
# stu2 = Students('王二', 16, 'student')
# stu3 = Students('赵五', 19, 'teacher')
# stu1.run()

 

 

特征：

一、封装

　　1.封装是面相对性一大特点

　　2.面向对象编程的第一步--将属性和方法封装到一个抽象的类当中

　　3.外界使用类创建对象，然后让对象调用方法

　　4.对象方法的细节都被封装在类的内部

 

题目1：

　1.小明体重75公斤

　2.小明每次跑步都会减肥0.5公斤

　3.小明每次吃东西体重会增加1公斤

 

class Person(object):
     def __init__(self, name, weight):
         self.name = name
         self.weight = weight
 
     def eat(self):      #吃
         self.weight += 1
 
    def run(self):        #跑
         self.weight -= 0.5
 
     def __str__(self):
         return '姓名:%s\n体重:%s公斤\n' % (self.name, self.weight)
 
xiaoming = Person('小明', 90)    #  创建小明
xiaoming.eat()                   #让小明调用吃的方法
xiaoming.run()                     #让小明调用跑的方法
print(xiaoming)

 

　题目2：　　　

   1、房子有户型、总面积、家具名称列表

　　　　房子没有任何家具

　2、家具有名字和占地面积，其中

　　　　席梦思(bed):4平米

　　　　衣柜(chest): 2平米

　　　　餐桌(table): 1.5平米

　3、将以上3个家具添加到房子中

　4、打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表

 

class Items(object):#创建一个家具类
    def __init__(self, name, area): #初始化出不同的类对象
        self.name = name
        self.area = area
 
     def __str__(self):
         return '家具名称:%s\n面积:%s平米\n' % (self.name, self.area)
 
class House(object):#创建房子类
     def __init__(self, house_type, total_area):#初始化房子类(因为新房子没有家具，剩余面积等于总面积，所以不用传参)
         self.house_type = house_type
         self.total_area = total_area
         self.free_area = total_area
         self.items = []
 
     def add_item(self, item):#添加家具的技能
         self.items.append(item.name)#一触发添加家具的技能就添加家具到列表中
         if self.free_area > item.area:#假如剩余面积大于家具面积就添加成功
             self.free_area = self.free_area - item.area
            # print('户型:%s\n总面积:%s平米\n剩余面积:%s平米\n家具列表:%s\n' % (self.house_type, self.total_area, self.free_area, self.items))
         else:#否则添加不进去
             print('家具太大了，装不进去....')
 
     def __str__(self):#打印房子当前状态
         return '户型:%s\n总面积:%s平米\n剩余面积:%s平米\n家具列表:%s\n' % \
               (self.house_type, self.total_area,self.free_area, self.items)
bed = Items('席梦思',4)#实例化出一个床对象
chest = Items('衣柜', 2)#实例化出一个衣柜对象
table = Items('餐桌', 1.5)#实例化出一个餐桌对象
# fire_car = Items('火车', 100)
 
 
house = House('两室一厅', 90)       #实例化出一个房子对象
house.add_item(bed)               #执行添加家具动作
house.add_item(chest)
house.add_item(table)
house.add_item(fire_car)
print(house)

 

题目3：

1、士兵  狗蛋 有一把M4A1

2、士兵 可以 开火

3、枪 能 发射 子弹

4、枪 装填 子弹 --增加子弹数量

 
class Gun(object):       #抢
    def __init__(self,name):
        self.name = name
        self.zidan = 0
    def add_zidan(self,count):     #填装子弹
        self.zidan += count
    def  shoot(self):          #射击
        if self.zidan > 0:
            self.zidan -= 1
            print('fire.....%s' %self.zidan)
        else:
            print(' no zidan ')
    def __str__(self):
        return ' 有一把%s\n子弹为%s'%(self.name,self.zidan)
 
class per(object):                 #人
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):             #开火
        if self.gun:
            self.gun.shoot()
        else:
            print('meiyou gun')
M4A1 = Gun('M4A1')       #创建枪
gd = per('狗蛋')       #创建狗蛋
gd.gun = M4A1    #狗蛋--调用了--抢  （也就是给狗蛋安排枪）
gd.gun.add_zidan(50)  #狗蛋的--枪--添加子弹
gd.fire()     #狗蛋开火
gd.fire()

二、继承

    继承实现代码的重用，相同的代码不需要重复的编写

 

动物：吃、喝、跑、睡

狗：除了（吃、喝、跑、睡） 还会（叫）

哮天犬：除了（吃、喝、跑、睡、叫） 还会（飞）

# class Anamal(object):
# #     def eat(self):
# #         print('吃')
# #     def drink(self):
# #         print('喝')
# #     def run(self):
# #         print('跑')
# #     def sleep(self):
# #         print('睡')
# #
# # class Dog():
# #     def bark(self):
# #         print('汪汪叫')
# #
# # class XiaoTianQuan(Anamal,Dog):
# #     def fly(self):
# #         print('我会飞啦！！！！')
# #
# # dog = XiaoTianQuan()
# # dog.bark()
# # dog.run()
# # dog.eat()
# # dog.sleep()
# # dog.drink()
# # dog.fly()

 

2、方法的重写

1）子类拥有父类的所有方法和属性

2）子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发应用场景

3）当父类的方法实现不能满足子类需求时，可以对方法进行重写

 

class Anamal(object):
     def eat(self):
         print('吃')
     def drink(self):
         print('喝')
     def run(self):
         print('跑')
     def sleep(self):
         print('睡')
 
class Dog(Anamal):
     def bark(self):            
         print('汪汪叫')
 
class XiaoTianQuan(Dog):
     def fly(self):
         print('我会飞啦！！！！')
     def bark(self):  
       print('有仙气的叫.......')
 
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()    #重写
dog.fly()

 

对父类的方法进行扩展

　　1.在子类中重写父类的方法

　　2.在需要的位置使用super().父类方法来调用父类方法的执行

　　3.代码其他的位置针对子类的需求，编写子类特有的代码实

关于super

　　在python中super是一个特殊的类

　　super()就是使用super类创建出来的对象

　　最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现

class Anamal(object):
    def eat(self):
         print('吃')
     def drink(self):
         print('喝')
     def run(self):
         print('跑')
     def sleep(self):
         print('睡')
class Dog(Anamal):
     def bark(self):       
          print('汪汪叫')
class XiaoTianQuan(Dog):
     def fly(self):
         print('我会飞啦！！！！')
 
     def bark(self):
         print('牛逼的叫.......')
         super().bark()       #调用基类的方法
         print('%*#*@^$*(@')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()
 
初始化__init__继承
class Person():
     def __init__(self, name):
         self.name = name
 
class KOBE(Person):
     def __init__(self, age):
         super(KOBE, self).__init__('科比')  #要将子类KOBE和self传递进去
         self.age = age
 
kobe = KOBE(18)
print(kobe.name)
print(kobe.age)
 

三、多态

　　面向对象的三大特性：

　　1.封装根据职责将属性和方法封装到一个抽象的类中

• 定义类的准则

　　2.继承实现代码的重用，相同的代码不需要重复的编写

• 设计类的技巧
• 子类针对自己特有的需求，编写特定的代码

　　3.多态不同的子类对象调用相同的父类方法，产生不同的执行结果

　　　　1.多态可以增加代码的灵活度

　　　　2.以继承和重写父类方法为前提

　　　　3.是调用方法的技巧，不会影响到类的内部设计

# class Dog(object):
#     def __init__(self, name):
#         self.name = name
#     def game(self):
#         print('%s 开开心心去玩耍.....' % self.name)
 
# class XiaoTianQuan(Dog):
#     def game(self):
#         print('%s 开开心心去玩耍.....' % self.name)
 
# class Person(object):
#     def __init__(self, name):
#         self.name = name
#     def game_with_dog(self, dog):
#         print('%s 和 %s 正在开开心心的玩耍......' % (self.name, dog.name))
#         dog.game()
#
# xiaoming = Person('小明')     #创建人对象
# dog = Dog('旺财')       #创建狗对象
# xiaoming.game_with_dog(dog)   #让小明跟狗玩耍
# xtq = XiaoTianQuan('飞天旺财')
# xiaoming.game_with_dog(xtq)

类方法

# class Tool(object):
#     count = 0
#     @classmethod
#     def show_tools_count(cls):
#         print('当前工具数量为%s' % cls.count)
#     def __init__(self, name1, name2):
#         self.name1 = name1
#         self.name2 = name2
#         Tool.count += 2
# tool1 = Tool('锤子')
# tool2 = Tool('榔头')
# Tool.show_tools_count()'';lkiy.

 静态方法：

        既不需要访问实例属性或者调用实例方法

        也不需要访问类属性或者调用类方法

        这个时候我们可以考虑把这个方法封装成静态方法

 

# class Dog(object):
#     @staticmethod
#     def run():
#     #不访问实例属性，也不访问类属性
#         print('小狗要跑.....')
#     def jump(self):
#         print('小狗要跳.....')
# # Dog.run()
# # Dog.jump()
# xiaotianquan = Dog()
# Dog.run()
# # Dog.jump('xiaotianquan')
# xiaotianquan.jump()
 

 

 

 

 

 

来源：https://www.cnblogs.com/heiguu/p/10098193.html