python 面向对象

# 面向对象
"""
面向对象特点
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
"""

面向对象