多态，new魔术方法，单态模式---day22

原创

wx62aaee4be59a4 2022-06-17 06:50:21 ©著作权

©著作权归作者所有：来自51CTO博客作者wx62aaee4be59a4的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.多态

# ### 多态：不同的子类对象，调用相同的父类方法，产生了不同的执行效果
'''
关键字：继承 改写
'''

class Soldier():
    #攻击
    def attack():
        pass
    
    #撤退
    def back():
        pass

#陆军
class Army(Soldier):
    def attack(self):
        print("[陆军]上来拼刺刀,你捅我我捅你,一刀999")
        
    def back(self):
        print("[陆军]撤退就跑")
        
#海军
class AirForce(Soldier):
    def attack(self):
        print("[空军]拿起二营长的意大利炮对敌方开展猛烈攻击")
    
    def back(self):
        print("[空军]弃机跳伞,落地成盒")
        
#实例化陆军,产生陆军士兵
obj_army = Army()

#实例化海军，产生海军士兵
obj_navy = Navy()

#实例化空军，产生空军士兵
obj_airforce = AirForce()


#各部分注意，等待将军的命令
lst = [obj_army,obj_navy,obj_airforce]

'''
1.全体出击
2.全体撤退
3.空军上,其他人撤
4.按q键退出
'''

sign = True
while sign:
    num = input("将军请下令:")
    
    for i in lst:
        if num == "1":
            i.attack()
        elif num == "2":
            i.back()
        elif num == '3':
            if isinstance(i,AirForce):
                i.attack()
            else:
                i.back()
        elif num.upper() == 'Q':
            print("将军,您辛苦了~")
            sign = False
            break
        else:
            print("风太大,我听不见!")
            break

2. __new__魔术方法

# ###  __new__ 魔术方法
'''
    触发时机:实例化类生成对象的时候触发(触发时机在__init__之前)
    功能:控制对象的创建过程
    参数：至少一个cls接受当前的类，其他根据情况决定
    返回值:通常返回对象或None
'''
#(1)基本语法
class MyClass():
    a = 1

other obj = MyClass()
print(other obj)

class MyClass1(object):
    def __new__(cls):
        print(cls)
        #(1) 借助父类object  类.方法()
        # obj = object.__new__(cls)
        # 返回本类自己的对象
        # return obj
        #(2) 返回其他类的对象
        # return other obj
        #(3)不返回任何对象
        return None
obj = MyClass1()
print(obj)
#print(obj.a)


#(2) new 方法触发时机要快于init
'''
__new__ 用来创建对象
__init__ 用来初始化对象(前提得有对象)
先创建对象，再去初始化对象，所以new快于init
'''
class Boat():
    def __init__(self):
        print(2)
    
    def __new__(cls):
        print(1)
        return object.__new__(cls)
obj = Boat()


#(3) new方法的参数要和init方法参数一一对应
#一个参数
class Boat():
    def __new__(cls,name):
        return object.__new__(cls)
    
    def __init__(self,name):
        self.name = name
        
obj1 = Boat('泰坦尼克号')
print(obj1.name)

#多个参数
class Boat():
    def __new__(cls,*args,**kwargs):
        return object.__new__(cls)
        
    def __init__(self,name,a,b,c,d,e):
        self.name = name
obj = Boat("泰坦尼克号",2,3,4,5,6)
print(obj.name)

#(4)注意点
'''如果返回的不是本类的对象，不会触发__init__构造方法'''
print("================")
class MyClass():
    a = 1
other_obj = MyClass()

class Boat():
    def __new__(cls):
        return other_obj
    
    def __init__(self):
        print("构造方法被触发")
obj = Boat()  #不会打印 "构造方法被触发"

3.单态模式

# ###  单态(例)模式：无论实例化多少次，都有且只有一个对象

'''
目的意义:
为了节省内存空间，仅仅是为了调用类中的成员
不需要额外给该对象添加任何成员，这个场景，使用单态
比如:操作数据库的增删改查这样的类，是不需要的
'''

#(1) 基本语法
class Singleton():
    __obj = None  #定义一个私有变量
    def __new__(cls):  #创建一个new方法
        if cls.__obj is None: #判断这个对象是否为None
            cls.__obj = obj.__new__(cls)  #为None 就创建一个对象
        return cls.__obj  #返回对象
'''
<__main__.Singleton object at 0x000001FB3F207278>
有这个对象直接返回，没这个对象，就给你创建，保证只有一个
第一次实例化时，if cls.__obj is None 条件为真，创建一个对象放到cls._obj,最后返回
第二次实例化时，if cls.__obj is None 条件为假 , 直接返回
第三次实例化时,if cls.__obj is None 条件为假 , 直接返回
第四次实例化时,if cls.__obj is None 条件为假 , 直接返回
'''
obj1 = Singleton()
print(obj1)
obj2 = Singleton()
print(obj2)
obj3 = Singleton()
print(obj3)
obj4 = Singleton()
print(obj4)


#(2) 单态模式 + 构造方法
class Singleton():
    __obj = None
    def __new__(cls,*args,**kwargs):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self,name):
        self.name = name
obj1 = Singleton('王振')
obj2 = Singleton('刘伟')
print(obj1.name)
print(obj2.name)

#解析:
'''
obj1 = Singleton('王振') self.name = "王振"
obj2 = Singleton('刘伟') self.name = '刘伟'
obj1 和 obj2 都是同时指向同一个对象，因为对象只创建了一个
对象.name  是获取最后那个指向的name即为刘伟，调了两次，即都打印一样的值
'''