面向对象

1.面向对象(oop:object oriented programming)概念
1)两个核心的概念
类:是一群具有相同特征或行为的事物的一个统称(类是抽象的，不能直接使用)
对象:由类创造出来的具体存在

2)类和对象的关系
类是模板,对象是根据这个模板创建出来的
类只需要一个, 对象可以有多个

类：属性(信息)和方法(你能完成的动作)

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

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

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

class Cat: ##创建类，开辟一块内存空间
def eat(self): ##self引用的是和对象调用的内存地址一样的，在
print(‘猫爱吃鱼’)
def drink(self):
print(‘猫爱河水’)

tom = Cat() ##创建对象，调用类，也就是调用开辟的内存空间
print(tom) ##现实调用的内存年地址
tom.eat() ##调用类中的功能
tom.drink()

class Cat:                   ##创建类，开辟一块内存空间
    def eat(self):           ##self引用的是和对象调用的内存地址一样的，在
            print('%s 猫爱吃鱼' %self.name)
    def drink(self):
            print('%s 猫爱河水' %self.name)

2.
tom = Cat()         ##创建对象，调用类，也就是调用开辟的内存空间
tom.name = 'Tom'    ##命名
tom.eat()           ##调用类中的功能
tom.drink()


fentiao = Cat()
fentiao.name = 'fentiao'
fentiao.eat()
fentiao.drink()

self:
哪一个对象调用的方法，self就是哪一个对象的引用
在封装的方法内部，self就表示当前调用方法的对象自己
在调用方法时，程序员不需要传递self参数(但是定义的式时候，第一个参数
必须是self

可以使用 .属性名 利用赋值语句就可以在类的外部给对象增加属性(不推荐)
将对象的属性封装在类中

2.面向对象与面向过程的差异
1)面向过程：—侧重于怎么做？

1.把完成某一个需求的, 所有步骤, 从头到尾, 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数

特点：代码的维护比较差

1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大

2)面向对象：----侧重于谁来做？
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法,耦合性比较低,便于维护

1.在完成某一个需求前，首先确定职责--要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法

特点：

1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

3.初始化方法：

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

如:

class Cat():
    def __init__(self,new_name):    ##new_name就是一个形参，接受外界传入的值
        self.name = new_name        ##在类中的任何方法都可以使用
    def eat(self):
        print('%s 河水' %(self.name))
    def drink(self):
        print('%s 喝可乐' %(self.name))

#使用类名()创建对象的时候，会自动调用初始化方法__init__
tom =Cat('haha')  					##括号中就是给形参传递信息
tom.eat()
tom.drink()

fentiao = Cat('fentiao')
fentiao.eat()
fentiao.drink()

如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造

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

4. 3种方法
   __del__方法：
   __str__方法：
   __del__方法：

在python中

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

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

如:
1)

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        ##del关键字可以删除一个对象，del关键字自己调用__del__方法
print('*' *50)
print(tom.name)

__str__方法：

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

如:

1)
		class Cat():
	    def __init__(self,name):
	        self.name =name
	    def __str__(self):      ##必须返回一个字符串
	        return 'i am %s' %(self.name)
		tom = Cat('tom')
		print(tom)
		fentiao = Cat('feniao')
		print(fentiao)
2)
					class Cat():
					    def __init__(self,name):
					        self.name =name
					tom = Cat('tom')
					print(tom)              ##直接输出的是调用的内存地址(默认是16进制)
					addr = id(tom)
					print(addr)             ##输出就是10进制地址
					print('%x' %(addr))     ##转换输出为16进制地址
					print('%d' %(addr))     ##转换输出为10进制地址
					fentiao = Cat('feniao')
					print(fentiao)

例子: 模拟C语言的冒泡排序,栈—>先进后出

class Zhan():
    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):              	##出栈  与pop块功能一样,但是在特性是不一样的, 此处模拟C语言,所以两个都写了
        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 = Zhan()
s.push('1')
s.push('6')
s.push('5')
s.push('3')
item = s.pop()
print(item)
print(s.view)

5.面向对象的封装
封装:

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

如:
小明体重75.0公斤
小明每次跑步都会减肥0.5公斤
小明每次吃东西体重都会增加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)

例题1:

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):
        if item.area > self.free_area:
            print('%s 的面积太大,无法添加' %(item.name))
            return
        self.item_list.append(item.name)
        self.free_area -= item.area     ##计算剩余面积

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

##创建房子的对象
home = House('两室一体',100)
home.add_item(bed)
home.add_item(chest)
home.add_item(table)
print(home)

例子2:

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

做法:

	class Gun():			##枪的类
	    def __init__(self,mode):
	        self.mode = mode
	        self.bullet_count = 0
	    def add_bullet(self,count):
	        self.bullet_count += count
	    def shoot(self):
	        if self.bullet_count <=0:
	            print('%s没有子弹~~' %self.mode)
	            return
	        self.bullet_count -= 1
	        print('%s~~~~~%s' %(self.mode,self.bullet_count))
	
	class Solder():			##人的类
	    def __init__(self,name):
	        self.name = name
	        self.gun = None
	
	    def fire(self):
	        if self.gun == None:
	            print('%s 没枪....'%(self.name))
	
	        self.gun.add_bullet(10)
	        self.gun.shoot()
	
##枪的对象
	gun = Gun('AK47')
	# gun.add_bullet(0)
	# gun.shoot()

##人的对象	
	solder = Solder('Ruien')
	solder.gun = gun
	solder.fire()