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

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即为刘伟，调了两次，即都打印一样的值
'''

总结：今天主要讲了继承的多态，__new__魔术方法，已经单态模式

多态就是不同的子类对象，调用相同的父类方法，产生了不同的执行效果

魔术方法__new__ 触发时机，在实例化生成对象的时候触发(在__init__初始化之前)

主要功能控制对象的创建过程，参数至少一个cls接收当前类，返回值，通过返回对象或None

new方法的参数要和init方法参数一一对应，注意点，如果返回的不是本类对象，就不会触发__init__构造方法

单态模式就是无论实例化多少次，都有且只有一个对象

目的是为了节省内存空间，用在仅仅是为了调用类中的成员不需要额外给该对象添加任何成员这种场景，如操作数据库的增删改查。

语法首先定义一个类，类里面定义一个私有属性并赋值为None，在创建一个new方法，传入一个cls，写个if判断，判断这个私有

变量是否为None，为None就执行if语句下的代码块，用obj.__new__(cls)创建一个对象，最后return这个对象，调用处，无论实例化多少个对象，只创建一个对象，此时都指向同一个对象