python面向对象

对象初始化过程
    __new__() 分配空间 创建对象
    __init__() 初始化

#继承
class Animal(object):
    def __init__(self):
        pass

    def eat(self):
        print('eateat-----')

    def drink(self):
        print('drink like animal-----')

    def sleep(self):
        print('sleepsleep-----')

class Human(Animal):
    def __init__(self):    # 父类不是object 
        super().__init__() # 重写__init__方法时要跑一次父类的__init__方法  保证父类的___init_能正常运行
         #原因是父类的__init__可能会封装有用的方法 不super调用一下等于全部重写__init__
         #重写或部分改写才要写这里的__init__ 直接继承不用__init__

    def play(self):
        print('playplay')

    def drink(self):          #继承 和父类的drink一样
        super().drink()   #调用父类方法1   
        #Animal.drink(self) #调用父类方法2

    def drink(self):          #多态
        super().drink()   #调用父类方法1
        print('Hunam drink good water')    # 多态 和父类的drink不一样

多继承
class A:
    def test(self):
        print('test')

class B:
    def test(self):
        print('ceshi')

class C(B,A):  #同名方法按( )里的顺序的
    pass

lala = C()
lala.test()

class C(B,A):
    pass
C.mro() #显示类方法的执行顺序

Python中
    class A()            #旧式类
        pass

    class A(object)        #新式类，python3中默认就是，等价于class A()
        pass                         #一律带object 方便移植

多态 # 子类和父类的相同方法产生不同的输出  这就是多态

class A(object):
    def f01(self):
        print("AA")

class B(A):
    def f01(self):
        print("AB")

H = B()

H.f01()

封装：在一个类中封装属性和方法
继承：子类能调用父类的属性和方法
多态：子类能调用父类的属性和方法得出不同的结果

类的方法在内存中只有一份 不同的实例用self传递给类的方法

类属性 和 类方法

class A(object):
    count = 0       # 类属性

    def __init__(self):
        A.count += 1

    @staticmethod    # 静态方法 不带参数  不需调用self或cls
    def f01():
        print("AA")

    @staticmethod    # 静态方法 带参数  不需调用self或cls
    def f02(person_name):
        print("AA"+person_name)

    @classmethod    # 需要传入cls 是类方法
    def print_class_count(cls):
        print(cls.count)    # 内部调用类属性

class B(A):
    def f01(self):
        print("AB")

H = A()
K = B()

print(A.count)

调用静态方法不能用self.aaa() 要用class.aaa()

-----------------------------------------------------------------------------------
单例设计
    保证一个类仅有一个实例，并提供一个访问它的全局访问点。
    避免全局使用的类频繁地创建与销毁
    控制实例数目，节省系统资源
    如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

class Person(object):
    new_instance = None   # __new__()创建空对象 存储__new__的返回 其为分配的空间和对象引用
    
    @classmethod
    def __new__(cls, *args, **kwargs):

        if cls.new_instance is None:  # 没有__new__过
            cls.new_instance = super().__new__(cls) #创建本对象
        else:
            return cls.new_instance

        return cls.new_instance

    def __init__(self):
        print('初始化')

A = Person()
B = Person()

print(A)
print(B)

---------------------------------------------------------------
self.__age只可在类的内部使用

class Girl(object):  # 类有内存空间 类型 名字
    school = "aaa"
    def __init__(self,name,age,sex):
        self.name = name
        self.__age = age
        self.sex =sex

    def a01(self):
        pass

    def a02(self):
        pass

xh = Girl('xiaohong',28,'F')
print(xh.name)
print(dir(xh))             #获取内部隐藏属性
print(xh._girl__age)             #访问内部隐藏属性