# 封装到对象中的属性是一种封装。 类本身就算是一种封装
class Person:
    
    country = ‘China‘    # 公开的 
    _addr = 555          # 被保护的
    __sch = "zhkai"      # 私有的
    
    def __init__(self, sex, name, age):
        self.name = name   # 公开的
        self._sex = sex    # 被保护的
        self.__age = age   # 私有的
        
    def func(self):       # 公开的
        print(self.name)
        
    def _func1(self):     # 被保护的
        print(self._sex)
        
    def __func2(self):    # 私有的
        print(self.name)
        
    def func3(self):      # 私有的可以在类内部进行访问
        print("__sch:", self.__sch, "  ","__age:", self.__age)
        
# 实例化对象    
p1 = Person("man", ‘xiaming‘, 39)
p2 = Person("girl",‘lisi‘, 18)

"""-------------------------------------------------------"""
# 1.公开的没有限制
p1.func()    # xiaming
print(p1.country, p2.country, Person.country)   # China China China
"""-------------------------------------------------------"""

# 2.被保护的能在类中调用
    # 2.1在类中或者子类中都可以访问
    # 2.2在外部不可以访问：此变量不能通过from XXX import xxx 导入   
    
p2._func1()   # girl
print(p1._addr, p2._addr, Person._addr)  # 555 555 555
"""-------------------------------------------------------"""

# 3.私有的

    # 3.1父类以及类的外部不能访问
# print(Person.__name)  
# p1 = Person()
# print(p1.__name)

    # 3.2 在类的内部可以调用
p1.func3()  # __sch: zhkai    __age: 39
p2.func3()  # __sch: zhkai    __age: 18

    # 3.3通过改名访问
        # 执行类的内容时，发现”__“的变量名时，系统会自动将其改名
        # 可以使用.__dict__查看，发现改名为 classname._classname__attributename 
        # 例如：__age 改为 _Person__age
p2._Person__func2()  # lisi
print(p2._Person__age, p2.__dict__[‘_Person__age‘], Person.__dict__[‘_Person__sch‘]) 
       # 18 18 zhkai

class Person:
    def __init__(self,name):
        self.name = name
    def getName(self):
        return self.name
    def setName(self, value):
        self.name = value
    def delName(self):
        del self.name
    x = property(getName,setName,delName)

p = Person("dd")
print(p.x) # dd
# 如果p 是 Person的实例化, p.x 将触发 getter,p.x = value 将触发 setter ， del p.x 触发 deleter。
p.name = 55
print(p.x) # 55

# 1.简单的继承
class A():  
    pass
class C():
    pass

# 1.1单继承
class B(A):   
    pass

# 1.2多继承
class Person(A, C):
    pass

# 注意：创建了类就会继承object
# 1.3查看对象
print(B.__class__)
print(type.__class__)

# 1.4查看父类：使用__bases__
print(B.__bases__)      # 单继承，只有一个父类
print(Person.__bases__)   # 多继承，包含了两个父类
print(int.__bases__, bool.__bases__)
"""
# 结果
<class ‘type‘>
<class ‘type‘>
(<class ‘__main__.A‘>,)
(<class ‘__main__.A‘>, <class ‘__main__.C‘>)
(<class ‘object‘>,) (<class ‘int‘>,)
"""

# 2.1资源的使用
# 定义父类（超类）
class Person():
    name = "China"         # 公有的
    __age = 18             # 私有的
    _addr = 56       # 被保护的
    def sleep(self):
        print("Sleeping....")
        
# 定义子类
class Teacher(Person):
    teacher_id = "9527"
    def make_test(self):
        print("attention")

t = Teacher() 

# 1.子类可以继承它的父类的任何属性和方法，可以使用父类里除了私有成员外所有内容
    # 1.1访问公有的、被保护的属性和方法
print(t.name, t._addr)  # China 56
t.sleep()  # Sleeping....

    # 1.2无法访问私有属性和方法
# print(t.__age)   # 会报错  但是还是可以通过改名访问print(t._Person__age)

    # 1.3 子类实例化对象访问自己的属性和方法
print(t.teacher_id)  #  9527
t.make_test()   # attention

    # 1.4用父类的资源，只能读取，而不是修改
         # Teacher中没有name的属性,利用Teacher.__dict__查看
         # 给Teacher增加了name属性，没有修改Person的name
Teacher.name = "201888" 
         # 修改后
print(Teacher.__dict__) # ‘name‘: ‘201888‘
print(Person.__dict__)  # ‘name‘: ‘China‘,

class B():
    age = 18
    
class A(B):
    age = 28   

t = A()
print(A.__dict__)
print(A.__dict__)
# 子类和父类定义同一个名称变量，则优先使用子类
print(t.age)  
"""
# 结果
{‘__module__‘: ‘__main__‘, ‘age‘: 28, ‘__doc__‘: None}
{‘__module__‘: ‘__main__‘, ‘age‘: 28, ‘__doc__‘: None}
28
"""

# 1.通过实例化对象增加
class Hum():
    a = 1
    def __init__(self):
        self.b = 2    
        
class Person(Hum):
    c= 3  
p = Person()
p.a = 77   
print(p.__dict__)
"""--------------------------------------------------------------------------"""

# 2.通过父类,在父类内增加
    # 注意;这种情况是子类没有构造函数，不能覆盖父类的构造函数
class Hum():
    a = 1
    def __init__(self):
        self.b = 2
        self.a = 77  # 增加的属性    
        
class Person(Hum):
    c= 3 
    
p = Person()
print(p.__dict__)

"""--------------------------------------------------------------------------"""
# 3.通过子类,在子类内增加
    # 注意：如果子类有构造函数，会覆盖父类的构造函数的。
class Hum():
    a = 1
    def __init__(self):
        self.b = 2
        
class Person(Hum):
    c= 3 
    def __init__(self):    
        Hum.__init__(self)   
            # 引用B中的实例化属性，解决被覆盖的问题 
        self.a = 77  # 增加的属性
    
p = Person() 
print(p.__dict__)

"""--------------------------------------------------------------------------"""

# 4.通过super
class Hum():
    a = 1
    def __init__(self):
        self.b = 2
        
class Person(Hum):
    c= 3 
    def __init__(self):    
        super(Person, self).__init__()  # 实现父类功能   
        # super().__init__() # 这种写法也可以
        self.a = 77
p = Person() 
print(p.__dict__)

"""--------------------------------------------------------------------------"""
# 5子类扩充夫类功能
    # 直接调用父类相应的功能，或者通过super
class Person():
    def sleep(self):
        print("Sleeping....")
    def work(self):
        print("make some money")
        
class Teacher(Person):
    def make_test(self):
        print("attention")
        
    def work(self):
        # 扩充父类功能只需调用父类相应的函数
        # Person.work(self)
        super().work()
        self.make_test()# 此处是扩充
        # 扩充父类的另一种方法,super 代表得到父类
                        
t = Teacher() # make some money

t.work()  # attention

# 继承里面的构造函数
class A():
    def __init__(self):
        print("A__init__")
class B():
    def __init__(self):
        print("B__init__")
class C(B):
    def __init__(self):
        print("C__init__")
class D(A):
    pass
class E():
    pass
 
p1 = A() # 自动调用A的构造函数
p2 = D() # 自动调用A的构造函数，
         # 因为D中没有构造函数，只能调用父类的构造函数
p3 = C() # 自动调用C的构造函数
         # 父类B的构造函数被覆盖了，C中已经存在各种函数
# p3 = E() # 会报错，E()没构造函数