# 接口类(抽象类)
from abc import ABCMeta,abstractmethod
# 接口类，用于规定：继承此类的派生类，必须有什么方法
class PayMeta(metaclass=ABCMeta):
    # 加上装饰器@abstractmethod，代表继承PayMeta类的派生类中必须有pay方法，否者报错。
    @abstractmethod
    def pay(self): pass
    
class Alipay(PayMeta):
    def __init__(self,money):
        self.money = money
        
    def pay1(self):
        print('使用支付宝,支付了<%s>.'%self.money)
    def pay(self):
        print('使用支付宝,支付了<%s>.'%self.money)
def pay(obj):
    obj.pay()
a1 = Alipay(500)
pay(a1)

# 类的私有字段、方法
# 在字段名前加上__该字段就成为了私有字段，只能在类的内部访问。就算是派生类（子类）也无法访问 
'''
私有字段的实现原理，在Python解释器读到__开头的字段时，会给该字段改名，改为 ‘_类名__字段名’,

所以使用_类名__字段名 这个可以在任何地方访问私有字段，但是不推荐这样访问

私有方法也是同理

注：在Python解释器从上到下读取类代码的时候，只要遇到私有字段都会将名字改为‘_类名__字段名’，不管是调用还是定义

'''

class A:
    __name = '类的私有字段'
    def __f1(self):
        print('__f1')
    def f2(self):
        self.__f1()
class B(A):
    def fun(self):
        print(self._A__name)
        
b1 = B()
b1.fun()
a1 = A()
a1.f2()

# 类的私有方法
class Parent():
    def __func(self):
        print('in Parent func Parent的私有方法')
        
    def __init__(self):
        self.__func()
        
        
class Son(Parent):
    def __fun(self):
        print('in Son func Son的私有方法')
        
son1 = Son()

# 类的私有对象属性
class A:
    __fun = 0
    def __init__(self,age):
        self.__arg = '类的私有静态对象属性'
        self.__age = age
    def func(self):
        print(self.__arg)
        print(self.__age)
#     def __fun(self):
#         print(666)
a1 = A(12)
print(A.__dict__)
a1.func()

# 创建一个类，计算BMI指数
'''
@property装饰器
property 可以让一个方法，伪装成属性使用。下面是示例

'''
class Bmi:
    def __init__(self,weight,hight,name):
        self.weight = weight
        self.hight = hight
        self.name = name
    @property
    def bmi(self):
        b = self.weight / self.hight ** 2
        if b < 18.5:
            return '《Name:%s BMI:%s》过轻：低于：18.5'%(self.name,format(b,'0.2f'))
        
        elif b <= 23.9:
            return '《Name:%s BMI:%s》正常：18.5~23.9之间'%(self.name,format(b,'0.2f'))
        
        elif b <= 27:
            return '《Name:%s BMI:%s》过重：24~27之间'%(self.name,format(b,'0.2f'))
        
        elif b <= 32:
            return '《Name:%s BMI:%s》肥胖：28~32之间'%(self.name,format(b,'0.2f'))
        
        else:
            return '《Name:%s BMI:%s》非常肥胖：高于32'%(self.name,format(b,'0.2f'))
        
bmi = Bmi(73,1.77,'kkk')
print(bmi.bmi)

# property 属性的修改
'''
@property装饰器
property 可以让一个方法 伪装成属性使用。

伪装属性的修改
@需要修改的属性.setter 下面是示例

注: 要使用 setter 装饰器 必须要存在@property  
'''
class A:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    # 查看属性
    @property    
    def age(self):
        return self.__age
    
    # 修改属性
    @age.setter 
    def age(self,a1):      

        self.__age = a1 if isinstance(a1,int) else self.__age
    # 删除属性
    @age.deleter
    def age(self):
        del self.__age
    
a1 = A('kkk',28)
print(a1.age)
a1.age = a1.age + 1
print(a1.age)
del a1.age

# 类方法

class A:
    def func(self):
        print(self)
    @classmethod    
    def func1(cls):
        # cls 就是 A 这个类
        print('传入的cls',cls)
        return cls()
    
    
a1 = A.func1()
a1.func()
# 对象调用类方法,自动传入的cls也是类本身。
a2 = A()
a2.func1()
'''
类方法的使用场景

1.类中 有些方法不需要对象参与
2.对类中的静态变量进行改变，要用类方法
3.在父类中获取，子类类空间

'''
# 在父类中获取，子类类空间
class A:
    @classmethod
    def func(cls):
        print(cls)
class B(A):
    pass
B.func()

# 静态方法
'''
静态方法：没有self,cls 不用默认传入 对象和类
'''
class A:
    @staticmethod
    def func():
        print(666)
A.func()