类的创建 以及 类的继承及其应用对象

类的创建 以及 类的继承及其应用场景

一, 类的创建

格式:

格式1:

class 类名:
	pass

格式2:

class 类名():
	pass

格式3:

# class 类名(父类名):
class 类名(object):
	pass

案例:

案例需求

定义老师类.

实现思路

1. 定义老师类(三种方式).
2. 函数内容.
3. 创建该类对象.
4. 打印该类对象.

# 1. 定义老师类(三种方式).
# class Teacher:
# class Teacher():
class Teacher(obiect):	# object是所有类的父亲, Python中所有的类都直接或间接继承自object类.
	# 2. 函数内容.
	pass

# 3. 创建该类对象.
t1 = Teacher()
# 4. 打印该类对象.
print(t1)

二, 继承入门

继承的定义

子类可以继承父类的 属性 和 行为.

继承的格式

class 子类名(父类名):
	pass
	

class A(B):
	pass
# A: 子类, 派生类.
# B: 父类, 基类, 超类.	
	

继承的好处和弊端

好处

提高代码的复用性.

弊端

耦合性增强了, 父类不好的内容, 子类想没有都不行.

扩展: 开发原则

高内聚, 低耦合

• 内聚: 指的是类自己独立处理问题的能力.
• 耦合: 指的是类与类之间的关系.
  大白话解释: 自己能搞定的事儿, 就不要麻烦别人.

案例

案例1:散步

案例需求

定义父类(男, 散步), 定义子类, 继承父类.

实现思路

1. 定义父类.
2. 定义属性性别男.
3. 定义行为walk().
4. 定义子类.
5. 测试子类的功能.

# 1. 定义父类.
class Father(object):
	# 2. 定义属性性别男.
	def __init__(self):
		self.gender = '男'
		
	# 3. 定义行为walk().
	def walk(self):
		print('饭后走一走, 活到九十九!')

# 4. 定义子类:
class Son(Father):
	pass

# 5. 测试子类的功能.
s = Son()
print(f'性别: {s.gender}')	# 子类从父类继承过来 属性.
s.walk()					# 子类从父类继承过来 行为.	

案例2:摊煎饼(单继承演示)

单继承定义

一个子类继承自一个父类

案例需求

一个摊煎饼的老师傅, 在煎饼果子界摸爬滚打多年, 研发了一套精湛的摊煎饼技术, 师傅要把这套技术传授给他的唯一的最得意的徒弟.

实现思路

1. 定义师傅类, Master
2. 定义属性: kongfu
3. 定义行为: make_cake()
4. 定义子类, Prentice, 继承师傅类.
5. 测试徒弟类的功能.

# 1. 定义师傅类.
class Master:
	# 2. 定义属性.
	def __init__(self):
		self.kongfu = '[古法配方]'

	# 3. 定义行为.
	def make_cake(self):
		print(f'采用{self.kongfu} 煎饼果子.')

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

# 3. 测试.
p = Prentice()
p.make_cake()	

案例3: 摊煎饼(演示多继承)

扩展: MRO机制.

• 解释:
  • Python中有MRO机制, 可以查看某个对象, 在调用函数时的 顺序, 即: 先找哪个类, 后找哪个类.
• 格式:

类名.mro()
类名.__mro__

案例需求

小明是一个爱学习的好孩子, 想学习更多的摊煎饼果子技术, 于是, 再逼百度搜索到黑马程序学校, 报班来培训学习摊煎饼果子技术.

实现思路

1. 定义师傅类.
2. 定义师傅类属性.
3. 定义师傅类方法.
4. 定义黑马学校类.
5. 定义黑马学校类属性.
6. 定义黑马学校类方法.
7. 定义徒弟类 -> 有个对象叫 小明.
8. 测试.
9. 查看mro机制的结果.

