面向对象(进阶)(‘封装‘,‘多态‘,‘对象属性‘,‘类属性‘,‘类方法‘,‘对象方法‘及其应用场景)

‘封装’,'多态’及其应用场景

一, 封装及其应用场景

封装的定义

属于面向对象的三大特征之一, 就是隐藏对象的属性和现实细节, 仅对外提供公共的访问方式.(我们学的函数, 类, 都是封装的体现).

封装的格式

__属性名
__属性名()

封装的好处和弊端

好处

提高代码的安全性. 由私有化来保证
提高代码的的复用性. 由函数来保证

弊端

代码量增加了. 因为私有的内容外界想访问, 必须提供公共的访问方式, 代码量就增加了.

封装的案例

案例需求

定义师傅类Master.
师傅类属性.
师傅类行为.
定义学校类School.
学校类属性.
学校类行为.
定义徒弟类(包含私房钱).
徒弟类属性.
徒弟类行为.
针对私有的属性, 提供公共的访问方式 (包含’获取’和’设置’).
定义徒孙类.
创建徒孙类对象.
调用功能.

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

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

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

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

# 7. 定义徒弟类(包含私房钱).
class Prentice:
	# 8. 徒弟类属性.
	def __init__(self):
		self.kongfu = '[独创煎饼果子配方]'
		# 私房钱.
		self.__money = 20000
	# 9. 徒弟类行为.
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
	# 10. 针对私有的属性, 提供公共的访问方式.
	def get_money(self):			# 获取	
		return self.__money
	def set_money(self, money):		# 设置
		self.__money = money		

# 11. 定义徒孙类.
class TuSun(Prentice):
	pass

# 12. 创建徒孙类对象.
ts = TuSun()
# 13. 调用功能.
perint(ts.kongfu)
ts.make_cake()
# print(ts.__money)		# 报错, 父类私有成员, 子类无法访问.
ts.set_money(100)
print(ts.get_money())	# 通过父类提供的公共的访问方式, 访问父类的私有成员.

二, 多态及其应用案例

多态的定义

同一个函数, 接收不同的参数, 有不同的效果.
同一个事物在不同时刻表现出来的不同状态, 形态

多态的前提条件

1. 要有继承.
1. 要有方法重写, 不然多态无意义.
1. 要有父类引用指向子类对象.

案例:

案例(1):动物案例

案例需求

动物类案例

实现思路

定义动物类(抽象类(也叫:接口)在其内定义抽象方法).
定义子类, 狗类.
定义子类, 猫类.
汽车类.
定义函数, 接收不同的动物对象, 调用speak方法.
创建狗类, 猫类对象.
演示多态.
测试汽车类

# 1. 定义动物类(抽象类(也叫:接口)在其内定义抽象方法).
class Animal:			# 抽象类(也叫: 接口)
	def speak(self):	# 抽象方法
		pass

# 2. 定义子类, 狗类.
class Dog(Animal):
	def speak(self):
		print('狗叫: 汪汪汪')

# 3. 定义子类, 猫类.
class Cat(Animal):
	def speak(self):
		print('猫叫: 喵喵喵')

# 4. 定义汽车类.
class Car:
	def speak(self):
		print('车叫: 滴滴滴')

# 5. 定义函数, 接收不同的动物对象, 调用speak方法
def make_noise(an:Animal):		# an:Animal = Dog()
	an.speak()

# an:Animal = Dog()			# 父类引用指向子类对象(标准用法).
# d:Dog = Dog()				# 创建狗类对象.	
# 6. 创建狗类, 猫类对象.
d = Dog()
c = Cat()
# 7. 演示多态. 		
make_noise(d)
make_noise(c)

# 8. 测试汽车类
c = Car()
make_noise(c)

案例(2): 构建战斗平台

案例需求

构建对战平台(公共的函数) object_play(), 接收: 英雄机和敌机.
在不修改对战平台代码的情况下, 完成多次战斗.
规则:
- 英雄机, 1代战斗力60, 2代战斗力80
- 敌机, 1代战斗力70
代码提示:
- 英雄机1代 HeroFighter
- 英雄机2代 AdvHeroFighter
- 敌机 EnemyFighter

实现思路

定义英雄机1代, 战斗力 60
定义英雄机2代, 战斗力 80
敌机1代
构建对战平台, 公共的函数, 接收不同的参数, 有不同的效果 -> 多态.
思路1: 不使用多态, 完成对战
场景1: 英雄机1代 VS 敌机1代
场景2: 英雄机2代 VS 敌机1代
思路2: 使用多态, 完成对战
场景1: 英雄机1代 VS 敌机1代
场景2: 英雄机2代 VS 敌机1代

