面向对象>>>抽象类>>>鸭子类型

一.抽象类:

　　假如老板让你实现一个QQ,支付宝,支付功能

你是这样做的:

class QQ:
    def pay(self,money):
        print("您用QQ支付了%s" % money)

class Ali:
    def pay(self,money):
        print("您用QQ支付宝了%s" % money)

q1 = QQ()
q1.pay(100)
a1 = Ali()
a1.pay(200)

　　老板说这样不好你在改改

改完的:

class QQ:
    def pay(self, money):
        print("您用QQ支付了%s" % money)

class Ali:
    def pay(self, money):
        print("您用QQ支付宝了%s" % money)
def pay(obj,money):
    obj.pay(money)

# q1 = QQ()
# a1 = Ali()

# pay(q1,100)  # 统一化设计
# pay(a1,200)

老板一看;不错

　　可是公司来了一个野生程序员这个项目给他了

要求添加一个微信支付,

他是这样写的:

class QQ:
    def pay(self, money):
        print("您用QQ支付了%s" % money)

class Ali:
    def pay(self, money):
        print("您用QQ支付宝了%s" % money)

class Wechat:
    def wechat_pay(self,money):
        print("您用微信支付宝了%s" % money)

def pay(obj,money):
    obj.pay(money)

# q1 = QQ()
# a1 = Ali()
# w1 = Wechat()
# pay(q1,100)  # 统一化设计
# pay(a1,200)
w1.wechat_pay(500)

老板一看不行啊:拿回去重写

拿回来一看明白了:

改良过的:

class QQ:
    def pay(self, money):
        print("您用QQ支付了%s" % money)

class Ali:
    def pay(self, money):
        print("您用QQ支付宝了%s" % money)

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

def pay(obj,money):
    obj.pay(money)

# q1 = QQ()
# a1 = Ali()
# w1 = Wechat()
# pay(q1,100)  # 统一化设计
# pay(a1,200)
# pay(w1,300)

　　工作时候为了避免这种规范,我要制定一个规范

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("您用QQ支付宝了%s" % money)

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

def pay(obj,money):
    obj.pay(money)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
pay(q1,100)  # 统一化设计
pay(a1,200)
pay(w1,300)

　　如果你碰到那种纯纯的他是真不会的你也可以这样做:

from abc import  ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self):pass
class QQ(Payment):   #抽象类,或者接口类:执行一个规范
    def pay(self, money):
        print("您用QQ支付了%s" % money)

class Ali(Payment):
    def pay(self, money):
        print("您用QQ支付宝了%s" % money)

class Wechat:
    def apay(self,money):  #未按照规范方法
        print("您用微信支付宝了%s" % money)

def pay(obj,money):
    obj.pay(money)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
pay(q1,100)  # 统一化设计
pay(a1,200)
pay(w1,300) # 未按照规范的方法 报错
#用处:在工作中,如果你要是规定及各类必须有一样的方法,
# 你要抽象类,指定一个规范,强制其有此方法

#python没有多态的概念,但是python崇尚鸭子类型

定义变量的方法:

　　1.java C#: 需要定义类型 int i = 3 str i = alex

　　2.java C#:没有多继承的概念

　　python:

　　　　i = 1

　　　　i = "alex"

鸭子类型: 它看着像鸭子,那么它就是鸭子

比如说:

　　# str list tuple

s1 = "alex"

s2 = str('123')

class Str:
    def index(self):
        pass
class List:
    def index(self):
        pass
class Tuple:
    def index(self):
        pass
#python中好多不同类但同名的方法不是强制规定,而是预定俗称像上面这三种类,
同样具有index方法,而且功能相似.

面向对象>>>抽象类>>>鸭子类型

猜你喜欢