Python教程8

Python教程8

　　1.多态

# -*-coding:utf-8-*-
"""
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码重用，相同的代码不需要重复编写
3.多态：不同的子类对象调用相同的父类方法，产生不同的执行结果
（多态可以增加代码的灵活度，以继承和重写父类方法为前提，是调用方法的技巧
不影响到类的内部设计）

"""


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()


# 创建狗对象
# waicai =Dog("旺财")
waicai = XiaoTianDog("旺财1")
# 创建人对象
xm = Person("小明")
# 调用和人玩的方法
xm.game_with_dog(waicai)

"""
术语：
创建出来的对象叫做类的实列
创建对象的动作叫实例化
对象的属性叫做实例属性
对象的调用方法叫做实例方法
两个说明：
1.每个对象都有自己独立的内存空间，保存各种不同的属性
2.每个对象的方法，在内存中只有一份，
在调用方法时，需要把对象的引用传递到方法的内部
"""

# 类对象
"""
类时一个特殊的对象，程序运行时，类同样会加载到内存。类对象在内存中只有一份，
使用一个类可以创建很多个对象实例，类对象还可以拥有自己的属性和方法。
类属性就是给类对象中定义的属性，通常用来记录这个类的相关特征，类属性不会用于记录剧吐的对象特征
"""


# 实例，定义一个工具类，每件工具都有自己的name，需求，指定使用这个类，创建多少个工具对象
class Tool(object):
    # 使用赋值语句定义类的属性
    count = 0

    def __init__(self, name):
        self.name = name
        Tool.count += 1  # 每次调用初始化方法都加1


tool1 = Tool("斧头")
print(Tool.count)
tool2 = Tool("榔头")
tool3 = Tool("扳手")
print(Tool.count)
print("----属性获取机制----")
print(Tool.count)  # 推荐
print("工具对象的总数: %d" % tool1.count)  # (不推荐)
print("工具对象的总数: %d" % tool3.count)  # （不推荐）
#  注意下三行
tool3.count = 99  # 在对象中找不到count属性，则会自动添加一个。和类属性不一样
print("工具对象的总数: %d" % tool3.count)
print("=====> %d" % Tool.count)

"""
类方法:
类方法需要修饰器@classmethod来标识
类方法的第一个参数是cls
"""


class Tool1(object):
    count1 = 10

    @classmethod  # 创建类方法,方法上方使用@classmethod
    def show_tool_count(cls):
        print("工具对象的数量%d" % cls.count1)

    def __init__(self, name):
        self.name1 = name
        Tool1.count1 += 1


toola = Tool1("斧头")
toola = Tool1("斧头1")
Tool1.show_tool_count()  # 调用类方法

"""
静态方法：
在开发时，如果需要在类中封装一个方法：
1.不需要访问实列属性或者调用实例方法
2.不需要访问类的属性或者调用类的方法
可以把方法封装成一个静态的方法

"""


class Dog1(object):
    @staticmethod  # 定义静态方法，在方法上使用@staticmethod
    def run():  # 注意静态方法没有参数
        print("小狗要跑跑....")


# dog1 = Dog1() #调用静态方法可以不创建对象
Dog1.run()

 　　2.综合案列

# -*-coding:utf-8-*-
"""
需求：
1.设计Game类
2.属性：
    定义一个类属性top_score记录游戏的历史最高分
    定义一个实例属性player_name记录当前游戏玩家姓名
3.方法：
    静态方法show_help显示游戏帮助信息
    类方法show_top_score显示历史最高分
    实列方法start_game开始当前玩家游戏
4.步骤
1.查看帮助信息
2.查看历史最高分
3.创建游戏对象，开始游戏
"""


class Game(object):
    top_score = 0

    def __init__(self, name):
        self.player_name = name

    @staticmethod
    def show_help():
        # 帮助信息
        print("------帮助信息--让僵死进入大门-----")

    @classmethod
    def show_top_score(cls):
        # 显示历史最高分
        print("显示历史记录最高分%d" % cls.top_score)

    def start_game(self):
        # 开始当前玩家游戏
        print("[%s]开始游戏啦.....!" % self.player_name)


# 1.查看游戏帮助信息
Game.show_help()
# 2.查看历史最高分
Game.show_top_score()
# 3.创建游戏对象
game = Game("小明")
game.start_game()

""""
几点说明：
1.实例方法--方法内部只需要访问实例属性
   (实例方法内部可以使用类名.访问类属性---同时访问实例属性和类属性)
2.类方法--方法内部只访问类属性
3.静态方法--方法内部，不需要访问实例属性和类属性
"""

 　　3.单例模式：

# -*-coding:utf-8-*-
"""
单例设计模式：
设计模式：
    时前人工作的总结和提炼，通常被人们广泛流传的设计模式都是针对某一特定问题的成熟解决方案
单例设计模式：
    让类创建对象，在系统中只有唯一的一个实例。
    每次执行类名（）返回对象，内存地址都是相同的
场景：
    音乐播放对象
    回收站对象
    打印机对象
"""
"""
__new__方法:
1.在使用类名（）创建对象时,python解释器会首先调用__new__方法为对象
  分配空间，返回对象的引用
2.获取对象的引用后，将引用作为第一个参数，传递给__init__方法

重写__new__方法的代码非常固定：
    重写__nw__方法一定要return super().__new__(cls),否则解释器得不到分配空
    间对象的引用，就不会电泳对象的初始化方法，其中__new__时一个静态的方法，在
    调用的时需要主动传递cls参数
"""


# __new__方法的重写
class MusicPlayer(object):
    def __new__(cls, *args, **kwargs):
        # 创建对象时，new方法会自动调用
        print("创建对象，分配空间")
        # 为对象分配空间
        instance = super().__new__(cls)  # 调用的父类方法
        # 返回对象的引用
        return instance

    def __init__(self):
        print("播放器初始化")


# 创建播放器对象
player = MusicPlayer()
print(player)

# 单列演示，不管创建多个对象，其对象的引用都是一样
print("单列演示，不管创建多个对象，其对象的引用都是一样-----")


class MusicPlayer1(object):
    # 定义类属性，记住第一个被创建的对象引用
    instance = None
    # 定义类属性，记录是否初始化动作
    init_flag = False

    def __new__(cls, *args, **kwargs):
        # 判断类属性是否为空
        if cls.instance is None:
            # 调用父类的方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)
        # 返回类属性保存的引用
        return cls.instance

    def __init__(self):
        # 判断是否执行过初始动作
        if MusicPlayer1.init_flag:
            return
        # 如果没有，则执行初始化
        print("初始化动作")
        # 修改属性的标记
        MusicPlayer1.init_flag = True


# 创建对象
player1 = MusicPlayer1()
print(player1)
player2 = MusicPlayer1()
print(player2)
# 创建了两次对象，虽然返回对象的引用时一个值，但使用一次类（）创建对象，则初始化执行一次
# 同样我们可以设置初始化标记。