Python学习笔记八 （多态，单例模式）

面向对象的三大特性

封装、继承、多态

• 封装

• 将方法和属性根据需求放在一起，构成一个类

• 有保护方法和属性的作用

• 继承

  • 当父类中的方法无法满足我们的需求，可以通过继承，然后重写其中的方法实现我们的需求
  • 主要作用是实现代码的复用（重用）
  • 遵守开闭原则，对修改关闭，对扩展开放

• 多态

  • 一个实例对象和一个类的不同实例对象合作可以产生不同的结果
  • 提高了方法的灵活性
  • 遵守里式替换原则，只要父类能出现的地方子类也可以出现，而且替换为子类不会产生任何错误或异常

---

多态

什么是多态？

一个实例对象和一个类的不同实例对象合作可以产生不同的结果

class User(object):
    def print_id(self):
        print("我是基类")


class VIPUser(User):
    def print_id(self):
        print("我是VIP用户")


class CommonUser(User):
    def print_id(self):
        print("我是普通用户")


class SellerUser(User):
    def print_id(self):
        print("我是商家用户")


class CheckPermission(object):
    def check_permission(self, user: User):
        user.print_id()


user = User()
vip_user = VIPUser()
common_user = CommonUser()
seller_user = SellerUser()

check = CheckPermission()

check.check_permission(user)
check.check_permission(vip_user)
check.check_permission(common_user)
check.check_permission(seller_user)

# 结果为：
# 我是基类
# 我是VIP用户
# 我是普通用户
# 我是商家用户 

---

类属性

类属性的作用

被类的实例对象所共享

和实例属性的区别

实例属性，对象与对象之间的属性相互独立，互不干扰。

class User(object):

    # 类属性，分私有和共有，共有可以被继承，
    user_addr = "我们都是DragonFang的fans"  # 不要脸le  hahaha

    def print_id(self):
        print("我是基类")


class VIPUser(User):
    def print_id(self):
        print("我是VIP用户") 

user = User() 
print(user.user_addr+"- " * 10)  # 对象名.类属性名 访问，不推荐
print(User.user_addr)  # 可以使用类名.类属性名 访问 ，推荐
print(VIPUser.user_addr)    # 共有类属性，可以被继承


# 结果为：
# 我们都是DragonFang的fans- - - - - - - - - - 
# 我们都是DragonFang的fans
# 我们都是DragonFang的fans

---

类方法

• 类对象所拥有的方法
• 需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。

class User(object):
    __user_addr = "我们都是DragonFang的fans"  # 真不要脸 hahaha
 
    @classmethod
    def get_user_addr(cls):
        return cls.__user_addr


user = User()
print(user.get_user_addr())  # 实例对象可以调用类方法，不推荐
print(User.get_user_addr())  # 类对象调用类方法，推荐

# 结果为：
# 我们都是DragonFang的fans
# 我们都是DragonFang的fans

---

静态方法

• 需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
• 静态方法 也能够通过 实例对象 和 类对象 去访问。

class User(object):
    __user_addr = "我们都是DragonFang的fans"  # 真不要脸 hahaha

    @staticmethod
    def show_user_addr():
        print(User.__user_addr)


user = User()
user.show_user_addr()  # 实例对象可以访问， 不推荐
User.show_user_addr()  # 类对象可以访问， 推荐

# 结果为：
# 我们都是DragonFang的fans
# 我们都是DragonFang的fans

---

魔法方法__new()__

• __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
• __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
• __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

用途：通过控制__new__方法的返回值，达到控制创建对象的目的

单例模式

在一个程序中一个类只有一个实例对象

创建基本单例模式

可以满足一个类只有一个对象的的基本要求

# 实例化一个单例
class Singleton(object):
    __instance = None

    def __new__(cls):
        # 如果类属性__instance的值为None，
        # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
        # 能够知道之前已经创建过对象了，这样就保证了只有1个对象
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance


a = Singleton()
b = Singleton()

# 通过id 查看对象在内存中的地址 ，如果地址相同则代表a、b为同一个对象
print(id(a))
print(id(b)) 

# 结果为：（每次运行的地址并不一样，但只要两者相等，就说明是同一对象）
# 2827427800008
# 2827427800008

上面这种写法有一个问题，一个类只有一个对象没问题，但是会进行多次初始化操作。

 
class Singleton(object):
    __instance = None

    def __new__(cls, *args, **kwargs): 
    
        print("new 方法 age：%d , name：%s" % args)
        
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        print("__init__ 方法 age：%d  " % age)
        self.age = age
        self.name = name


a = Singleton(18, "dongGe")
b = Singleton(8, "dongGe")

print(id(a))
print(id(b))
print(a.age)
print(b.age)


# 结果为： 
# new 方法 age：18 , name：dongGe  # 通过打印结果可以看出，__new__方法先执行，然后__init__方法执行 
# __init__ 方法 age：18            # 同时初始化对象的参数会传给__new__方法，也会传给__init__方法
# new 方法 age：8 , name：dongGe   
# __init__ 方法 age：8  
# 2537223055848
# 2537223055848
# 8  # 如果创建多个对象，后创建的对象的属性会覆盖掉先创建对象的属性值，这不是我们想要的结果，既然一个类
# 8  # 只能有对象，所以我们也想这个对象只初始化一次

 

解决多次初始化

# 实例化一个单例
class Singleton(object):
    __instance = None

    __is_fris_init = True  # 类属性，状态标记，默认为True，代表第一次初始化

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):

        if not Singleton.__is_fris_init:  # 不是第一次初始化，则不向下执行
            return

        print("__init__ 方法 age：%d  " % age)
        self.age = age
        self.name = name
        Singleton.__is_fris_init = False  # 第一次初始化完成，改变类属性的值


a = Singleton(18, "dongGe")
b = Singleton(8, "dongGe")

print(a.age)
print(b.age)

# 结果为：
# __init__ 方法 age：18 
# 18
# 18

---

到此结   DragongFang   2018.4.14