Python 编程——面向对象编程

一、面向对象

面向对象编程——Object Oriented Programming,简称 OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。

面向对象vs面向过程

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。侧重于怎样去做

特点：
01.注重步骤和过程，不注重职责分工
02.如果需求复杂，代码会变得非常复杂
03.开发复杂的项目时，没有固定的套路，开发难度很大

面向对象的程序设计的核心是对象（上帝式思维），侧重于谁来做
特点：
01.注重对象和职责，不同的对象承担不同的职责
02.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
03.需要在面向过程的基础上，在学习一些面写对象的语法

二、类定义与实例化

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。

1.面向对象有两个核心概念： 类 和 对象

01.类

是一群具有相同特征或行为的事物的一个统称（类是抽象的，不能直接使用）

02.对象

由类创造出来的；具体存在。

2.类和对象的关系：

类是模板。对象是根据模板创建出来的
类只需要一个，对象可以有多个；

类：属性(信息)和方法(你能完成的动作)
           1.类名：这类事物的名字（满足大驼峰命名法）
                        大驼峰命名法：
                          1.每个单词的首字母大写
                          2.单词与单词之间没有下划线
2.属性：这个类创建出来的对象有什么特征
3.方法：这个类创建出来的对象有什么行为

类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类

属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑

简单示例：
需求1：
小明今年18岁，身高1.80，每天早上要跑步，会去吃东西
小美今年17岁，身高1.67，小美不跑步，小美喜欢吃东西

Person		#类名
age			#属性
weight		#属性
run()		#方法
eat()		#方法

实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

初始化方法：
类名() 就可以创建一个对象
类名()创建对象的时候，python的解释器会自动执行以下操作
        1.为对象在内存中分配空间—创建对象
        2.调用初始化方法为对象的属性设置初始值 --初始化方法(__init__)
这个初始化方法是内置方法，是专门用来定义一个类具有哪些属性的方法

简单示例：

class Cat():
    def __init__(self,new_name):
        #print('这是一个初始化方法')
        self.name = new_name
    # self.name 在类中的任何方法中都可以使用
    def eat(self):
        print('%s 爱吃鱼' %(self.name))
        #print('eating~~~')
    def drink(self):
        print('%s 要喝水' %(self.name))

# 使用类名()创建对象的时候，会自动调用初始化方法__init__
hello_kitty = Cat('hk')
hello_kitty.eat()
hello_kitty.drink()
fentiao = Cat('fentiao')
fentiao.eat()
fentiao.drink()

如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象的时候，使用类名(属性)调用

类的方法：

__del__方法：
__str__方法：

在python中
当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法

应用场景
__init__改造初始化方法，可以让创建对象更加灵活
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

__del__方法示例：

class Cat:
    def __init__(self,name):
        self.name = name
        print('%s 来了' %(self.name))
    def __del__(self):
        print('%s 走了' %(self.name))

tom = Cat('tom')
print(tom.name)
del tom
print('*' *50)
print(tom.name)

__str__方法示例：、

__str__方法：
在python中，使用print输出对象变量的时候，默认情况下会输出这个变量引用的对象是由哪一个类创建的对象以及在内存中的地址(十六进制表示)
如果在开发中，希望使用print输出变量时候，能够打印自定义的内容，就可以利用__str__这个内置方法了

class Cat:
    def __init__(self,name):
        self.name = name
    def __str__(self):
    	#必须返回一个字符串
    	return '我是 %s ' %(self.name)

tom = Cat('tom')
print(tom)
addr = id(tom)
print(addr)
#转换为十六进制
print('%x' %(addr))
#转换为十进制
print('%d' %(addr))

用面向对象的方法是实现栈

class Stack:
    def __init__(self):
        self.stack = []
    #入栈
    def push(self,value):
        self.stack.append(value)
        return True
    #出栈   
    def pop(self):
        # 判断栈是否为空
        if self.stack:
            # 取出栈顶元素
            item = self.stack.pop()
            return item
        else:
            return False
    #取出栈顶元素
    def top(self):
        if self.stack:
            return self.stack[-1]
        else:
            return False
    #栈的长度
    def length(self):
        return len(self.stack)
    def view(self):
        return ','.join(self.stack)
s = Stack()
s.push('1')
s.push('2')
item = s.pop()
print(s.view())

三、封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 根据职责将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

简单示例：
需求1
1.小明体重75.0公斤
2.小明每次跑步都会减肥0.5公斤
3.小明每次吃东西体重都会增加1公斤

class Person:
    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
xiaoming  = Person('小明',75.0)
xiaoming.run()
print(xiaoming)
xiaoming.eat()
print(xiaoming)

需求2
1.小明和小美都爱跑步
2.小美体重45.0公斤
2.每次跑步都会减肥0.5公斤
3.每次吃东西体重都会增加1公斤
##提示：因为属于同一类，而且方法属性都相同

class Person:
    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  = Person('小美',45.0)
xiaomei.run()
print(xiaomei)
xiaomei.eat()
print(xiaomei)        

需求3：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和战地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

提示：涉及两个类，由于家具类是要被作为对象使用的，所以先定义家具类

class HouseItem:
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s] 占地 %.2f' %(self.name,self.area)
class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        self.item_list = []
    def __str__(self):
        return ('户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'
                %(self.house_type,self.area,self.free_area,self.item_list))

    def add_item(self,item):
        # 1.要判断家具的面积
        if item.area > self.free_area:
            print('%s 的面积太大了，无法添加' %(item.name))
            return
        # 2.将家具的名称添加到列表中去
        self.item_list.append(item.name)
        # 3.计算剩余面积
        self.free_area -= item.area

