接口類抽象類 封裝

時間  2019-11-19
標籤 接口 抽象 封裝 欄目 軟件設計 简体版
原文   原文鏈接

 

接口類抽象類:java

初版,很差,沒有統一化設計,第二版解決.
class QQ:
    def pay(self,money):
        print('您用qq支付了%s元' % money)

class Ali:
    def pay(self,money):
        print('您用支付寶支付了%s元' % money)

q1 = QQ()
q1.pay(100)
a1 = Ali()
a1.pay(200)
View Code 
第二版 ,相安無事,此時來了一個野生程序員.完成了一個微信功能
class QQ:
    def pay(self,money):
        print('您用qq支付了%s元' % money)

class Ali:
    def pay(self,money):
        print('您用支付寶支付了%s元' % money)


class Wechat:
    def wechatpay(self,money):
        print('您用微信支付了%s元' % money)

def pay(obj,money):
    obj.pay(money)  # q1.pay(100)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 統一化設計
pay(a1,200)
w1 = Wechat()
w1.wechatpay(500)
View Code 
第三版,從新改版微信支付功能
class QQ:
    def pay(self,money):
        print('您用qq支付了%s元' % money)

class Ali:
    def pay(self,money):
        print('您用支付寶支付了%s元' % money)

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

def pay(obj,money):
    obj.pay(money)  # q1.pay(100)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 統一化設計
pay(a1,200)
w1 = Wechat()
pay(w1,500)
View Code 
第四版,爲了不上述野生程序員可能發生的問題,我要制定一個規範.
class Payment:  # 抽象類,或者接口類:制定一個規範.
    def pay(self):pass


class QQ(Payment):
    def pay(self,money):
        print('您用qq支付了%s元' % money)


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)  # a1.pay(200)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 統一化設計
pay(a1,200)
w1 = Wechat()
pay(w1,500)
View Code 
第五版 強制制定規範,若是未按照規範執行,就會報錯.
from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):    # 抽象類 接口類  規範和約束  metaclass指定的是一個元類
    @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)  # a1.pay(200)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
q1 = QQ()
a1 = Ali()
pay(q1,100)  # 統一化設計
pay(a1,200)
w1 = Wechat()
pay(w1,500)
View Code 
用處: 在工做中,若是你要是規定幾個類必須有同樣的方法, 你要抽象類,制定一個規範,強制其有此方法. python沒有多態的概念,可是python崇尚鴨子類型. 定義變量的方法: 1,java c# 須要定義 類型. int i= 3
2,java c# 沒有多繼承的概念.
i = 1
i = 'alex'
鴨子類型: 它看着像鴨子,那麼他就是鴨子.
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
View Code 
python中好多不一樣類但同名的方法不是強制規定,而是約定俗成,像上面這三種類,都一樣據有index方法,並且功能類似, 則 他們三個互稱爲鴨子.
封裝: 封裝就是將一些屬性或者方法(有用的信息)放置在一個空間中. 1,封裝 對象的封裝.
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
p1 = Person('oldboy',1000)
p2 = Person('alex',10000)
print(p1.name)
print(p2.name)
View Code 
2 封裝(私有成員.) 類的結構分析:
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 = '皮毛'  # _Animal__cloth

class Person(Animal):
    mind = '有思想...'  # 第一部分:全部的公有靜態變量,公有靜態字段
    __level = '高等動物'  # 第一部分:私有靜態變量,私有靜態字段  # _Person__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)
View Code 
在類的外面訪問: 私有靜態字段是訪問不到的.
p1 = Person('alex',1000)
print(p1.mind)
print(p1.__level)
print(Person.__level)
print(Person.__dict__)
print(Person._Person__level)
View Code 
能夠經過對象._類名__變量名 類名._類名__變量名 能夠訪問到,可是絕對不要這麼訪問. 在類的內部: 私有靜態字段是能夠訪問
p1 = Person('alex',1000)
p1.func()

父類的私有靜態字段,派生類能否訪問? 不可訪問.
p1 = Person('alex',10)
print(p1.__cloth)
p1.func()
私有方法:
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()
View Code 
類外面訪問不到.
p1 = Person('OLDBOY',1000)
p1.__func()  #
類內部能夠訪問.
p1 = Person('OLDBOY',1000)
p1.func1()
派生類中也是不能訪問的.
p1.func2()
私有屬性 也是類外部不能訪問,派生類不能訪問,只能在類內部訪問.
class Animal:
    def __f1(self):print(1111)  # _Animal__f1

class Person(Animal):
    mind = '有思想...'  # 第一部分:全部的公有靜態變量,公有靜態字段
    def __init__(self,name,age,sex): # 構造方法  # 第二部分 動態方法,方法(函數)
        self.name = name   # 公有對象屬性
        self.age = age
        self.__sex = sex
    def __func(self):  # _Person__func()
        print(666)
View Code 
總結: 對於私有成員來講,他加載到內存時,都會加上_類名__變量名,因此你在類的外部,或者派生類中都不可訪問. 爲何設置私有成員? 有些變量,方法,屬性,只在類內部進行使用便可,不便於(不容許)類外部或者派生類去調用.
class Person:
    def __init__(self,username,password): # 構造方法  # 第二部分 動態方法,方法(函數)
        self.usn = username   # 公有對象屬性
        self.__pwd = self.__makepassword()
    def __makepassword(self):
        '''複雜的加密過程'''
        new_pwd = self.__pwd + '666'
        return new_pwd
