day21--接口类,抽象类,接口

一,接口类,抽象类

只是在工作中书写的一种规范

用处: 在工作中,如果你要是规定几个类,必须有一样的方法,你要用抽象类,制定一个规范,强制其有此方法

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):   #强制制定规范,如果未按照规范执行,就会报错
    @abstractmethod
    def pay(self):pass

class QQ(Payment):
    def pay(self,money):
        print("您使用qq支付了%s元" % money)
    def ret(self):
        print("支付失败...")

class Ali(Payment):
    def pay(self,money):
        print("您使用支付宝支付了%s元" % money)

class Wechat(Payment):
    def pay(self,money):
        print("您使用微信支付了%s元" % money)

def pay(obj,money):
    obj.pay(money)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
pay(q1,100)
pay(a1,200)
pay(w1,300)

View Code

二,Python多态(鸭子类型)

Python没有多态的概念,但是Python崇尚鸭子类型

 
 python中好多不同类但同名的方法不是强制规定,而是约定俗成,不同的类,都同样据有一种方法,而且功能相似,则他们互称为鸭子. 

 
   # str  list  tuple
str.index()
s1 = 'alex'
class Str:
    def index(self):
        pass

class List:
    def index(self):
        pass

class tuple:
    def index(self):
        pass
#python中好多不同类但同名的方法不是强制规定,而是约定俗成,像上面这三种类,都同样据有index方法,而且功能相似,
# 则 他们三个互称为鸭子. 
  
鸭子类型
三,Python封装
封装就是将一些属性或方法(有用信息)放置在一个空间中
 
   #类的结构分析:

# class Person:
#     mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段
#     __level = '高等动物'  # 第一部分:私有静态变量,私有静态字段  变量名前加__
#     def __init__(self,name,age,sex): # 构造方法  # 第二部分 动态方法,方法(函数)
#         self.name = name   # 公有对象属性
#         self.age = age
#         self.__sex = sex  # 私有对象属性
#     def func(self):   # 第二部分:普通方法
#         print(666)
#     def __func1(self):  # 第二部分:私有方法
#         print(777)
#
#     @staticmethod  #  静态方法
#     def f2():pass
#
#     @classmethod  # 类方法
#     def f2(self): pass
#
#     @property    # 属性
#     def hex(self):pass
#
# 类整体分类:
    #第一部分:  公有静态字段 mind = '有思想...' ,私有静态字段. __level = '高等动物'
    #第二部分: 特殊方法(__init__(公有属性,私有属性),__str__...)
                # 普通方法  def func(self)
                # 私有方法  def __func1(self):
                #类方法:
                    # @classmethod
                    # def f2(self): pass
                # 静态方法:
                    # @staticmethod  #  静态方法
                    #   def f2():pass
                #属性:
                    # @property  # 属性
                    # def hex(self): pass 
  
类的结构分析
私有成员:私有静态字段,私有属性,私有方法,在变量前+__双下划线
私有静态字段
 
   # 私有静态字段
class Animal:
    __cloth = "皮毛"

class Person(Animal):
    mind = "有思想"
    __level = "高等动物"

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.__level)
        #print(self.Animal__cloth)
        #print(self.__cloth)
p1 = Person("alex",1000)
print(p1.mind)
#print(p1.__level)  #在类的外面访问: 私有静态字段是访问不到的.
#print(Person.__level)
print(Person.__dict__)
print(Person._Person__level)  #可以通过对象._类名__变量名  类名._类名__变量名 可以访问到,但是绝对不要这么访问.
p1.func()    #在类的内部: 私有静态字段是可以访问
#print(p1.__cloth)  #父类的私有静态字段,派生类可否访问? 不可访问. 
  
View Code
私有方法
 
   # 私有方法

# class Animal:
#     def __f1(self):print(1111)  # _Animal__f1
#
# class Person(Animal):
#     mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段
#     def __init__(self,name,age): # 构造方法  # 第二部分 动态方法,方法(函数)
#         self.name = name   # 公有对象属性
#         self.age = age
#         self.__sex = sex
#     def __func(self):  # _Person__func()
#         print(666)
#     def func1(self):
#         self.__func()  # self._Person__func()
#     def func2(self):
#         self.__f1()  # self._Person__f1()

# 类外面访问不到.
# p1 = Person('OLDBOY',1000)
# p1.__func()  #
# 类内部可以方法.
# p1 = Person('OLDBOY',1000)
# p1.func1()
# 派生类中也是不能访问的.
# p1.func2()
# 私有属性 也是类外部不能访问,派生类不能访问,只能在类内部访问. 
  
View Code
# 总结: 对于私有成员来说,他加载到内存时,都会加上_类名__变量名,所以你在类的外部,或者派生类中都不可访问.
#为什么设置私有成员?
# 有些变量,方法,属性,只在类内部进行使用即可,不便于(不允许)类外部或者派生类去调用.
相关面试题
 
  # class A:
#     def __init__(self):
#         self.__func()
#     def __func(self):
#         print('IN    A')
# class B(A):
#     def __func(self):
#         print('IN     B')
# b1 = B()

class A:
    def __init__(self):
        self.func()
    def func(self):
        print('IN    A')
class B(A):
    def func(self):
        print('IN     B')
b1 = B()
# print(b1.name)
# print(b1.func)
print(b1.func)
print(b1.func()) 
 

day21--接口类,抽象类,接口

猜你喜欢