python面向对象2--综合案例：烤地瓜、搬家具、单继承、多继承

python面向对象1–类、对象、属性、魔法方法
python面向对象2–综合案例：烤地瓜、搬家具、单继承、多继承
python面向对象3-多层继承、super()、私有权限、多态、类属性实例属性、类方法和静态方法

五、综合应用

5.1 烤地瓜

需求：
1.被烤的时间和对应的地瓜状态:
2,添加调理，用户可以根据自己的意愿添加调料

需求1：被烤的时间和对应的地瓜状态

步骤：
事物分类—地瓜类

定义类
地瓜的属性：被烤的时间、状态、调料
地瓜的方法：被烤 添加调料
显示对象信息

#1，定义类：初始化属性、方法、显示信息的str
class SweetPotato():
	def __init__(self):
		#被烤时间
		self.cook_time = 0
		#烤的状态
		self.cook_state = '生的'
		#调料列表
		self.condiments = []
	
	#2，创建对象并调用对应的实例方法
	def cook(self,time):
		"""烤地瓜方法"""
		#1，计算整体考过的时间
		self.cook_time += time
		#2，用整体时间进行判断状态
		if 0 <= self.cook_time <3:
			self.cook_state = '生的'
		elif 3 <= self.cook_time <5:
			self.cook_state = '半生不熟'
		elif 5 <= self.cook_time <8:
			self.cook_state = '熟了'
		elif self.cook_time >=8:
			self.cook_state = '烤糊了'
	
	#str魔法方法，用于输出对象状态
	def __str__(self):
		return f'这个地瓜的被烤过的时间是{self.cook_time}，状态是{self.cook_state}'
			

digua1 = SweetPotato()
print(digua1)  #这个地瓜的被烤过的时间是0，状态是生的
digua1.cook(2)
print(digua1) #这个地瓜的被烤过的时间是0，状态是生的

digua1.cook(3)
print(digua1) #这个地瓜的被烤过的时间是5，状态是熟了

太强了，这个讲的清晰又简洁

需求2： 添加调料

class SweetPotato():
	def __init__(self):
		#被烤时间
		self.cook_time = 0
		#烤的状态
		self.cook_state = '生的'
		#调料列表
		self.condiments = []
	
	#2，创建对象并调用对应的实例方法
	def cook(self,time):
		"""烤地瓜方法"""
		#1，计算整体考过的时间
		self.cook_time += time
		#2，用整体时间进行判断状态
		if 0 <= self.cook_time <3:
			self.cook_state = '生的'
		elif 3 <= self.cook_time <5:
			self.cook_state = '半生不熟'
		elif 5 <= self.cook_time <8:
			self.cook_state = '熟了'
		elif self.cook_time >=8:
			self.cook_state = '烤糊了'
	
	#
	def add_condiments(self,condiment):
		self.condiments.append(condiment)

	#str魔法方法，用于输出对象状态
	def __str__(self):
		return f'这个地瓜的被烤过的时间是{self.cook_time}，状态是{self.cook_state}，调料是{self.condiments}'

digua1 = SweetPotato()
print(digua1)  #这个地瓜的被烤过的时间是0，状态是生的，调料是[]
digua1.add_condiments('辣椒面')
digua1.cook(2)
print(digua1) #这个地瓜的被烤过的时间是2，状态是生的，调料是['辣椒面']
digua1.add_condiments('酱油')
digua1.cook(3)
print(digua1) #这个地瓜的被烤过的时间是5，状态是熟了，调料是['辣椒面', '酱油']

5.2 搬家具

需求：将小于房子剩余面积的家具搬到房子中
步骤：两个事物：房子类，家具类

房子类：

• 实例属性：房子位置、房子占地面积、房子剩余面积、房子内家具列表
• 实例方法：容纳家具
• 显示房屋信息str

家具类：

• 属性：家具名称、家具占地面积