# 1. 定义师傅类.
class Master:
	# 2. 定义师傅类属性.
	def __init__(self):
		self.kongfu = '[古法煎饼果子配方]'
	# 3. 定义师傅类行为.
	def make_cake(self):
		print(f'运用{self.kongfu} 制作煎饼果子')

# 4. 定义黑马学校类.
class School:
	# 5. 定义学校类属性.
	def __init__(self):
		self.kongfu = '[黑马AI煎饼果子配方]'

	# 6. 定义学校类行为.
	def make_cake(self):
		print(f'运用{self.kongfu} 制作煎饼果子')

# 7. 定义徒弟类 -> 有个对象叫 小明.
	class Prentice(school, Master):	# 从左往右, 就近原则.
		pass

# 8. 测试.
xm = Prentice()
print(xm.kongfu)
xm.make_cake()


# 9. 查看mro机制的结果.
print(Prentice.mro())		# Prentice -> School -> Master -> object
print(Prentice.__mro__)		# Prentice -> School -> Master -> object

案例4: 子类重写父类功能.

重写的定义

• 概述:
  • 重写也叫覆盖, 即: 子类出现和父类重名的属性 或者 行为, 称之为: 重写.
• 重写的调用层次:
  • 遵循 就近原则, 子类有用, 没有就去就近的父类找, 依次查找其所有的父类, 有就用, 没有就报错.

案例需求

小明掌握了老师傅金和黑马的技术后, 自己潜心研究出一套自己的独门配方的全新摊煎饼果子技术.

实现思路

1. 老师傅类.
2. 老师傅属性.
3. 老师傅行为.
4. 黑马学校类.
5. 黑马学校属性.
6. 黑马学校行为.
7. 徒弟类.
8. 徒弟属性.
9. 徒弟行为.
10. 测试.
11. 创建徒弟类对象.
12. 访问属性.
13. 调用函数.

# 1. 老师傅类.
class Master:
	# 2. 老师傅属性.
	def __init__(self):
		self.kongfu = '[古法煎饼果子配方]'
	# 3. 老师傅行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
# 4. 黑马学校类. 
class School:
	# 5. 学校类属性.
	def __init__(self):
		self.kongfu = '[黑马AI煎饼果子配方]'
	# 6. 学校类行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')

# 7. 徒弟类.
class Prentice(School, Master):
	# 8. 徒弟类属性.
	def __init__(self):
		self.kongfu = '[独创煎饼果子配方]'
	# 9. 徒弟类行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
		
# 10. 创建徒弟类对象.
p = Prentice()
# 11. 访问属性.
print(p.kongfu)
# 12. 调用函数.
p.make_cake()	

案例5: 子类重写父类功能后, 继续访问父类功能

实现方法:

• 方法一:
  • 父类名.父类函数名(self) 精准访问, 想找那个父类, 就调哪个父类.
• 方法二:
  • super().父类函数名() 只能访问最近的那个父类, 有就用, 没有就往后继续查找.

案例需求

很多顾客都希望能吃到徒弟做出的煎饼果子有自己独立品牌的有自己独立品牌的煎饼果子, 拥有黑马配方技术的煎饼果子的味道

图解

方法一: 父类名.父类功能名(self)

实现思路

1. 老师傅类.
2. 老师傅类属性.
3. 老师傅类行为.
4. 黑马学校类.
5. 黑马学校属性.
6. 黑马学校行为.
7. 徒弟类.
8. 徒弟类属性.
9. 徒弟类行为.
10. 调用父类的功能.
11. 创建徒弟类对象.
12. 访问属性.
13. 调用函数.

# 1. 老师傅类.
class Master:
	# 2. 老师傅属性.
	def __init__(self):
		self.kongfu = '[古法煎饼果子配方]'
	# 3. 老师傅行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
			
# 4. 黑马学校类.
class School:
	# 5. 学校属性.
	def __init__(self):
		self.kongfu = '[黑马AI煎饼果子配方]'
	# 6. 学校行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
