Python进阶 -- 面向对象编程③

目录

私有属性和私有方法

01. 应用场景及定义方式

应用场景

• 在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
• 私有属性就是对象不希望公开的属性
• 私有方法就是对象不希望公开的方法

定义方式

• 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

class Women:

    def __init__(self, name):

        self.name = name
        # 不要问女生的年龄
        self.__age = 18

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
# print(xiaofang.__age)

# 私有方法，外部不能直接调用
# xiaofang.__secret()

02. 伪私有属性和私有方法

提示：在日常开发中，不要使用这种方式，访问对象的 私有属性 或 私有方法

​​Python​​ 中，并没有 真正意义 的 私有

• 在给属性、方法命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
• 处理方式：在名称前面加上​​_类名​​​ =>​​_类名__名称​​

# 私有属性，外部不能直接访问到
print(xiaofang._Women__age)

# 私有方法，外部不能直接调用
xiaofang._Women__secret()

单例

01. 单例设计模式

• 设计模式

• 设计模式是前人工作的总结和提炼，通常，被人们广泛流传的设计模式都是针对某一特定问题的成熟的解决方案
• 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性

• 单例设计模式

• 目的—— 让类创建的对象，在系统中只有唯一的一个实例
• 每一次执行​​类名()​​ 返回的对象，内存地址是相同的

单例设计模式的应用场景

• 音乐播放对象
• 回收站对象
• 打印机对象
• ……

02. __new__ 方法

• 使用类名()创建对象时，​​Python​​ 的解释器首先会 调用​​__new__​​ 方法为对象分配空间
• ​​__new__​​​ 是一个 由​​object​​ 基类提供的内置的静态方法，主要作用有两个：

1. 在内存中为对象分配空间
2. 返回对象的引用

• ​​Python​​ 的解释器获得对象的引用后，将引用作为第一个参数，传递给​​__init__​​ 方法

重写 ​​__new__​​ 方法 的代码非常固定！

• 重写​​__new__​​ 方法一定要​​return super().__new__(cls)​​
• 否则 Python 的解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法
• 注意：​​__new__​​ 是一个静态方法，在调用时需要主动传递​​cls​​ 参数

示例代码

class MusicPlayer(object):

    def __new__(cls, *args, **kwargs):
        # 如果不返回任何结果，
        return super().__new__(cls)

    def __init__(self):
        print("初始化音乐播放对象")

player = MusicPlayer()

print(player)

03. Python 中的单例

• 单例—— 让类创建的对象，在系统中只有唯一的一个实例

1. 定义一个类属性，初始值是​​None​​，用于记录单例对象的引用
2. 重写​​__new__​​ 方法
3. 如果类属性​​is None​​，调用父类方法分配空间，并在类属性中记录结果
4. 返回类属性中记录的对象引用

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

只执行一次初始化工作

• 在每次使用​​类名()​​​ 创建对象时，​​Python​​ 的解释器都会自动调用两个方法：

• ​​__new__​​ 分配空间
• ​​__init__​​ 对象初始化

• 在上一小节对​​__new__​​ 方法改造之后，每次都会得到第一次被创建对象的引用
• 但是：初始化方法还会被再次调用

需求

• 让初始化动作只被执行一次

解决办法

1. 定义一个类属性​​init_flag​​ 标记是否执行过初始化动作，初始值为​​False​​
2. 在​​__init__​​​ 方法中，判断​​init_flag​​​，如果为​​False​​ 就执行初始化动作
3. 然后将​​init_flag​​​ 设置为​​True​​
4. 这样，再次自动调用​​__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)

多态

面向对象三大特性

1. 封装根据职责将属性和方法封装到一个抽象的类中

• 定义类的准则

2. 继承实现代码的重用，相同的代码不需要重复的编写

• 设计类的技巧
• 子类针对自己特有的需求，编写特定的代码

3. 多态不同的子类对象调用相同的父类方法，产生不同的执行结果

• 多态可以增加代码的灵活度
• 以继承和重写父类方法为前提
• 是调用方法的技巧，不会影响到类的内部设计

多态案例演练

需求

1. 在​​Dog​​​ 类中封装方法​​game​​

• 普通狗只是简单的玩耍

2. 定义​​XiaoTianDog​​​ 继承自​​Dog​​​，并且重写​​game​​ 方法

• 哮天犬需要在天上玩耍

3. 定义​​Person​​ 类，并且封装一个和狗玩的方法

• 在方法内部，直接让狗对象调用​​game​​ 方法

案例小结

• ​​Person​​ 类中只需要让狗对象调用​​game​​ 方法，而不关心具体是什么狗

• ​​game​​​ 方法是在​​Dog​​ 父类中定义的

• 在程序执行时，传入不同的狗对象实参，就会产生不同的执行效果

多态 更容易编写出出通用的代码，做出通用的编程，以适应需求的不断变化！

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)