# 1. 定义英雄机1代, 战斗力 60
class HeroFighter:
	def power(self):
		return 60

# 2. 定义英雄机2代, 战斗力 80
class AdvHeroFighter(HeroFighter):
	def power(self):
		return 80

# 3. 敌机1代
class EnemyFighter:
	def power(self):
		return 70

# 4. 构建对战平台, 公共的函数, 接收不同的参数, 有不同的效果 -> 多态.
def object_play(hero, enemy):
	# 参1: 英雄机, 参2: 敌机
	if hero.power() >= enemy.power():
		print('英雄机 战胜 敌机!')
	else:
		print('英雄机 惜败 敌机!')

# 思路1: 不使用多态, 完成对战.
# 场景1: 英雄机1代 VS 敌机1代
h1 = HeroFighter()
e1 = EnemyFighter()
if h1.power() >= e1.power():
	print('英雄机1代 战胜 敌机1代')
else:
	print('英雄机1代 惜败 敌机1代')
# 场景2: 英雄机2代 VS 敌机1代
h2 = AdvHeroFighter()
e1 = EnemyFighter()
if h2.power() >= e1.power():
	print('英雄机2代 战胜 敌机1代')
else:
	print('英雄机2代 惜败 敌机1代')

# 思路2: 使用多态, 完成对战.
h1 = HeroFighter()
h2 = AdvHeroFighter()
e1 = EnemyFighter()
# 场景1: 英雄机1代 vs 敌机1代
object_play(h1, e1)
# 场景2: 英雄机2代 VS 敌机1代
object_play(h2,e1)

案例(3): 空调案例

抽象类的定义

概述:
- 在Python中, 抽象类 = 接口, 即 : 有抽象方法的类就是抽象类, 也叫接口.
抽象方法 = 没有方法体的方法, 即: 方法体是 pass 修饰的.
作用/目的:
- 抽象类一般充当父类, 用于指定行业规范, 准则, 具体的实现交由子类来完成.

案例需求

实现思路

定义抽象类, 空调类, 设定: 空调的规则.
制冷.
制热.
左右摆风.
定义子类(小米空调), 实现父类(空调类)中的所有抽象方法.
制冷.
制热.
左右摆风.
定义子类(格力空调), 实现父类(空调类)中的所有抽象方法.
制冷.
制热.
左右摆风.
小米空调.
格力空调.

# 1. 定义抽象类, 空调类, 设定: 空调的规则.
class AC:
	# 2. 制冷.
	def cool_wind(self):
		pass
	# 3. 制热.
	def hot_wind(self):
		pass
	# 4. 左右摆风
	def swing_l_r(self):
		pass
# 5. 定义子类(小米空调), 实现父类(空调类)中的所有抽象方法.
class XiaoMi(AC):
	# 6. 制冷.
	def cool_wind(self):
		print('小米 核心 制冷技术!')
	# 7. 制热.
	def hot_wind(self):
		print('小米 核心 制热技术!')
	# 8. 左右摆风.
	def swing_l_r(self):
		print('小米空调 静音左右摆风 计数!')

# 9. 定义子类(格力空调), 实现父类(空调类)中的所有抽象方法.
class Gree(AC):
	# 10. 制冷.
	def cool_wind(self):
		print('格力 核心 制冷技术!')
	# 11. 制热.
	def hot_wind(self):
		print('格力 核心 制热技术!')
	# 12. 左右摆风.
	def swing_l_r(self):
		print('格力空调 低频左右摆风 技术!')

# 16. 小米空调.
xm = XiaoMi()
xm.cool_wind()
xm.hot_wind()
xm.swing_l_r()

# 17. 格力空调.
gree = Gree()
gree.cool_wind()
gree.hot_wind()
gree.swing_l_r()

‘对象属性’, ‘;类属性’, ‘类方法’, '静态方法’及其应用场景

三, '对象属性’和’类属性’及其应用场景

图解

在这里插入图片描述

属性的定义

概述:

属性是1个名词, 用来描述事物的外在特征的.

对象属性

定义到 init 魔法方法中的属性, 每个对象都有自己的内容.
只能通过对象名. 的方式调用.

类属性

定义到类中, 函数外的属性(变量), 能被该类下所有的对象所共享.
既能通过类名. 还能通过对象名. 的方式来调用, 推荐使用类名. 的方式.

案例

案例需求

定义对象属性和类属性

实现思路