# 7. 徒弟类.
class Prentice(School, Master):
	# 8. 徒弟属性.
	def __init__(self):
		self.kongfu = '[独创煎饼果子配方]'
	# 9. 徒弟行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
	# 10. 调用父类的功能.
	def make_master_cakes(self):
		Master.__init__(self)
		Master.make_cake(self)
	def make_school_cake(self):
		School.__init__(self)
		School.make_cake(self)

# 11. 	创建徒弟类对象.
p = Prentice()
# 12. 访问属性.
print(p.konghfu)		# 独创
# 13. 调用函数.
p.make_cake()			# 独创
p.make_master_cake()	# 古法
p.make_school_cake()	# AI
p.make_cake()			# AI		 		

方法二: super().父类功能名()

实现思路

# 1. 老师傅类.
class Master:
	# 2. 老师傅属性.
	def __init__(self):
		self.kongfu = '[古法煎饼果子配方]'
		
	# 3. 老师傅行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
			
# 4. 黑马学校类.
class School:

	# 5. 学校属性.
	def __init__(self):
		self.kongfu = '[黑马AI煎饼果子配方]'
		
	# 6. 学校行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
		
# 7. 徒弟类.
class Prentice(School, Master):

	# 8. 徒弟属性.
	def __init__(self):
		self.kongfu = '[独创煎饼果子配方]'
		
	# 9. 徒弟行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
		
	# 10. 调用父类功能.
	def make_old_cake(self):
		super().__init__()
		super().make_cake()

# 11. 创建徒弟类对象.
p = Prentice()
# 12. 访问属性.
print(p.kongfu)			# 独创
# 13. 调用函数.
p.make_cake()			# 独创
p.make_old_cake()			# AI	
	

案例6: 多层继承

多层继承的定义

• 概述:
  • 类A继承类B, 类B继承类C, 这就是多层继承.
• 目前题设中的继承体系:
  • object <- Master, School <- Prentice <- TuSun

案例需求

n年后, 小明老了, 想要把"有自己的味道的独立品牌, 有黑马配方技术, 也有古法配方技术的煎饼果子的味道"的所有技术传授给自己的徒弟.

实现思路

1. 老师傅类.
2. 老师傅属性.
3. 老师傅行为.
4. 黑马学校类.
5. 黑马学校属性.
6. 黑马学校行为.
7. 徒弟类.
8. 徒弟属性.
9. 徒弟行为.
10. 调用父类的功能.
11. 创建徒孙类.
12. 创建徒孙类对象.
13. 调用功能.

# 1. 老师傅类.
class Master:
	# 2. 老师傅属性.
	def __init__(self):
		self.konghfu = '[古法煎饼果子配方]'

	# 3. 老师傅行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')

# 4. 黑马学校类.
class Student:
	# 5. 学校类属性.
	def __init__(self):
		self.konghfu = '[黑马AI煎饼果子配方]'
	
	# 6. 学校类行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')

# 7. 徒弟类.
class Prentice(School, Master):
	# 8. 徒弟属性.
	def __init__(self):
		self.kongfu = '[独创煎饼果子配方]'
		
	# 9. 徒弟行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')

	# 10. 调用父亲类的功能.
	def make_master_cake(self):
		Master.__init__(self)
		Master.make_cake(self)
	
	def make_school_cake(self):
		School.__init__(self)
		School.make_cake(self)

	
# 11. 创建徒孙类.
class TuSun(Prentice):
	pass
# 12. 创建徒孙类对象.
ts = TuSun()
# 13. 调用功能.
ts.make_cake()			# Prentice类的
ts.make_master_cake()	# Master类的
ts.make_school_cake()	# School类的			  
		
			
		

三, 总结

• Q1: 类的创建格式?
  • 格式一

class 类名:

- 格式二

class 类名():

- 格式三

	- class 类名(父亲名):

• Q2: 继承的功能?
  • 子类重写父类功能.
  • 子类重写父类功能后, 继续访问父类功能.
  • 多层继承.