10 面向对象基础（三）

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)