#家具类
class Furniture():
	def __init__(self,name,area):
		#家具名称
		self.name = name
		#家具占地面积
		self.area = area
		
#双人床
bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)
ball = Furniture('篮球场', 2000)

#房屋类
class Home():
	def __init__(self,address,area):
		self.address = address  #房子位置
		self.area = area #房屋面积
		self.free_area = area #剩余面积
		self.furniture = []
	
	def __str__(self):
		return f'房子地理位置在{self.address}，房屋面积{self.area}，剩余面积{self.free_area},家具有{self.furniture}'
		
	#家具的容纳
	def add_furniture(self,item):  #item是传入的家具对象
		if self.free_area >= item.area:
			self.furniture.append(item.name)
			self.free_area -=item.area  #剩余面积更新
		else:
			print('家具太大，剩余面积不足，无法容纳')

# 房子1：北京，1000
jia1 = Home('北京', 1000)
print(jia1) #房子地理位置在北京，房屋面积1000，剩余面积1000,家具有[]

jia1.add_furniture(sofa)
print(jia1) #房子地理位置在北京，房屋面积1000，剩余面积990,家具有['沙发']

jia1.add_furniture(ball)
print(jia1)
#家具太大，剩余面积不足，无法容纳
#房子地理位置在北京，房屋面积1000，剩余面积990,家具有['沙发']

经典类或旧是类

#新式类
class 类名（object）:
	代码

二、单继承

故事：师傅有一套煎饼果子技术，打算传给最得意的弟子daqiu

一个父类继承给唯一的子类
要定义师傅类和徒弟类，徒弟继承师傅
class 子类名（父类名）：

#1，师傅类。属性和方法
class Master(object):
	def __info__(self):
		self.kongfu = '[古法煎饼果子配方]'
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
#2，定义徒弟类，继承师傅类
class Prentice(Master):   
	pass
#3，用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)  #[古法煎饼果子配方]
daqiu.make_cake()  #运用[古法煎饼果子配方]制作煎饼果子

简化单继承代码

#子类继承父类，指子类默认继承父类的所有属性和方法
#父类A
class A(object):
	def __init__(self):
		self.num = 1
	def info_print(self):   #定义一个方法，后面调用
		print(self.num)

#子类B
class B(A):
	pass

#创建对象
result = B()
result.info_print() #输出：1
#子类的对象也能使用父类的方法

所有类默认继承object类，object类是顶级类或者基类，其他子类叫做派生类

三、多继承

故事：daqiu除了学习师傅的技术，还想学习学校的煎饼果子技术

多继承：一个类同时继承多个父类

#1，师傅类。属性和方法
class Master(object):
	def __info__(self):
		self.kongfu = '[古法煎饼果子配方]'
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')

#学校类
class School(object):
	def __info__(self):
		self.kongfu = '[学校煎饼果子配方]'
	def make_cake(self):       #两个父类的属性和方法一样
		print(f'运用{self.kongfu}制作煎饼果子')

#2，定义徒弟类，继承师傅类
class Prentice(Master,School):    
	pass

#3，用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)  #[古法煎饼果子配方]
daqiu.make_cake()  #运用[古法煎饼果子配方]制作煎饼果子
#第一个父类是Master，优先继承它

结论：一个类有多个父类时，默认使用第一个父类的同名属性和方法

四、子类重写父类同名方法和属性

子类中存在和父类同门的属性和特征，此时，创建子类的对象，调用它的属性和特征，是优先子类

故事：daqiu在掌握师傅的技术后，又自己研发出一套独创新技术，此时使用daqiu的技术应该是daqiu自己的计算

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class Prentice(Master):
    def __init__(self):
        self.kongfu = '[独制煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

daqiu = Prentice()
print(daqiu.kongfu)  #[独制煎饼果子配方]
daqiu.make_cake()  #运用[独制煎饼果子配方]制作煎饼果子

结论：子类有，则优先子类