# 面向对象
"""
面向对象特点
1.封装: 依据功能需求将某些属性与方法封装到一个类中
2.继承: 实现代码的重复调用，相同的功能调用不需要重复编写
3.多态: 不同的对象调用相同的类方法，产生不同的执行结果
面向对象的基本知识点
类: 描述具有相同的属性和方法的对象的集合,具有抽象性，不能直接使用,主要职责是创建对象
对象:通过类定义的，具有属性与方法的具体实例，可以使用
方法:类中定义的函数
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。
实例化：创建一个类的实例，类的具体对象。
在程序开发中，应该 先有类，再有对象
类和对象的关系: 类是模板，对象是根据类这个模板创建出来的 类只有一个，而对象可以有很多个
类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少
"""
# 类的设计
"""
类名 这类事物的名字，满足大驼峰命名法(每一个单词的首字母大写,单词与单词之间没有下划线)
属性 这类事物具有什么样的特征(对象的特征描述)
方法 这类事物具有什么样的行为(对象具有的行为)
"""
# 定义简单的类 只包含方法
"""
class 类名:
def 方法1(self, 参数列表):
pass
def 方法2(self, 参数列表):
pass
对象变量 = 类名()
类中定义方法第一个参数必须是self
在类封装的方法内部，self 就表示当前调用方法的对象自己
调用方法时，程序员不需要传递 self 参数
在方法内部 可以通过 self. 访问对象的属性 也可以通过 self. 调用其他的对象方法
"""
class P1:
def say(self):
print('你好')
a = P1()
a.say()
# 类的初始化
"""
当使用 类名() 创建对象时，会 自动 执行以下操作：
为对象在内存中 分配空间 —— 创建对象
为对象的属性 设置初始值 —— 初始化方法(__init__ )
"""
# 通过初始化方法在类的内部设置属性
class P2:
def __init__(self):
self.name = '小明'
def say(self):
print("你好%s" % self.name)
b = P2();
b.say()
# 通过初始化方法传参在类的内部设置属性
class P3:
def __init__(self, name):
self.name = name
def say(self):
print("你好%s" % self.name)
c = P3('小李');
c.say()
# 内置方法 __del__
"""
当使用类名()创建对象时，为对象分配完空间后，自动调用 __init__ 方法
当一个 对象被从内存中销毁前，会自动调用 __del__ 方法
生命周期:
一个对象从调用类名()创建，生命周期开始
一个对象的__del__方法一旦被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法
"""
class P4:
def __init__(self):
print('生命开始')
def __del__(self):
print('生命结束')
d = P4()
del d
# 内置方法 __str__
"""
使用 print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）
如果在开发中，希望使用 print 输出 对象变量时，能够打印 自定义的内容，就可以利用 __str__ 这个内置方法了
"""
class P5:
def __init__(self):
print("生命开始")
def __del__(self):
print("生命结束")
def __str__(self):
return "我是一个类"
e = P5()
print(e)
# 私有属性和私有方法
"""
在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
私有属性 就是对象不希望公开的属性
私有方法 就是对象不希望公开的方法
在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
并没有真正意义的私有 在名称 前面加上 _类名 => _类名__名称 可以访问到类的私有属性和方法
"""
class P6:
def __init__(self):
self.__age = 25
def __mimi(self):
print('秘密')
def say(self):
print("年龄是" % self.__age)
f = P6()
# print(f.__age) # 类的外部不能调用私有属性
# f.__mimi() # 类的外部不能调用私有方法
print(f._P6__age)
f._P6__mimi()
# 类的继承
"""
类的单继承
子类拥有父类的所有方法和属性
class 类名(父类名):
pass
子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据 职责，封装子类特有的属性和方法
继承的传递性
C类从B类继承，B类又从A类继承
那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
继承中的方法重写
当父类的方法实现不能满足子类需求时，可以对方法进行 重写(override)
重写 父类方法有两种情况：
1. 覆盖父类的方法: 如果在开发中，父类的方法实现和子类的方法实现，完全不同,就可以使用 覆盖 的方式，在子类中 重新编写 父类的方法实现
具体的实现方式，就相当于在 子类中 定义了一个 和父类同名的方法并且实现
2.对父类方法进行扩展 如果父类原本封装的方法实现是子类方法的一部分
在子类中重写父类的方法
在需要的位置使用super().父类方法 来调用父类方法的执行
代码其他的位置针对子类的需求，编写子类特有的代码实现
父类的私有属性和私有方法
子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法
"""
class Person:
def __init__(self, name):
self.name = name
self.__age = 25
def __mimi(self):
print('这是一个秘密')
def mimi(self):
print('这是一个秘密')
def say(self):
print("你好%s" % self.name)
def eating(self):
print('我最爱吃')
class Student(Person):
def run(self):
print(self.name)
# print(self.__age) # 子类不能调用父类的私有属性
self.mimi()
# self.__mimi() # 子类不能调用父类的私有方法
print('我跑的快')
def say(self):
print('我是小学生')
def eating(self):
super().eating()
print('%s也一样爱吃' % self.name)
class Stu(Student):
def __str__(self):
return '我爱python'
aa = Student('小明')
aa.say()
aa.run()
aa.eating()
bb = Stu('张飞')
bb.say()
bb.eating()
# 多继承
"""
类可以拥有多个父类，并且具有所有父类的属性和方法
class 子类名(父类名1, 父类名2...)
pass
如果不同的父类中存在同名的方法 依据继承顺序执行 当前类、继承第一个类、第二个类...
内置属性 __mro__ 用于在多继承时判断方法、属性的调用路径 查看 方法 搜索顺序
"""
class O1:
def test(self):
print('test...')
class O2:
def demo(self):
print('demo...')
def test(self):
print('...test....')
class O3(O1, O2):
def say(self):
print('say')
class O4(O2, O1):
def say(self):
print('say')
gg = O3()
gg.test()
gg.demo()
gg.say()
jj = O4()
jj.test()
# 多态 不同的子类对象 调用相同的父类方法，产生不同的执行结果
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍..." % self.name)
class XiaoTianDog(Dog):
def game(self):
print("%s 飞到天上去玩耍..." % self.name)
class Person(object):
def __init__(self, name):
self.name = name
def game_with_dog(self, dog):
print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))
# 让狗玩耍
dog.game()
# 1. 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")
# 2. 创建一个小明对象
xiaoming = Person("小明")
# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)
# 类属性和类方法
"""
封装实例的属性和方法外，类对象还可以拥有自己的属性和方法
通过类名. 的方式可以访问类的属性或者调用类的方法
类属性 就是给类对象中定义的属性
通常用来记录与这个类相关的特征
类属性不会用于记录具体对象的特征
属性的获取机制: 首先在对象内部查找对象属性、没有找到的情况下向上寻找类的属性
如果使用 对象.类属性 = 值 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值
"""
# 定义类属性
class P8:
count = 0 # 类属性
def __init__(self, name):
self.name = name
k = P8('小呢咋')
print(k.count) # 不推荐
print(P8.count) # 推荐
# 类方法和静态方法
"""
类方法 就是针对 类对象 定义的方法
在类方法内部可以直接访问类属性或者调用其他的类方法
类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
类方法的 第一个参数 应该是 cls
可以通过cls.访问类的属性
也可以通过cls.调用其他的类方法 不是对象方法
@classmethod
def 类方法名(cls):
pass
"""
class P10:
count = 0
def __init__(self, name):
self.name = name
def say(self):
print('你好')
@classmethod
def test(cls):
print('哈哈')
@classmethod
def show(cls):
print(cls.count)
cls.test()
mn = P10
P10.show()
# 静态方法
"""
静态方法
既不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
静态方法 需要用 修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法
@staticmethod
def 静态方法名():
pass
通过类名.调用静态方法
"""
class P20:
count = 0
def __init__(self, name):
self.name = name
@staticmethod
def run():
print('快跑')
P20.run()
# 单例
"""
目的是让类创建的对象，在系统中只有唯一的一个实例
每一次执行类名()返回的对象，内存地址是相同的
__new__ 方法
1) 在内存中为对象分配空间
2) 返回对象的引用
Python的解释器获得对象的引用后，将引用作为第一个参数，传递给__init__ 方法
Python的解释器获得对象的引用后，将引用作为第一个参数，传递给__init__ 方法
__new__ 是一个静态方法，在调用时需要主动传递cls参数
"""
# 示例
class MusicPlayer(object):
def __new__(cls, *args, **kwargs):
return super().__new__(cls)
def __init__(self):
print("初始化音乐播放对象")
player = MusicPlayer()
print(player)
# Python 中的单例
"""
定义一个类属性，初始值是None，用于记录单例对象的引用
重写__new__ 方法
如果类属性is None，调用父类方法分配空间，并在类属性中记录结果
返回类属性中记录的对象引用
"""
class MusicPlayer(object):
# 定义类属性记录单例对象引用
instance = None
def __new__(cls, *args, **kwargs):
# 1. 判断类属性是否已经被赋值
if cls.instance is None:
cls.instance = super().__new__(cls)
# 2. 返回类属性的单例引用
return cls.instance
# __init__ 对象初始化只被执行一次
"""
定义一个类属性 init_flag 标记是否 执行过初始化动作，初始值为 False
在 __init__ 方法中，判断 init_flag，如果为 False 就执行初始化动作
然后将 init_flag 设置为 True
这样，再次 自动 调用 __init__ 方法时，初始化动作就不会被再次执行 了
"""
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
# 记录是否执行过初始化动作
init_flag = False
def __new__(cls, *args, **kwargs):
# 1. 判断类属性是否是空对象
if cls.instance is None:
# 2. 调用父类的方法，为第一个对象分配空间
cls.instance = super().__new__(cls)
# 3. 返回类属性保存的对象引用
return cls.instance
def __init__(self):
if not MusicPlayer.init_flag:
print("初始化音乐播放器")
MusicPlayer.init_flag = True
# 创建多个对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
# 新式类
"""
object 是 Python 为所有对象提供的 基类，提供有一些内置的属性和方法
新式类：以 object 为基类的类，推荐使用
经典类：不以 object 为基类的类，不推荐使用
在 Python 3.x 中定义类时，如果没有指定父类，会 默认使用 object 作为该类的 基类
为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行 如果没有父类，建议统一继承自 object
class 类名(object):
pass
"""
面向对象
来源：https://www.cnblogs.com/ddf128/p/12014489.html