面向对象特性
面向对象的三大特性：封装、继承、多态
1 封装 根据职责将属性和方法封装到一个抽象的类中
2 继承 实现代码的重用，相同的代码不需要重复的编
面向对象特性
面向对象的三大特性：封装、继承、多态
1. 封装 根据职责将属性和方法封装到一个抽象的类中
2. 继承 实现代码的重用，相同的代码不需要重复的编写
3. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
01-单继承
1.1 继承语法
子类继承父类，拥有父类的所有属性和方法，开发时只需要根据职责在子类中封装子类独有的属性和方法即可
class 类名（父类名）
若C类从B类继承，B类从A类继承，那么C类具有B类和A的所有属性和方法
子类=派生类，父类=基类，继承=派生
1.2 方法的重写
如果父类的方法无法满足子类的需求，可以对方法进行重写，重写情况有两种，分别为覆盖父类的方法，对父类方法的扩展
覆盖：在子类中重新定义一个和父类同名的方法进行实现，这样运行时只会调用子类的方法，而不会调用父类的方法
扩展：父类的方法只是子类的一部分，就可以先对子类进行重写，在需要父类功能的地方使用 super().父类方法 进行调用
super().父类方法 可以理解为对父类方法的全部继承
eg:super().bark()
# 另一种方式
父类名.父类方法(self)
Dog.run(self)
注意：父类名和super()不可混用，且不可使用当前子类名调用当前方法，否则会陷入递归调用，出现死循环
# 错误案例
class Dog:
def bark(self):
print("吠")
Dog.bark(self)
1.3 父类的私有属性和方法
和之前的私有属性和私有方法一致，子类和子类的对象无法通过直接方法访问父类的私有属性和方法，父类的对象也无法直接访问父类的私有属性和方法
但仍可以用间接的方法访问，可用间接方法于子类方法的继承和父类对象的调用
# 子类继承父类的私有方法
class Father:
def __way(self):
print("This is father's private property.")
class Son(Father):
def __way(self):
super()._Father__way()
# 父类对象调用父类私有方法
father = Father()
father._Father__way()
# 无限套娃——子类对象调用子类私有方法且子类私有方法调用父类私有方法
son = Son()
son._Son__way()
注意：实际开发中同样不推荐
02-多继承
2.1 多继承的使用和注意事项
一个子类可以有多个父类进行继承
class 子类名(父类1, 父类2, ...)
如果不同子类存在同名方法，会按照父类顺序进行查找，找到了就直接返回
class Father_1:
def hello(self):
print("hello world")
class Father_2:
def hello(self):
print("hello python")
class Son(Father_1, Father_2):
def say_hello(self):
super().hello()
son = Son()
son.say_hello()
# 在这里输出的就是hello world
2.2 Python中的方法搜索顺序
可以使用 类名.mro() 的方法查询方法的搜索顺序，也可以在多继承时判断方法、属性的调用路径
# 以上述为例
print(Son.mro())
# 输出结果：[<class '__main__.Son'>, <class '__main__.Father_1'>, <class '__main__.Father_2'>, <class 'object'>]
所以我们也可以看出来多继承的执行顺序是先查找当前类，再查看父类1，再看父类2，最后再去object类，找不到才会报错
2.3 新式类与旧式类
在python 2.x 版本中定义类，如果没有指定父类，则默认不使用object类（object类是所有类的父），需要使用自己打
在python 3.x 版本中定义类，如果没有指定父类，则默认使用object类，即可以调用__str__， __init__ 等方法
如果为了让代码在python 2.x和python 3.x中同时运行，建议没有父类时统一继承object类
class 类名(object)
03-多态
通过不同的子类对象，调用相同的父类方法，产生不同的执行结果，就是多态
多态的目的就是提升代码的灵活性，相当于父类的方法是这类方法的主体框架，子类只需要根据不同的对象需求进行调整，对相同功能的父类代码进行继承与重写
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))
# xiaohu = Dog("旺财")
# xiaohu.game()
xiaohu = XiaoTianDog("飞天旺财")
xiaohu.game()
xiaoming = Person("小明")
xiaoming.game_with_dog(xiaohu)
在这里我们可以看到，虽然都是game方法，但是由于是由不同的子类产生的不同的对象，且game方法在不同的子类中已经进行了重写，所以产生了不同的结果
03-类属性和类方法
3.1 类的结构
在面向对象的开发中，首先需要创建类；在创建类后，通过 类名() 创建对象，称为类的实例化，创建出来的对象称为实例
对象的属性称为实例属性，对象调用的方法称为实例方法
对象拥有自己的实例属性，并且可以用 self 调用自己的方法和属性或者其他的对象方法
每一个对象都有自己的独立内存，保存着各自的属性，但是多个对象的方法在内存中只有一份，调用时是需要将对象的引用传递到方法内部的self
3.2 类对象
类是一个特殊的对象，称为类对象，在程序运行时也会被加载到内存，且仅有一份，通过类对象可以创建出实例对象
类对象有自己的属性和方法，称为类方法和类属性，通过 类名.属性/类名.方法 进行调用，该类的所有对象都可以通过类名直接访问
3.3 类属性和实例属性
类属性是给类对象定义的属性，记录这个类相关的特征，并不会影响到具体对象的特征，直接在类名下使用赋值语句即可，调用是使用 类名.类属性 进行调用
class Tool(object):
count = 0
def __init__(self, name):
self.name = name
Tool.count += 1
由于python对于属性的获取有向上查找的机制，即在当前对象找不到属性会向上寻找类属性，所以还可以使用 对象名.类属性 进行调用，但并不推荐
注意：对象.类属性 = 值 的赋值语句只会给对象添加属性，而不会改变类属性的值
tieqiao.count = 0
print(tieqiao.count)
print(Tool.count)
3.4 类方法和静态方法
3.4.1 类方法
类方法是针对类定义的方法，可在类方法内直接访问类属性或者调用其他类方法
@classmethod
def 类方法(cls):
pass
类方法要用@classmethod来修饰，第一个参数任意，习惯使用cls，可以理解为实例方法的self，cls调用的方法是当前类的引用
使用类方法是，不需要传入cls参数，直接 类名. 即可；在方法内部，可以通过 cls. 访问类属性和其他类方法
3.4.2 静态方法
如果在类中封装的方法既不需要访问实例属性和实例方法，也不需要访问类属性和类方法，就可以封装成静态方法，通过 类名. 调用静态方法
@staticmethod
def 静态方法():
pass
3.4.3 案例示范
需求：
1.设计一个 Game 类
2.属性：①定义一个 类属性 top_score 记录游戏的 历史最高分
②定义一个 实例属性 player_game 记录 当前游戏的玩家姓名
3.方法：①静态方法 show_help 显示游戏帮助信息
②类方法 show_top_score 显示历史最高分
③实例方法 start_game 开始当前玩家的游戏
4.主程序步骤：①查看帮助信息
②查看历史最高分
③创建游戏对象，开始游戏
class Game(object):
top_score = 0
def __init__(self, player_name):
self.player_name = player_name
def start_game(self):
print("开始游戏...")
Game.top_score = 999
@classmethod
def show_top_score(cls):
print("最高分是%d" % cls.top_score)
@staticmethod
def show_help():
print("This is help.")
Game.show_help()
Game.show_top_score()
xiaoming = Game("小明")
xiaoming.start_game()
Game.show_top_score()
04-单例
单例是为了让类创建的对象，在系统中只有唯一的一个实例，每一次执行 类名() 返回的对象，内存地址是相同的
如音乐播放器，每次只能播放一首歌曲，每一个歌曲（实例）在结束（返回）后都返回相同的内存地址，以便下一首歌的播放
4.1 __new__ 方法
使用 类名() 创建对象的时候，首先使用object类内置的静态方法__new__来分配空间，并返回对象的引用到python解释器，解释器接收到
对象的引用后，将引用作为参数传递给__init__方法，由它进行对象的初始化并定义实例属性
而为了达到单例设计模式，需要对__new__方法进行重写，使得无论执行多少次，返回相同的内存地址，使得只创建一个对象实例
4.2 重写 __new__ 方法
重写 __new__ 方法需要在最后加上 return super().__new__(cls) 来返回内存地址，否则python解释器得不到对象引用就无法进行对象的初始化
def __new__(cls, *args, **kwargs):
print("创建对象，分配空间")
# 在object类中，默认有实现分配内存空间的功能，所以只需要用super()调用父类方法即可，并在 return 中返回
return super().__new__(cls)
注意：__new__方法是一个静态方法，需要主动传递cls参数
4.3 Python中的单例
4.3.1 实现单例的相同引用
定义一个类属性(instance)，初始值定为None，用于记录单例对象的引用，同时重写__new__方法
刚开始定义对象实例时，调用父类__new__方法分配空间，并返回，之后的定义跳过分配空间，直接使用原引用，实现单例
class MusicPlayer(object):
instance = None
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = super().__new__(cls)
return cls.instance
def __init__(self, name):
self.name = name
player1 = MusicPlayer("1")
player2 = MusicPlayer("2")
print(player1)
print(player2)
可以发现这里即使名字不一样，引用也是相同的
4.3.2 实现单例的一次初始化
4.3.1实现了相同引用，但是每次还要初始化，略显冗杂，先仿照上述方法对__init__方法进行修改，同样定义一个用来记录初始化的类属性(init_flag)，初始值为False
def __init__(self):
if not MusicPlayer.init_flag:
print("初始化")
MusicPlayer.init_flag = True