p1 = Person('alex','123')
print(p1.__pwd)
View Code 
面試題:
class A:
    def __init__(self):   # 2, self = b1對象空間
        self.__func()   # 默認_A__func()  (私有屬性必須把前面的類加上)  # 3, b1._A__func()             
    def __func(self):    # 4 , 默認_A__func()   b1._A__func()  
        print('IN    A')       # print(in A )
class B(A):
    def __func(self):
        print('IN     B')
b1 = B()    1, #B裏面沒有去A裏面找       

class A:
    def __init__(self):   # 2,self = b1對象空間
        self.func()      # 3,b1.func()  #b1裏面有func函數,全部又去b1裏面找
    def func(self):
        print('IN    A')
class B(A):
    def func(self):
        print('IN     B')    #  4 print(IN B)
b1 = B()   # 1,B沒有去A裏面找b1屬性        
# print(b1.name)
# print(b1.func)
print(b1.func)
print(b1.func())
View Code

 

抽象類接口類：
抽象類和接口類 —— 瞭解*
在python代碼中 抽象類和接口類沒有明顯的區別
主要就是維持了一種規範
一切皆對象
a = 1
dic = {'k':'v'}
lst = [1,2,3]
def func():
    pass
print(type(func))

len(lst)
print(dic.__len__(),len(dic))
def len(lst):
    return lst.__len__()
print(len)

from abc import ABCMeta,abstractmethod
class Pay(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):pass    # 規範
View Code 
多態：
python天生自帶多態
什麼是多態
java的多態是經過繼承實現的
class Foo:pass
class list(Foo):pass
class dict(Foo):pass
class str(Foo):pass
def len(a):
    print(a)
len(1)
View Code 
Python，動態解釋型強類型語言
弱類型 1+'2'參數的數據類型也不須要指定
強類型 同類型之間能夠作運算 參數的數據類型也須要指定
抽象類 ：
子類必須實現父類中的同名方法——規範代碼
    在類的位置指定metaclass 是ABCMeta
    在指定的方法上面添加@abstractmethod裝飾器
目的：規範全部繼承這個類的子類 必須實現被@abstractmethod裝飾器裝飾的這個方法
特色：抽象類和接口類只能被繼承不能被實例化
class WechatPay(Pay):
    def pay(self,money):
        print('微信支付了%s元'%money)

class AliPay(Pay):
    def pay(self, money):
        print('支付寶支付了%s元' % money)

class ApplePay(Pay):
    def pay(self,money):
        print('apple支付了%s元' % money)

def payment(obj,money):
obj.pay(money)
wp = WechatPay()
payment(wp,100)     # 編程的習慣 —— 歸一化設計
wp.pay(100)
ap = AliPay()
payment(ap,100)
ap.pay(100)

app = ApplePay()
payment(app,100)
View Code 
規範
接口類
python天生支持多繼承，對於python來講抽象類和接口類沒有區別
接口類是python特有的，由於python直接用類就能夠實現接口的效果
python沒有‘接口這種數據類型，java中有
java語言是不支持多繼承的
from abc import ABCMeta,abstractmethod
class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass

class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        print('walk')
    def swim(self):
        print('swim')

class Parrot:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')

class Swan:
    def walk(self):
        print('walk')
    def fly(self):
        print('fly')
    def swim(self):
        print('swim')
View Code 
封裝：
封裝 成一個函數
封裝 成一個類
封裝：面向對象的特性
class A:
私有靜態屬性： __靜態屬性 = 'aaa'#私有屬性
    print(__靜態屬性)#__靜態屬性，_類名__名字
在一個變量以前 ，加上兩個雙下劃線是有特殊意義的
加上了這個雙下劃線，這個變量就變成私有的
print(A.__靜態屬性) #報錯 私有的名字不能在類的外部使用
print(A.__dict__)
print(A._A__靜態屬性)#從語法的角度上不容許你直接調用的
A.__wahaha = 'hahaha'#在一個類的外部是不可能定義一個私有的名字的
print(A.__dict__)
私有的對象屬性：
class Room:
    def __init__(self,owner,id,length,width,height):
        self.owner = owner
        self.id = id
        self.__length= length
        self.__width = width
        self.__height = height
    def area(self):
        return self.__lenght*self.__width
r = Room('文傑',302,2,1.5,0.5)
print(r.area())
View Code 
私有的方法：
不但願從外部去調用這個方法，不獨立完成一個功能，而是類總體完成某個功能的一部分。不能被子類繼承，在類的內部使用的時候自動變形：類__名字
class Student:
    對密碼進行加密
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd
    def __getpwd(self):
        return self.__pwd[::-1]
    def login(self):
        self.__getpwd()
Student().__getpwd
View Code 
面試題：
class A:
    def __init__(self):
        self.__func()   #self._A__func()
    def __func(self):
        print('A')
class B(A):
    def __func(self):
        print('B')
B()      # _B__func()


class A:
    def __init__(self):
        self.__func()
    def __func(self):  #_A__func
        print('A')
class B(A):
    # def __func(self):
    #     print('B')
    def __init__(self):
        self.func()   # _B__func()
B()
View Code 
名字：
公有的  在類的外部用  內部的 子類用
保護的  子類用  內不用
__私有的  在類的內部用
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程