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

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

一, 封装及其应用场景

封装的定义

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

封装的格式

__属性名
__属性名()

封装的好处和弊端

好处

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

弊端

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

封装的案例

案例需求

1. 定义师傅类Master.
2. 师傅类属性.
3. 师傅类行为.
4. 定义学校类School.
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 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.__moneydef 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. 要有继承.
• 2. 要有方法重写, 不然多态无意义.
• 3. 要有父类引用指向子类对象.

案例:

案例(1):动物案例

案例需求

动物类案例

实现思路

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

# 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): 构建战斗平台

案例需求

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

实现思路

1. 定义英雄机1代, 战斗力 60
2. 定义英雄机2代, 战斗力 80
3. 敌机1代
4. 构建对战平台, 公共的函数, 接收不同的参数, 有不同的效果 -> 多态.
5. 思路1: 不使用多态, 完成对战
6. 场景1: 英雄机1代 VS 敌机1代
7. 场景2: 英雄机2代 VS 敌机1代
8. 思路2: 使用多态, 完成对战
9. 场景1: 英雄机1代 VS 敌机1代
10. 场景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. 定义抽象类, 空调类, 设定: 空调的规则.
2. 制冷.
3. 制热.
4. 左右摆风.
5. 定义子类(小米空调), 实现父类(空调类)中的所有抽象方法.
6. 制冷.
7. 制热.
8. 左右摆风.
9. 定义子类(格力空调), 实现父类(空调类)中的所有抽象方法.
10. 制冷.
11. 制热.
12. 左右摆风.
13. 小米空调.
14. 格力空调.

# 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个名词, 用来描述事物的外在特征的.

分类:

• 对象属性: 属于每个对象, 即: 每个对象的属性值可能都不同. 修改A对象的属性, 不影响对象B.
• 类属性: 属于类的, 即: 能被该类下所有的对象所共享. A对象修改类属性, B对象访问的是修改后的.

对象属性

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

类属性

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

案例

案例需求

定义对象属性和类属性

实现思路

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

# 1. 定义1个 Student类, 每个学生都有自己的 姓名, 年龄.
class Student:# 2. 定义类属性.teacher_name = '水镜先生'# 3. 定义对象属性, 即: 写到 init 魔法方法中的属性.def __init__(self, name, age):self.name = nameself.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 = 40print(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个参数必须是 类对象, 而静态方法无参数的特殊要求.
2. 你可以理解为: 如果函数中要用 类对象, 就定义成 类方法, 否则定义成 静态方法, 除此外, 并无任何区别.

案例:

案例需求

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

实现思路

1. 定义学生类.
2. 定义类属性.
3. 定义类方法.
4. 定义静态方法.
5. 创建学生类对象.
6. 调用功能.

# 1. 定义学生类.
class Student:# 2. 定义属性类.school = '黑马程序员'# 3. 定义类方法.@classmethoddef show1(cls):print(f'cls: {cls}')			# <class '__main__.Student'>print(cls.school)print('我是类方法')# 4. 定义静态方法.@staticmetheddef show2():print(Student.scxhool)print('我是静态方法')# 5. 创建学生类对象.
s1 = Student()
s1.show1()
s1.show2()

五, 总结

• Q1: 封装的定义?

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

• Q2: 多态的定义?

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

• Q3: 对象属性的定义?

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

• Q4: 类属性的定义?

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

• Q5: 类方法的定义?

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

• Q6: 静态方法的定义?

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