19 抽象类 接口类 封装. 多态

主要内容:

1.  抽象类(接口类) : python没有接口这个概念.只是制定一个规范.  

　　制定一个规范  :凡是继承我的类,必须有我规定的方法.

　　第一版:

class Alipay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('用支付宝花了%s钱' % self.money)
class Jdpay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('在京东花了%s钱' % self.money)
a1 = Alipay(100)
j1 = Jdpay(200)
a1.pay()
j1.pay()

　  第二版:支付方式一样

class Alipay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('用支付宝花了%s钱' % self.money)
class Jdpay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('在京东花了%s钱' % self.money)
def pay(obj):
    obj.pay()
a1 = Alipay(100)
j1 = Jdpay(200)
pay(a1)             #归一化设计.
pay(j1)

　　第三版:野生程序员来了...  添加一个微信支付的功能

# 野生程序员来了,....增加一个微信支付的功能
class Alipay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('用支付宝花了%s钱' % self.money)
class Jdpay:
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('在京东花了%s钱' % self.money)
class Wechatpay:
    def __init__(self,money):
        self.money = money
    def weixinpay(self):      #对于具有相同功能的方法,尽量使用同一个名字.
        print('使用微信支付了%s' % self.money)
def pay(obj):
    obj.pay()
a1 = Alipay(100)
j1 = Jdpay(200)
w1 = Wechatpay(300)
a1.pay()
j1.pay()
w1.weixinpay()

　　第四版:重新修改,制定规则,抽象类,接口类.

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):      #定义一个模块,强制使用pay,派生类中不适用会报错.
    @abstractmethod
    def pay(self):pass

class Alipay(Payment):
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('使用支付宝支付了%s' % self.money)
class Jdpay(Payment):
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('使用京东支付了%s' % self.money)
class Wechatpay(Payment):
    def __init__(self,money):
        self.money = money
    def pay(self):
        print('使用微信支付%s' % self.money)
def pay(obj):             #归一化设计.
    obj.pay()
a = Alipay(200)
j = Jdpay(500)
w = Wechatpay(300)
pay(a)
pay(j)
pay(w)

2.  多态:python处处是多态,没有多态的事例.         python:弱类型语言.

　　java:强类型语言.

　　python不管是什么类型,传入函数,封装到对象都可以.

　　Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”

       鸭子类型: 看着像鸭子,其实就是鸭子.

　　这些类:都互称为鸭子类型.

class Str:
    def index(self):
        pass
class List:
    def index(self):
        pass
class Tuple:
    def index(self):
        pass

3.  封装

　　广义的封装 : 实例化一个对象,给对象空间封装一些属性.给类中封装静态字段.

　　狭义的封装 : 私有制

　　私有成员:  私有静态字段  , 私有方法,   私有对象属性.

　　a:   私有静态字段:类的内部可以访问,类的外部不可以访问.

　　　　　　　　对于私有静态字段来说,只有在本类中内部访问,类的外部,派生类均不可访问.

class B:
    __money = 1000
class A(B):
    name = 'lily'
    __age = 20
    def func(self):
        print(self.__age)  #在类的内部实例化对象可以访问私有静态字段.
        print(A.__age)     #在类的内部类名可以访问私有静态字段.
    def func1(self):
        # print(self.__money)  #对于私有静态字段,只有本类中内部可以访问,类的外部派生类都不可以.
        # print(A.__money)
        pass
a1 = A()
a1.func()
# print(a1.__age)    #在类的外部,实例化对象不能访问类中的私有静态字段
# print(A.__age)     #在类的外部,类名不能访问私有静态字段
a1.func1()

　　b: 私有方法:类的内部可以访问,类的外部和派生类都不可以访问.

class B:
    __money = 1000
    def __fn(self):
        print('B')
class A:
    name = 'lily'
    __age = 20
    def __func(self):
        print('func,,,,')
    def func1(self):
        self.__func()    #在类的内部可以访问私有方法.
        # self.__fn()    #在类的外部.派生类均不可以访问静态方法.
a1 = A()
# a1.__func()           #类的外部不可以访问私有方法
a1.func1()
# print(B._B__money)   #尽量不要用.
# print(a1._A__age)
# print(A._A__age)
a1._A__func()
A._A__func(1)          #类名去访问类中的方法.一定要传参数.

　c :  私有对象属性:在类的内部可以访问.在类的外部派生类都不可以访问.

class Foo:
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.sex = sex
    def fn(self):
        print(f1.__name)     #在类的内部可以实现

f1 = Foo('alex',23,'nan')
print(f1.__dict__)
print(f1.sex)
f1.fn()
print(f1.__age)            #在类的外部不可以实现.

　d : 面试题:

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

    def __init__(self):
        self.__func()

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

son1 = Son()     #实例化一个对象son1,自动执行_init_方法,  执行self.__func(),内部实际self._Parent__func
                 #子类中没有,然后执行  'in parent func'
print(Parent.__dict__)