10.1私有屬性和私有方法

class Dog(object):

    def __init__(self):
        self.__age = 10  # 在屬性名前面加倆下劃線，將屬性私有化，這個屬性稱為私有屬性（一般不允許物件來訪問修改這個屬性）

    # def __fn(self):
    #     print("私有方法")

    def get_age(self):
        return self.__age

    def set_age(self, num):
        if 0 < num <= 22:
            self.__age = num


dog = Dog()
# dog.age = 111

# print(dog.__age)
# dog.fn()
# print(dog.get_age())
dog.set_age(30)
print(dog.get_age())
 

10.2 共有屬性的繼承問題

class Animal(object):

    def __init__(self):
        self.age = 10
        self.num = 200


class Dog(Animal):

    def __init__(self):  # 屬性是寫在init初始化方法裡面的，一旦子類定義了這個init方法，就會把父類的init方法重寫了， 導致了dog = Dog()在呼叫init方法的時候，呼叫的是子類的init方法
        super().__init__()   # 在初始化中的super().__init__() 的時候，把這句程式碼寫在最前
        self.name = "狗"
        self.num = 300

    # pass

dog = Dog()
print(dog.name)
print(dog.age)
print(dog.num)
 

10.3 私有屬性的繼承問題

"""
公有屬性可以繼承到子類，只是要注意重寫init方法的問題
我們認為私有屬性不繼承
"""


class Animal(object):

    def __init__(self):
        self.__age = 10
        self.num = 200

# ani = Animal()
# print(ani._Animal__age)   # 瞭解


class Dog(Animal):

    def __init__(self):  # 屬性是寫在init初始化方法裡面的，一旦子類定義了這個init方法，就會把父類的init方法重寫了， 導致了dog = Dog()在呼叫init方法的時候，呼叫的是子類的init方法
        super().__init__()   # 在初始化中的super().__init__() 的時候，把這句程式碼寫在最前
        self.name = "狗"
        self.num = 300

    # pass

dog = Dog()
print(dog.name)
print(dog.__age)  # 操作
print(dog.num)
 

10.4多型

"""

面嚮物件語言的三大特性： 封裝、繼承、多型


多型： 一種事物多種形態  （前提：子類是父類的另外一個形態）
"""


class A(object):
    def say(self):
        print("---Asay")


class B(object):
    def say(self):
        print("---Bsay")


class C(object):
    def say(self):
        print("---Csay")


def fn(obj):
    obj.say()

a = A()
b = B()
c = C()

fn(c)

10.5類屬性和例項屬性

"""
類屬性的定義：在類裡面，在方法之外 定義的，不用帶self 
特點：類屬性在各個物件之間共享


如何訪問類屬性：
1、類物件.類屬性     Dog.num    （最推薦的寫法）
2、例項物件.類屬性 (不推薦這麼用)
3、例項物件.__class__.類屬性  (瞭解)
4、在類方法中， 通過  cls.num
"""


class Dog(object):   # 類物件

    num = 100  # 類屬性 ，是給類物件使用

    def __init__(self):
        self.age = 10   # 例項屬性， 是給例項物件去使用的，在各個物件之間互相獨立，互不干擾
        # self.num =

dog = Dog()   # 建立物件，建立例項， 建立例項物件，例項化一個物件
# print(dog.age)

dog1 = Dog()
dog1.age = 11
print(dog1.age)  # 11
print(dog.__class__.num)  # 100
dog1.__class__.num = 300
print(dog.__class__.num)  # 300

"""
類屬性的定義：在類裡面，在方法之外 定義的，不用帶self 
特點：類屬性在各個物件之間共享


如何訪問類屬性：
1、類物件.類屬性     Dog.num    （最推薦的寫法）
2、例項物件.類屬性 (不推薦這麼用)
3、例項物件.__class__.類屬性  (瞭解)

"""


class Dog(object):   # 類物件

    numb = 0  # 類屬性 ，是給類物件使用

    def __init__(self):
        self.age = 10   # 例項屬性， 是給例項物件去使用的，在各個物件之間互相獨立，互不干擾
        # self.num =
        # self.numb = 0
        Dog.numb += 1

dog = Dog()   # 建立物件，建立例項， 建立例項物件，例項化一個物件

dog1 = Dog()
dog2 = Dog()

print(Dog.numb)

10.6類方法和靜態方法

"""
類方法定義的格式：
@classmethod   # 裝飾器、修飾器
def 方法名(cls): 
    # cls和類名的指向是同一個
    # 類方法一般用來修改類屬性


如何呼叫類方法：
1、類名.方法名()      Dog.fn()
2、物件.__class__.方法名()      dog.__class__.fn()
"""


class Dog(object):   # 類物件
    num = 10

    def __init__(self):
        self.age = 10   # 例項屬性， 是給例項物件去使用的，在各個物件之間互相獨立，互不干擾

    def eat(self):    # 例項方法
        print("--吃")

    @classmethod   # 裝飾器、修飾器
    def fn(cls):   # 類方法   cls 接收的是類物件
        # print(Dog.num)
        print(cls.num)

    @staticmethod
    def fn02():   # 靜態方法
        print("這是靜態方法")

    @staticmethod
    def welcome():   # 靜態方法
        print("-" * 30)
        print("--------名片管理器v1.0--------")
        print("----1、新增名片")
        print("----2、刪除名片")
        print("----3、修改名片")
        print("----4、查詢名片")
        print("----5、查詢所有名片")
        print("----6、退出系統")
        print("-" * 30)


dog = Dog()
# dog.eat()

Dog.fn()  # 10
dog.__class__.fn()  # 10
Dog.welcome()

10.7__new__()

"""
    def __new__(cls):   # 作用： 返回出新創建出來的物件
        return super().__new__(cls)   # super().__new__(cls)是在呼叫object的new方法，object的new方法做了：創建出了新物件並且返回出這個物件， 一旦執行了super().__new__(cls)，就會有一個新物件產生


dog = Dog()

1、建立物件    __new__()   返回了這個物件
2、建立物件成功之後， 呼叫init方法
"""


class Dog(object):

    def __new__(cls):   # 作用： 返回出新創建出來的物件
        # pass
        return super().__new__(cls)   # super().__new__(cls)是在呼叫object的new方法，object的new方法做了：創建出了新物件並且返回出這個物件
        # 結論：一旦執行了super().__new__(cls)，就會有一個新物件產生

    def __init__(self):
        self.age = 10

dog = Dog()
print(dog)
print(dog.age)

10.8單例模式

"""

    def __init__(self, name, age):
        if 第一初始化：
            self.name = name
            self.age = age
"""


class King(object):

    __instance = None
    __isFirst = True

    def __new__(cls, name, age):
        # if not King.__instance:
        #     King.__instance = super().__new__(cls)
        #     return King.__instance
        # else:
        #     return King.__instance
        if not King.__instance:
            King.__instance = super().__new__(cls)

        return King.__instance

    def __init__(self, name, age):
        if King.__isFirst:
            self.name = name
            self.age = age
            King.__isFirst = False

king1 = King("嬴政", 40)
print(king1.name)
king2 = King("秦始皇", 42)
print(king1.name)