接口类 和 抽象类

#接口类：多继承，父类不实现
# from abc import ABCMeta,abstractmethod
# class  Fly_Animal(metaclass=ABCMeta):#规范
#      @abstractmethod
#      def fly(self):pass
#
# class Swim_Animal(metaclass=ABCMeta):
#     @abstractmethod
#     def swim(self):pass
#
# class Walk_Animal(metaclass=ABCMeta):
#     @abstractmethod
#     def walk(self):pass
#
# class Frog(Walk_Animal,Swim_Animal):
#     def walk(self):
#         print("自己实现")
#
#         def swim(self): pass
# class Swan(Walk_Animal,Swim_Animal,Fly_Animal):
#     pass
# class Bird(Walk_Animal,Fly_Animal):
#     pass


#applepay  alipay
# from abc import  ABCMeta,abstractmethod
# # 接口类：
# # 是规范子类的一个模板，只是接口类中定义的，就应该在子类中实现
# #接口类不能被实例化，它只能被继承
# 支持多继承

# class Payment(metaclass=ABCMeta):#模板,接口类
#     @abstractmethod #装饰接口类中方法的，加上这个装饰器，自动检测子类中的方法名
#     def pay(self,money):pass
#
#     @abstractmethod
#     def  get(self,money):pass
# class Apple_pay(Payment):
#     def pay(self,money):
#         print('用苹果支付了%s元'%money)
# class Ali_pay(Payment):
#     def pay(self, money):
#         print('用支付宝支付了%s元'%money)
# class WeChat_pay(Payment):
#     def pay(self,money):
#         print('用微信支付了%s元'%money)
# def pay(obj,money):
#     return obj.pay(money)
# apple = Apple_pay()
# ali = Ali_pay()
# wechat = WeChat_pay()
# # apple.pay(100)
# # ali.pay(50)
# # pay(apple,100)#apple.pay(100)
# pay(wechat,200)


#抽象类
#模板 规范
#抽象类可以实现一些子类共有的功能和属性  抽象不鼓励多继承
#抽象类不能被实例化
#这个抽象类可以规范子类必须实现抽象类中的抽象方法

#文件操作：打开文件，关闭文件，写文件，读文件
#硬盘操作：打开，关闭，写，读
#进程文件：打开，关闭，读，写
# python 没有接口的概念
# 只能借助抽象类的模具  来实现接口类
#接口——Java：没有多继承——Interface

# from abc import ABCMeta,abstractmethod
# class  Base(metaclass=ABCMeta):
#     def __init__(self,filename):
#         self.filename = filename
#
#     @abstractmethod #抽象方法
#     def open(self):
#         return "shabi"
#
#     @abstractmethod
#     def close(self):pass
#
#     @abstractmethod
#     def read(self):pass
#
#     @abstractmethod
#     def write(self):pass
# class File(Base):
#     def open(self):pass
#     def close(self):pass
#     def read(self):pass
#     def write(self):pass


#封装 :把一些属性和方法放到类里 这本身就是一种封装
    # 封装 ： 把属性和方法藏在类里 我只能在类内部调用，不能再外部使用
#从类的外面不能直接调用，在类内的使用加上了一层密码：_类名

# class Dog:
#     __role = 'dog'   #私有的静态属性
#     def __discount(self): #私有的方法
#         print('in __func')
#
#     def price(self):
#         self.__discount()

# print(Dog.__dict__)
# print(Dog._Dog__role)#不推荐用这种方法

#定义一个私有变量属性方法 ： __名字
#在类的内部可以直接用 : __名字
#在类的外部不能直接使用，如果一定要用，在私有方法之前加上：_类名,变成 _类名__名字
#在类外的名字 通过__dict__就可以查看

