抽象类,接口类,封装,多态

抽象类,接口类

抽象类有固定的写法(制定规范),制定规范后,必须按照规范的方法来写后面的执行方法,否则程序就会报错

代码:

普通方法写两个支付的方法

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('使用支付宝支付了%s元' % (self.money))
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在京东支付了%s元' % (self.money))
a1=Ali(100)
a1.pay()

a2=Jd(200)
a2.pay()

归一化设计

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在支付宝使用了%s元' % self.money)
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在京东使用了%s元' % self.money)
def fu(ob):     #定义一个函数,这个函数的形参接收实例化的对象
    ob.pay()       #这个函数的功能必须要跟类里的函数方法一样,因为这里是调用类里的函数方法(都是支付方法),ob接收的实例化的对象
                   #执行的时候就相当于  对象.pay()   ,所以执行的实际上是类里面的pay(self)方法'''
a1=Ali(100)
fu(a1)          #归一化设计   ,  把实例化的对象当做实参传给ob这个形参,传过去就相当于a1.pay()这种形式
                #用归一化设计就不用每次执行程序时都要去手动调用函数,用归一化设计只需要实例化一个对象就行了,剩下的就由程序自己执行
a2=Jd(200)
fu(a2)


归一化设计的漏洞

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在支付宝中使用了%s元' % self.money)
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在京东使用了%s元' % self.money)
class Wx:
    def __init__(self,money):
        self.money=money
    def po(self):
        print('在微信中使用了%s元' % self.money)
        # class Wx这个类中的方法就是归一化设计的漏洞,虽然程序可以执行,
        # 但是这个类里面定义的方法和其他两个类中的方法不一样,我们要使它们必须用的是同样的方法,不然就报错

def fu(ob):     #这里按照归一化设计程序执行没毛病
    ob.pay()
a1=Ali(100)
fu(a1)

a2=Wx(200)
a2.po()



抽象类,接口类

from abc import ABCMeta,abstractmethod      #引入模块,这四行固定模式
class Payment(metaclass=ABCMeta):  # 抽象类(接口类):    #这里的payment作为下面两个类的父类,这个类名可以自己定义
    @abstractmethod
    def pay(self): pass  # 制定了一个规范   制定一个规范,下面类的方法必须使用这里定义的这个方法,否则报错,这个规范自己定义,所以函数名可以自己定义

class Ali(Payment):
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在支付宝上支付了%s元' % self.money)
class Jd(Payment):
    def __init__(self,money):
        self.money=money
    def pay(self):
        print('在京东上支付了%s' % self.money)

def fu(ob):
    ob.pay()

a1=Ali(100)
a2=Jd(200)
fu(a1)
fu(a2)
#这一版指定了规范,再像上一般那样自己定义一个函数方法,单独调用在这一版里面就会报错

# 封装
# 广义的封装:实例化一个对象,给对象空降封装一些属性
# 狭义的封装:私有制
# 私有成员:私有静态字段  ,  私有方法,私有对象属性 例:print(a1.__age)实例化对象不能访问私有静态字段,类名也不能
# 访问私有静态字段
# 对于私有静态字段,类的外部不能访问,类的内部可以访问
# 只能在本类中内部访问,类的外部,派生类均不可访问


面试题:

class Parent:
    def __func(self):       #4,执行__func(self):
        print('in Parent func')     #5,执行__func(self):后打印的内容

    def __init__(self):     #2,父类这里有__init__方法,执行__init__方法
        self.__func()       #3,__init__方法里面执行了__func这个函数

class Son(Parent):
    def __func(self):
        print('in Son func')

son1 = Son()   #1,实例化一个对象,会自动执行本类中的__init__方法,但是Son这个类中没有__init__方法,所以就去它的父类里面找

多态:

# Python没有多态,Python处处是多态,有鸭子类型
# 鸭子类型:函数每个类里面的函数方法是一样的   .  看着像鸭子类型,他就是鸭子
# 这些类 都互称为鸭子

例:

class Str:
    def per(self):
        print('a')
class Int(Str):
    def per(self):
        print('b')
class List(Str):
    def per(self):
        print('c')
a1=Str()
a1.per()
#这些类,都互称为鸭子

抽象类,接口类,封装,多态

猜你喜欢