目录
例会总结代码以及知识点
"""
类和对象
在程序中先有类，再有对象
"""
# 类
class lei: # 定义一个类需要用class关键字
# 类属性
school = 'fuyang'
# 对象的绑定方法
def __init__(self, name, age): # 初始化方法
self.name = name
self.age = age
# 这里定义一个查看数据的方法将对象的数据进行打印
def student_shuju(self):
print(f'年龄为{self.age}, {self.name}的学校是{self.school}')
# 对象
stu1 = lei('韩', 16)
stu1_school = lei.school
print(stu1_school)
stu1.student_shuju()
# #一切皆对象这里我把我要调用的模块看成类
# import a
# a.yanzheng()
# 封装主要有一个学习方面一个研究方面，学习将类的内部实现细节隐藏，提供有限的接口，研究封装是怎么封装的
# 学习方面
class fengzhuang:
def __init__(self, name, age):
self.__name = name # 我将姓名进行了封装也就是片面的隐藏
self.age = age
def chakan(self): # 定义一个查看隐藏属性的方法
print(self.__name)
# 实例化一个对象
man = fengzhuang('123456789', 12)
# man.name#因为被隐藏了不能直接查看需要用内部定义的查看方法
# 直接查看方法
print(man.__dict__)
# 用内部的查看方法
man.chakan() # 这里用类的里面的查看方法来查看
# 研究方面：封装就是变形了属性的名字，变形阶段是在内部发生的变形
# 假设我将一个文件的全部功能给写好同时封装起来用propetory方法进行封装起来然后一次性使用
# 我先来一个只进行了封装没有用propetory方式
class ruanjian:
def __wenjian1(self):
print('创建主要环境!')
def __wenjina2(self):
print('安装程序启动!')
def __wenjina3(self):
print('安装成功!')
def anzhuang(self): # 这里定义一个使用方法同时将这个方法变成属性来直接使用
self.__wenjian1()
self.__wenjina2()
self.__wenjina3()
yonghu = ruanjian()
yonghu.anzhuang() # 与下面的做对比
class ruanjian:
def __wenjian1(self):
print('创建主要环境!')
def __wenjina2(self):
print('安装程序启动!')
def __wenjina3(self):
print('安装成功!')
@property
def anzhuang(self): # 这里定义一个使用方法同时将这个方法变成属性来直接使用
self.__wenjian1()
self.__wenjina2()
self.__wenjina3()
yonghu = ruanjian()
yonghu.anzhuang # 这里是区别点，把它看成安装启动按钮就行了
"""
上面的代码和第一个代码几乎一样，但是有区别点，这就是property的作用点，将方法变成属性来调用。
这么理解封装就是将牛奶原料包装起来
内部方法就像吸管口给我们提供喝牛奶的地方
property则是给我们提供了吸管这个属性
"""
# 绑定方法的区分：没有装饰器(classmethod)装饰的方法或者staticmethod装饰的方法都是对象的绑定方法
# 类的绑定方法(classmethod)
# 这里以汽车为例子
class qichechang():
@classmethod # 它可以将类里面的方法变成类的绑定方法
def shuju(cls):
print('欢迎来到汽车维修厂这里有汽车x台')
class qiche(qichechang):
def __init__(self, name):
self.name = name
def jiasu(self):
print(f'{self.name}正在加速')
class weixiu():
@staticmethod
def weixiufangshi1():
print('该方法提供汽车通用螺丝刀')
@staticmethod
def weixiufangshi2():
print('该方法提供通用轮胎')
# 生成汽车实例对象
qiche = qiche('宝马')
qichechang.shuju()
qiche.shuju()# 类来调用类的绑定方法
# 使用对象的绑定方法加速
qiche.jiasu()
# 我用类名来调用静态方法
weixiu.weixiufangshi1()
# 我有类的实例来调用静态方法
gongju = weixiu
gongju.weixiufangshi1()
"""
上面的例子可以这么理解
对象的绑定方法就是我有了这个车，这个车我可以让它的按钮型号(对象的绑定方法)来加速，这个按钮只有它能用其它的车是用不了这个按钮的，这就体现了对象的绑定方法，谁绑定了谁用
类的绑定方法就像汽车厂，我可以设计不同的汽车，但是我要关心的是我如何造汽车已经汽车的库存，这与汽车的型号没有关系
静态方法就像通用工具，我可以给车拧螺丝也可以给汽车厂的内部螺丝进行加固，不受具体对象或类的限制
简洁就是对象的方法是特定在这个对象方法，类的方法就是工厂汽车的数量，静态方法就是通用工具，可以用于不同的情况
"""
# 多态和多态性
# 这里以快餐为例子
# 先来一个基础的类(快餐店)
class kuaican:
def speak(self):
print('请问你需要什么')
# 普通人类
class people(kuaican):
def speak(self):
kuaican.speak(self) # 这里穿插一下继承的调用的方式之一(直接调用就算不继承父类也可以使用)
print('我需要一个汉堡')
# 学生类
class student(kuaican):
def speak(self):
super().speak() # 用super来调用父类里的方法进行重用(用super来调用)
print('我需要炸鸡和可乐')
# 老板类
class laoban(kuaican):
def speak(self):
super().speak()
print('我需要一份披萨、炸鸡、汉堡、可乐')
# 生成一个普通人对象
people1 = people()
# 生成一个学生对象
stu1 = student()
# 生成一个老板对象
Boss = laoban()
# 这里创建一个函数来调用上面实例对象
def xuqiu(obj):
obj.speak()
xuqiu(people1)
xuqiu(stu1)
xuqiu(Boss)
"""
这个代码包含了多态和多态性的内容
多态就像快餐店的点餐口前有不同身份的人来点餐，这些人身份的类是不一样的这就是多态（可以简单理解为多种形态的类）
多态性就是无论我以什么身份来点餐，我都要在点餐口来点餐，这里的speak就是多态性的体现，多态性运行不同类型的对象(不同身份的类)都要使用同一个方法来点餐。
需要注意点有两个:第一个是多态是一个概念，而多态性是它的一种体现
第二点是多态的最终目的，从上面看好像我让这些人的编码遵循了我点餐的规范(这是一种片面的想法)，但是多态的最终目的并不是让代码变得遵守规范，多态的主要目的是实现接口抽象(这里还有所欠缺没有完全了解)和方法重用(上面有展示)
多态最核心的目的是提高代码的可维护性和扩展性，同时减少代码的重复编写(方法重用)
"""
# 组合这个概念在上次例会有讲过就是类中类
# 以上次例会的食物为例子
# 这里我先生成动物类
class Admin():
def __init__(self, name, tizhong, eat):
self.name = name
self.tizhong = tizhong
self.eat = eat
def xuze(self):
print(f'体重为{self.tizhong}的{self.name}喜欢吃{self.eat.eat}') # 第一个eat是实例对象，第二个eat是调用这个实例对象的方法
# 这里生成食物的类
class Eat():
def __init__(self, eat):
self.eat = eat
# 生成实例动物对象和食物对象
eat = Eat('小鱼干')
car = Admin('小猫咪', 10, eat) # 这里的eat是实例对象将其传参进去
# 调用类里面的方法
car.xuze()
eat = Eat('骨头')
dog = Admin('修勾', 20, eat)
dog.xuze()