# class Room:
#     def __init__(self,name,price,length,width):
#         self.name = name
#         self.price = price
#         self.__length =length  #私有的对象属性
#         self.__width = width
#
#     def area(self):
#         return self.__length*self.__width
#
# house = Room('小超超',1000000,2,1)
# print(house.area())
# class A:
#     def __func(self):
#         print('__a_func')
#
# class B(A):
#     def __init__(self):
#         self._A__func()
#
# b = B()

#私有的
#私有的静态属性、方法、对象属性
#使用__名字的方式调用，保证在类内部可以调用，外部不行
#私有的 不能被继承
# 当有一个名字，不想被外部使用也不想被子类继承，只想在内部使用的时候就定义私有的

#公有的
#私有的 + property


# class Person:
#     def __init__(self,name,height,weight):
#         self.name = name
#         self.height = height
#         self.__weight = weight
#
#     @property
#     def bmi(self):
#         return self.__weight / (self.height ** 2)
#
# li = Person('博',1.80,70)
# print(li.bmi)#调用属性一样的调用他的方法

#@property 把一个方法 伪装成一个属性
#1.属性的值 是这个方法的返回值
#2.这个方法不能有参数了


#圆形类 ： 面积 周长
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r = r
#     @property
#     def area(self):
#         return self.r*self.r*pi
#
#     @property
#     def perimeter(self):
#         return self.r*pi*2
# c1 = Circle(5)
# print(c1.area)
# print(c1.perimeter)

# class Goods:
#     __discount = 0.8   #静态属性
#     def __init__(self,name,price):
#         self.__name = name
#         self.__price = price  #原价
#     @property
#     def name(self):
#         return self.__name
#
#     @name.setter
#     def name(self,new_name):
#         self.__name = new_name
#
#     @property
#     def price(self):   #折后价
#         return self.__price * Goods.__discount
#
#     @price.setter
#     def price(self,new_price):   #修改原价
#         if type(new_price) is int:
#             self.__price = new_price
# apple = Goods('苹果',10)
# apple.price = '10'   #settrt
# print(apple.price)   #property
# apple.price = 8
# print(apple.price)


# 封装
# __私有+property
# 让对象的属性变得更安全了
# 获取到的对象的值可以进行一些加工
# 修改对象的值的同时可以进行一些验证


class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
# print(f1.AAA)     #property
# f1.AAA='aaa'#setter
print(f1.AAA)
# del f1.AAA    #deleter

# 定义一个类
#类里面的方法
#并没有用到self
# class Goods:
#     __discount = 0.8
#     @classmethod   #类方法
#     def change_discount(cls,new_discount):
#         cls.__discount = new_discount
#     @classmethod
#     def get_discount(cls):
#         return cls.__discount
# # apple = Goods()
# Goods.change_discount(0.75)
# print(Goods.get_discount())
#类方法
    #调用：不需要实例化 直接用类名调用就好
    #定义：不用接受self参数，默认传cls，cls就代表当前方法所在的类
#什么时候用类方法？
    #需要使用静态变量 且 不需要和对象相关的任何操作的时候

#静态方法
#如果这个方法 既不需要操作静态变量
           # 也不需要使用对象相关的操作，
# 就使用静态方法
class A:
    @staticmethod
    def func(name):  #静态方法
        print(123)
A.func('alex')
#面向对象编程：专门为面向对象编程提供的一个方法——staticmethod
#它完全可以当做普通函数去用，只不过这个函数要通过类名.函数名调用
#其他 传参 返回值 完全没有区别

#类里面，一共可以定义这三种方法：
#普通方法 self
#类方法 cls
#静态方法

#绑定方法 和 非绑定方法

class A:
    @staticmethod
    def func1(name):  #静态方法
        print(123)

    @classmethod
    def func2(cls):  # 静态方法
        print(123)

    def func3(self):pass
a = A()
print(a.func1)  #静态方法
print(a.func2)  #类方法 ： 绑定到A类的func
print(a.func3)  #普通方法：绑定到A类对象的func

#静态方法和类方法 都是直接可以使用类名调用
#普通方法：对象调用