一、封装
封装：就是把属性和方法封装到一个抽象的类中。
1.调用方法
代码如下（示例）：
class Student():
def study(self,course_name):
print(f'学生正在学习{course_name}')
def play(self):
print('学生正在玩游戏')
stu1 = Student()
stu2 = Student()
stu1.study('python')
#调用类方法，需要对类进行实例化
Student().study('Java')
2.初始化方法
- init()方法： （下划线无法显示）创建对象时，会在内存中获得保存对象所需的内存空间，然后自动执行初始化方法，完成内存的初始化方法。简而言之，就是在创建对象时为对象绑定属性并赋初值。
- 调用： 属性用self进行调用，参数直接调用
3.属性装饰器
代码如下（示例）：
#属性装饰器
class Student():
def __init__(self,name,age):
#创建私有属性
self.__age = age
self.__name = name
#获取私有属性
@property
def name(self):
return self.__name
#修改私有属性
@name.setter
def name(self,name):
self.__name=name or 'unknown'
@property
def age(self):
return self.__age
def study(self,course_name):
print(f'{self.__name}正在学习{course_name}')
stu3=Student('王大锤',50)
print(stu3.name,stu3.age)
4.方法
- 静态方法： 调用时，不需要对类进行实例化，可以直接使用：类名.方法()
- 静态方法vs类方法：
1.参数： 静态传参——参数，类方法传参——第一个必须是cls
2.函数： 静态方法不和当前类绑定，可以看做一个单独的函数，类方法代表当前的方法属于当前的类
3.调用： 静态方法不需要创建对象就可以调用，类方法不可以通过实例对象进行调用，实例方法也不可以通过类对象调用。
二、继承
继承：就是实现代码的复用，相同的代码不需要重复的编写。
1.继承语法
代码如下（示例）：
class 类名(父类名)：
pass
2.方法的重写
子类想增加新功能，而父类不能修改功能时，可使用方法重写。
class Dog():
def bark(self):
print('bark!')
class Xiaotianquan(Dog):
def fly(self):
print("fly!")
#方法的重写
def bark(self):
print('bark as a god!')
3.调用父类方法
调用父类方法有以下两种方式：
class Xiaotianquan(Dog):
def fly(self):
print("fly!")
def bark(self):
print('bark as a god!')
#调用父类方法1,super()是个对象
super().bark()
#调用父类方法2
Dog.bark(self)
三、多态
多态是不同子类对象调用相同的父类方法，产生不同的执行结果。
class A:
def work(self):
print('人类需要工作')
class B(A):
def work(self):
print('程序员在工作--------------代码')
class C(A):
def work(self):
print('设计师在工作--------------图纸')
b=B()
c=C()
b.work()
c.work()
四、单例设计模式
这是让类创建的对象，在系统中只有唯一的一个实例并且内存地址是相同的。只初始化一次的到单例设计模式实现代码如下所示：
class MusicPlayer:
instance = None
init_Flag = False
def __new__(cls) :
if cls.instance is None:
cls.instance = super().__new__(cls)
return cls.instance
def __init__(self):
if MusicPlayer.init_Flag:
return
print('初始化中....')
MusicPlayer.init_Flag=True
player1 = MusicPlayer()
player2 = MusicPlayer()
print(player1,player2)