'''
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 体重:%s公斤 ' % (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 面积:%s平米 ' % (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 总面积:%s平米 剩余面积:%s平米 家具列表:%s ' % (self.house_type, self.total_area, self.free_area, self.items)) else:#否则添加不进去 print('家具太大了，装不进去....') def __str__(self):#打印房子当前状态 return '户型:%s 总面积:%s平米 剩余面积:%s平米 家具列表:%s ' % (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 子弹为%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()