zoukankan      html  css  js  c++  java
  • 类的抽象类接口类,多态封装

    抽象类,接口类

    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()
    w1 = Wechatpay(200)
    a1 = Alipay(200)
    j1 = Jdpay(100)
    pay(a1)  # 归一化设计
    pay(j1)
    

      python 到处都是多态

    python有鸭子类型.
    鸭子类型 : 看着像鸭子,他就是鸭子.
    
    这些类 都互称为鸭子.
    #举例:字符串,列表,元组中都有index方法,这几个类就叫做鸭子类型.方法用一样的名字 class Str: def index(self): pass class List: def index(self): pass class Tuple: def index(self): pass

      

    广义的封装: 实例化一个对象,给对象空间封装一些属性.
    狭义的封装: 私有制.私有成员:私有静态属性,私有方法,私有动态属性
    class B:
        __money = 100000
    
    class A(B):
        name = 'alex'
        __age = 1000
    
        def func(self):
            print(self.__age)
            print(A.__age)    # 对于私有静态属性,类的内部可以访问.
            print('func....')
        def func1(self):
            print(self.__money)
            print(A.__money)
    a1 = A()
    print(a1.name)
    print(A.name)
    
    print(a1.__age)  # 实例化对象不能访问私有静态属性
    print(A.__age)  # 类名不能访问私有静态属性
    对于私有静态属性,类的外部不能访问.
    
    a1.func()
    
    对于私有静态属性,类的内部可以访问.
    
    a1.func1()
    
    对于私有静态属性来说,只能在本类中内部访问,类的外部,派生类均不可访问.
    
    可以访问,但是工作中千万不要用.
    print(A._A__age)
    print(A.__dict__)
    
    私有方法
    
    class B:
        __money = 100000
        def __f1(self):
            print('B')
    
    class A(B):
        name = 'alex'
    
        def __func(self):
            print('func....')
    
        def func1(self):
            self.__func()   # 类的内部可以访问
            self.__f1()
    a1 = A()
    a1.__func()  # 类外部不能访问
    a1.func1()  # 类的内部可以访问
    
    # 面试题
    
    class Parent:
        def __func(self):
            print('in Parent func')
    
        def __init__(self):
            self.__func()
    
    class Son(Parent):
        def __func(self):
            print('in Son func')
    
    son1 = Son()
    #实例化对象的时候先执行等号右边,然后自动执行类里面的__init__方法,
    子类中没有去父类中找,
    然后执行__func方法,
    因为私有静态属性以及方法往下走时前面自动加上_类名,因为__init__方法在Parent类中,
    所以等于执行_Parent__func方法,
    打印in Parent func

      

  • 相关阅读:
    scala之伴生对象的继承
    scala之伴生对象说明
    “Failed to install the following Android SDK packages as some licences have not been accepted” 错误
    PATH 环境变量重复问题解决
    Ubuntu 18.04 配置java环境
    JDBC的基本使用2
    DCL的基本语法(授权)
    ZJNU 1374
    ZJNU 2184
    ZJNU 1334
  • 原文地址:https://www.cnblogs.com/duanpengpeng/p/9373031.html
Copyright © 2011-2022 走看看