定义1个 Student类, 每个学生都有自己的姓名, 年龄.
定义类属性.
定义对象属性, 即: 写到 init 魔法放法中的属性.
定义str魔法方法, 输出对象的信息.
场景1: 对象属性.
修改s1的属性值.
场景2: 类属性.
类属性可以通过类名. 还可以通过对象名. 的方式调用.
尝试用对象名. 的方式来修改类属性.
10.如果要修改类变量的值, 只能通过类名. 的方式来实现.

# 1. 定义1个 Student类, 每个学生都有自己的 姓名, 年龄.
class Student:
	# 2. 定义类属性.
	teacher_name = '水镜先生'
	# 3. 定义对象属性, 即: 写到 init 魔法方法中的属性.
	def __init__(self, name, age):
		self.name = name
		self.age = age
	# 4. 定义str魔法方法, 输出对象的信息.
	def __str__(self):
		return '姓名: %s, 年龄: %d' % (self.name, self.age)
# 5. 场景1: 对象属性
s1 = Student('曹操', 38)
s2 = Student('曹操', 38)

# 6. 修改s1的属性值.
s1.name = '许褚'
s1.age = 40

print(f's1: {s1}')
print(f's2: {s2}')

# 7. 场景2: 类属性.
# 8. 类属性可以通过 类名.	还可以通过 对象名. 的方式调用.
print(s1.teacher_name)			# 水镜先生
print(s2.teacher_name)			# 水镜先生
print(Student.teacher_name)			# 水镜先生

# 9. 尝试用 对象名. 的方式来修改 类属性.
# s1.teacher_name = '夯哥'		# 只能给s1对象赋值, 不能给属性赋值.

# 10. 如果要修改类变量的值, 只能通过	类名. 的方式实现.
Student.teacher_name = '夯哥'
print(s1.teacher_name)				# 夯哥
print(s2.teacher_name)				# 夯哥
print(Student.teacher_name)				# 夯哥

四, '类方法’和’静态方法’及其应用场景

类方法定义:

属于类的方法, 可以通过类名. 还可以通过对象名. 的方式来调用.
定义类方法的时候, 必须使用装饰器 @classmethod , 且第1个参数必须表示 类对象.

静态方法定义:

属于该类下所有对象所共享的方法, 可以通过类名. 还可以通过对象名. 的方式来调用.
定义静态方法的时候吗必须使用装饰器 @staticmetgod , 且参数传不传都可以.

区别:

类方法的第1个参数必须是类对象, 而静态方法无参数的特殊要求.
你可以理解为: 如果函数中要用类对象, 就定义成类方法, 否则定义成静态方法, 除此外, 并无任何区别.

案例:

案例需求

定义类方法和静态方法, 并调用

实现思路

定义学生类.
定义类属性.
定义类方法.
定义静态方法.
创建学生类对象.
调用功能.

# 1. 定义学生类.
class Student:
	# 2. 定义属性类.
	school = '黑马程序员'
	# 3. 定义类方法.
	@classmethod
	def show1(cls):
		print(f'cls: {cls}')			# <class '__main__.Student'>
		print(cls.school)
		print('我是类方法')

	# 4. 定义静态方法.
	@staticmethed
	def show2():
		print(Student.scxhool)
		print('我是静态方法')

# 5. 创建学生类对象.
s1 = Student()
s1.show1()
s1.show2()

五, 总结

Q1: 封装的定义?
- 属于面向对象的三大特征之一, 就是隐藏对象的属性和现实细节, 仅对外提供公共的访问方式.(我们学的函数, 类, 都是封装的体现).
Q2: 多态的定义?
- 同一个函数, 接收不同的参数, 有不同的效果.
- 同一个事物在不同时刻表现出来的不同状态, 形态
Q3: 对象属性的定义?
- 定义到 init 魔法方法中的属性, 每个对象都有自己的内容.
- 只能通过对象名. 的方式调用.
Q4: 类属性的定义?
- 定义到类中, 函数外的属性(变量), 能被该类下所有的对象所共享.
- 既能通过类名. 还能通过对象名. 的方式来调用, 推荐使用类名. 的方式.
Q5: 类方法的定义?
- 属于类的方法, 可以通过类名. 还可以通过对象名. 的方式来调用.
- 定义类方法的时候, 必须使用装饰器 @classmethod , 且第1个参数必须表示 类对象.
Q6: 静态方法的定义?
- 属于该类下所有对象所共享的方法, 可以通过类名. 还可以通过对象名. 的方式来调用.
- 定义静态方法的时候吗必须使用装饰器 @staticmetgod , 且参数传不传都可以.