面向对象

1、面向对象与面向过程
    面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么
    基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式
    优点：复杂的过程流程化
    缺点：扩展性差


    面向对象：核心是对象二字，对象指特征与技能的结合体
    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式
    优点：可扩展性强
    缺点：变成复杂度高，极容易出现过度设计的问题

2、类
    对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体
    在现实生活中：一定是先有一个个具体的对象，后总结出类
    在程序中：一定是先定义类，后产生对象
　　创建类的时候，是首字母要大写
类属性的增删改查：

class Studnets(object):
    school = '实验中学'

    def choose_course(self):
        print('选课')
stu1 = Studnets()
print(stu1.school)    #查看
stu1.school ='实验'    #改
print(stu1.school)
stu1.contry = '北京'    #增加
print(stu1.contry)
# del stu1.contry        #删除
# print(stu1.contry)

运行结果：

定义个类：

__init__(self)用法中，self表示，谁调用就代表谁

先考虑立场，再考虑归类，再考虑每一个对象的特征和技能

class Studnets(object):
    school = '实验中学'#数据属性
    def __init__(self, name, age): #类的初始化方法，可以把每个人不同的特征定义下来，自动调用初始化函数
        self.name = name
        self.age = age
    def choose_course(self):#函数属性
        print('%s正在选课，年纪是%s' % (self.name, self.age))
stu1 = Studnets('张三', 18)
stu1.choose_course()
stu2 = Studnets('李四', 19)
stu2.choose_course()
stu3 = Studnets('王五', 20)
stu3.choose_course()

运行结果：

 例2：

class Studnets(object):
    school = '实验中学'#数据属性
    def __init__(self, name, age): 
        self.name = name
        self.age = age
    def choose_course(self):#函数属性
        print('%s正在选课，年纪是%s' % (self.name, self.age))
    def run(self):
        print('%s正在奔跑...' % (self.name))
stu1 = Studnets('帅帅', 25)
stu1.run()
stu2 = Studnets('六六', 18)
stu2.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('小明', 75)
xiaoming.eat()#加1
xiaoming.eat()#加1
xiaoming.run()#减0.5
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
        else:#否则添加不进去
            del self.items[-1]
            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)#实例化出一个餐桌对象
train = Items('火车', 100)
路飞 = Items('海贼王', 10)
house = House('两室一厅', 90)#实例化出一个房子对象
house.add_item(bed)#执行添加家具动作
house.add_item(chest)
house.add_item(table)
house.add_item(train)
house.add_item(路飞)
print(house)

运行结果：火车由于太大，无法放进去

封装案例3：士兵突击

　　　　属性可以是另外一个类创建的对象：

　　需求：

　　　　1、士兵许三多，枪AK47

　　　　2、士兵可以开火

　　　　3、枪能够发射子弹

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

　　　　

class Gun(object):#创建枪类
    def __init__(self, name):#初始化枪类属性（子弹默认没有，所以不写了）
        self.name = name
        self.bullet = 0#子弹默认是零
    def shoot(self):#射击技能
        if self.bullet > 0:#判断子弹数
            # for i in range(self.bullet): #直接把子弹打空
                self.bullet -= 5
                print('冲啊.......突突突突突.......[%s]' % self.bullet)
        else:
            print('没子弹，上刺刀......')
    def add_bullet(self, count):#装填子弹技能
        self.bullet += count
    def __str__(self):
        return '枪型号:%s
剩余子弹:%s
' % (self.name, self.bullet)
class Soldier(object):#创建士兵类
    def __init__(self, name):#初始化士兵类属性（枪默认没有所以不写在这了）
        self.name = name
        self.gun = None#没有枪
    def fire(self):
        if self.gun:
            self.gun.shoot()#调用子弹函数
        else:
            print('[%s]:没有枪，赶紧撤......' % self.name)

ak47 = Gun('AK47')#上枪
xsd = Soldier('许三多')#上士兵
xsd.gun = ak47#把枪给士兵
xsd.gun.add_bullet(50)#上子弹
xsd.fire()
xsd.fire()

运行结果：

继承

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

　　　　·设计类的技巧

　　　　·子类针对自己特有的需求，编写特定的代码

单继承

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

class Dog(Anamal):#继承Anamal
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):#继承Dog
    def fly(self):
        print('我会飞啦！！！！')

dog = XiaoTianQuan()
dog.bark()
dog.run()
dog.eat()
dog.sleep()
dog.drink()
dog.fly()

运行结果：

多继承

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

class Dog(object):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Anamal,Dog):#继承Anamal和 Dog
    def fly(self):
        print('我会飞啦！！！！')

dog = XiaoTianQuan()
dog.bark()
dog.run()
dog.eat()
dog.sleep()
dog.drink()
dog.fly()

运行结果：

方法的重写

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

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

应用场景：当父类的方法不能满足子类需求时，可以对方法进行重写

 

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()#继承bark方法

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

运行结果：

 初始化__init__继承

class Person(object):#创建一个人类
    def __init__(self, name):
        self.name = name

class KOBE(Person):#创建一个科比类，继承人类
    def __init__(self, age):#定义自己的初始化
        super(KOBE, self).__init__('科比')#继承的初始化，如果有参数需要传参
        self.age = age

kobe = KOBE(18)
print(kobe.name)
print(kobe.age)

运行结果：

 多态

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

　　　　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)

运行结果：

类方法

 @classmethod，只访问类属性

class Tool(object):#创建工具类
    count = 0#类属性：工具的数量
    @classmethod#装饰函数为类方法
    def show_tools_count(cls):#如果只访问类属性，那么就把他定义成类方法
        print('当前工具数量为%s' % cls.count)#类方法要用cls访问和调用
    def __init__(self, name):
        self.name = name
        Tool.count += 1
tool1 = Tool('锤子')
tool2 = Tool('榔头')
Tool.show_tools_count()

 运行结果：

静态方法

@staticmethod

• 既不需要访问实例属性或者调用实例方法
• 也不需要访问类属性或者调用类方法
• 这个时候我们可以考虑把这个方法封装成静态方法

class Dog(object):
    @staticmethod#声明这是一个静态方法
    def run():#不用实例化，就可以不用self
    #不访问实例属性，也不访问类属性
        print('小狗要跑.....')
    def jump(self):#用self就会报错
        print('小狗要跳.....')
Dog.run()
Dog.jump()

运行结果：

如果加了self，那么就要实例化

class Dog(object):
    @staticmethod#声明这是一个静态方法
    def run():
    #不访问实例属性，也不访问类属性
        print('小狗要跑.....')
    def jump(self):
        print('小狗要跳.....')
Dog.run()
xiaotianquan = Dog()
xiaotianquan.jump()

运行结果：