# 创建家具对象
bed = HouseItem('bed',400)
# print(bed)
chest = HouseItem('chest',2)
# print(chest)
table = HouseItem('table',1.5)
# print(table)

# 创建房子对象
my_home = House('两室一厅',80)
# 将家具添加到房子中去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

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

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

class Gun:
    def __init__(self,model):
        self.model = model
        self.bullet_count = 0

    def add_bllet(self,count):
        self.bullet_count += count

    def shoot(self):
        if self.bullet_count <=0:
            print('%s 没有子弹了...' %(self.model))
            return
        self.bullet_count -= 1
        print('%s ~~~~~%s' %(self.model,self.bullet_count))

class Soldier:
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        if self.gun ==None:
            print('%s 还没有枪...' %(self.name))
            return
        self.gun.add_bllet(10)
        self.gun.shoot()

ak47 = Gun('ak47')
# ak47.add_bllet(50)
# ak47.shoot()
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

四、继承

1.简单示例：

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

class Animal:
    def eat(self):
        print('吃～～～～')

    def drink(self):
        print('喝～～～～')

    def run(self):
        print('跑～～～～')

    def sleep(self):
        print('睡～～～～')

class Cat(Animal):
    def call(self):
        print('喵喵～～～～')

# 创建一个猫对象
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.sleep()
fentiao.call()

1.子类继承自父类，可以直接享用父类中已经封装好的方法
2.子类中应该根据职责，封装子类特有的属性和方法

2.继承的传递性

当父类方法的实现不能满足子类的需求的时候，可以对方法进行重写(覆盖父类的方法)，对父类方法进行扩展

class Animal:
    def eat(self):
        print('吃～～～～')

    def drink(self):
        print('喝～～～～')

    def run(self):
        print('跑～～～～')

    def sleep(self):
        print('睡～～～～')

class Cat(Animal):
    def call(self):
        print('喵喵～～～～')

class Hellokitty(Cat):
    def speak(self):
        print('说日语')

    def call(self):
        # 1.针对子类特有的需求，编写代码
        print('$###$^&&$#@')
        # 2.调用原来在父类中封装的方法
        #Cat.call(self)     #python2.x里
        super().call()      #python3.x里

# 创建一个猫对象
kt = Hellokitty()
kt.call()
kt.drink()
kt.eat()
kt.sleep()
kt.run()

3.继承的顺序

class A:
    def test(self):
        print('A--------------test方法')
    def demo(self):
        print('A--------------demo方法')

class B:
    def test(self):
        print('B--------------test方法')
    def demo(self):
        print('B--------------demo方法')
# 先A后B
class C(A,B):
    pass

c = C()
c.test()
c.demo()

注意：一般父类函数名称不要相同，避免混淆

4.新式类和旧式类

object是python为所有对象提供的基类，提供一些内置的属性和方法(可以使用dir函数查看)
注意：python2.x里，继承的话需要在括号里加上object，才能继承基类的方法，而python3.x系列里自动继承

新式类：以objiect为基类，推荐使用
旧式类(经典类)：不以objiet为基类，不推荐

五、多态

多态(以封装和继承为前提)
不同的子类对象调用相同的方法，产生不同的执行结果

class Dog(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print('%s 开心的玩～～～' % (self.name))
class Gaofei(Dog):
    # 父类的方法不能满足子类的需求，重写game方法
    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()

# 创建一个狗对象
#wangcai = Gaofei('高飞')
wangcai = Dog('大黄')
# 创建一个人对象
xiaoming = Person('小明')
# 让小明和狗玩
xiaoming.game_with_dog(wangcai)

六、类结构

类的结构
术语–实例
1.使用面向对象开发，第一步是设计类
2.使用 类名() 创建对象，创建对象的动作有两步
1.在内存中为对象分配空间
2.调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在–实例
因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时，需要把对象的引用传递到方法内部

类方法和类属性

类方法:针对类对象定义的方法 在类方法内部可以直接访问类属性或者调员工其他的类方法
类属性:针对类对象定义的属性 使用赋值语句在class关键字下可以定义类属性(类属性用于记录与这个类相关的特性)
类名.属性 -----调用类属性
类名.方法名 ----调用类方法

class Toy(object):
    # 1.使用赋值语句定义类属性，记录所有玩具的数量
    count = 0
    def __init__(self,name):
        self.name = name
        # 让类属性 +1
        Toy.count += 1
    @classmethod
    def show_toy_count(cls):
        print('玩具对象的数量 %d' %(cls.count))
# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('泰迪熊')
# 调用类方法
Toy.show_toy_count()

静态方法

在开发中，如果需要在一个类中封装一个方法 这个方法既不需要访问实例属性或者调用实例方法也不需要访问类属性或者调用类方法，这个时候，我们就可以把这个方法封装成一个静态方法

class Cat(object):
    @staticmethod
    def call():
        print('喵喵～')
# 通过 类名. 调用静态方法
Cat.call()

# 不需要创建对象，直接就可以使用

练习题：
1.设计一个Game类
1.查看帮助信息
2.查看历史最高分
3.创建游戏对象，开始游戏
属性
方法

class Game(object):
    # 1.历史最高分
    top_score= 10000
    def __init__(self,name):
        self.name = name
    @classmethod
    def show_top_score(cls):
        print('历史记录 %d' %(cls.top_score))
    @staticmethod
    def show_help():
        print('帮助信息@￥￥@！￥￥@！#￥@！')
    def start_game(self):
        print('%s 开始游戏啦～～' %(self.name))
# 查看帮助信息
Game.show_help()
# 查看历史最高分
Game.show_top_score()
# 创建游戏对象
game = Game('ysk')
game.start_game()