1、面向对象和面向过程
面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么
基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式
优点：复杂的过程流程化
缺点：扩展性差
面向对象：核心是对象二字，对象指特征与技能的结合体
基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式
优点：可扩展性强
缺点：变成复杂度高，极容易出现过度设计的问题
2、类
对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体
在现实生活中：一定是先有一个个具体的对象，后总结出类
在程序中：一定是先定义类，后产生对象
定义类名字最好用驼峰式命名法，即每个单词的首字母都是大写的。
实例1：
class Students:
school='清华'
def __init__(self,name,age): # self就是谁调用谁就是self
self.name=name
self.age=age
def run(self):
print('%s get 100分' %self.name)
stu1=Students('李白',88)
print(stu1.school)
stu1.run()
stu2=Students('杜甫',99)
print(stu2.school)
stu2.run()
输出结果如下：
H:pythonpython.exe H:/python1/6.10面向对象.py
清华
李白 get 100分
清华
杜甫 get 100分
2. 封装
1.封装是面相对性一大特点
2.面向对象编程的第一步--将属性和方法封装到一个抽象的类当中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
5.封装根据职责将属性和方法封装到一个抽象的类中
定义类的准则
实例1：
小明爱跑步
需求
1.小明体重75公斤
2.小明每次跑步都会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤
class Person:
def __init__(self,name,weight):
self.name = name
self.weight = weight
def run(self):
self.weight -= 0.5
def eat(self):
self.weight += 1
def __str__(self):
return '%s的体重为%s公斤' % (self.name,self.weight)
xiaoming = Person('小明',75)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
实例2：
需求：
1、房子有户型、总面积、家具名称列表
房子没有任何家具
2、家具有名字和占地面积，其中
席梦思(bed):4平米
衣柜(chest): 2平米
餐桌(table): 1.5平米
3、将以上3个家具添加到房子中
4、打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表
class Item:
def __init__(self,name,area):
self.name = name
self.area = area
class House:
def __init__(self,name,total_area):
self.name = name
self.total_area = total_area
self.free_area = total_area
self.items = []
def add_item(self,item):
if item.area < self.free_area:
self.free_area = self.free_area - item.area
self.items.append(item.name)
else:
print('%s太大,放不进去' % item.name)
def __str__(self):
return '户型:%s|总面积:%s|剩余面积:%s|家具列表:%s' % (self.name,self.total_area,self.free_area,self.items)
house = House('地下室',30)
bed = Item('席梦思',4)
chest = Item('衣柜',2)
table = Item('冰箱',40)
house.add_item(bed)
house.add_item(chest)
house.add_item(table)
print(house)
实例3：
class Gun:#创建枪类
def __init__(self,gun_type):
self.gun_type = gun_type#初始化枪的型号
self.bullet = 0#初始化子弹的数量
def add_count(self, count):#添加子弹
self.bullet += count
def shoot(self):#射击
if self.bullet > 0:#假如子弹数量大于0
self.bullet -= 1# 那就射击，并且减少子弹数量
print('开火.......%s' % self.bullet)
else:
print('没有子弹啊，兄弟，别这么坑我啊？？？')#否则没有就显示没有子弹
class Soldier:#创建一个士兵的类
def __init__(self, name,gun=None):
self.name = name#初始化士兵的姓名
self.gun = gun#初始化枪
def fire(self):#开火方法
if self.gun:#假如有枪
self.gun.shoot()#那就射击
else:#不然就显示没有枪
print('没有枪啊，兄弟，你让我去送死吗？？')
ak47 = Gun('AK47')#创建一个枪的对象叫ak47
ak47.add_count(10)#添加10颗子弹
xsd = Soldier('许三多')#实例化一个许三多的士兵对象
xsd.gun = ak47#把枪交到许三多手中
xsd.fire()#开火
3.继承
继承实现代码的重用，相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求，编写特定的代码
单继承
多继承
3.1继承：继承实现代码的重用，相同的代码不需要重复的编写
实例1：
class Anamal(object): # 新类式：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('我会飞啦！！！！')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()
输出结果如下：
吃
跑
睡
喝
汪汪叫
我会飞啦！！！！
3.2方法的重写
子类拥有父类的所有方法和属性。
子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
当父类的方法实现不同的子类需求时，可以对方法进行重写。
实例：
#重写哮天犬叫唤的方法
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()
运行结果如下：
吃
跑
睡
喝
牛逼的叫.......
我会飞啦！！！！
3.3对父类的方法进行扩展
1.在子类中重写父类的方法
2.在需要的位置使用super().父类方法来调用父类方法的执行
3.代码其他的位置针对子类的需求，编写子类特有的代码实现
关于super：
在python中super是一个特殊的类
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() # 继承了Dog中的bark的内容
print('%*#*@^$*(@')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()
运行结果如下：
吃
跑
睡
喝
牛逼的叫.......
汪汪叫
%*#*@^$*(@
我会飞啦！！！！
4.多态
多态不同的子类对象调用相同的父类方法，产生不同的执行结果
a.多态可以增加代码的灵活度
b.以继承和重写父类方法为前提
c.是调用方法的技巧，不会影响到类的内部设计
实例：
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('小明')
#创建狗对象
dog1 = Dog('旺财')
dog2 = XiaoTianQuan('飞天旺财')
#让小明跟狗玩耍
xiaoming.game_with_dog(dog1)
xiaoming.game_with_dog(dog2)
运行结果如下：
小明 和 旺财 正在开开心心的玩耍......
旺财 开开心心去玩耍.....
小明 和 飞天旺财正在开开心心的玩耍......
飞天旺财 非常开开心心去玩耍.....