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

主要内容:

1.  抽象类(接口类):

　　制定一个规范  :

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
    @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 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__)

原文地址：https://www.cnblogs.com/gyh412724/p/9371352.html