设计模式

文章链接

　　重学 Java 设计模式：实战建造者模式 - 小傅哥 - 博客园 (cnblogs.com)

 

内容概要

　　一、什么是设计模式

　　二、接口

　　三、面向对象设计的SOLID原则

　　四、设计模式的归纳命名

 

1、什么是设计模式

　　设计模式是对软件开发过程中普遍出现的各种问题，进行的解决方案。每一个设计模式都是系统的命名、归纳、解释和评价了面向对象系统种一种重要的重复出现的设计。

　　简单的理解，就是每个设计模式是对不同问题解决方法的归纳

 

2、接口

　　接口规定了它子类的格式（它既有抽象方法，也有子类所共有的代码部分，避免代码重复）。

　　更正:接口最好不应该具有具体的实现,它最好时纯抽象的

from abc import ABCMeta, abstractmethod

# 定义一个抽象类
class Payment(metaclass=ABCMeta):
    @abstractmethod  # 抽象方法
    def pay(self, money):
        pass


class WeChatPay(Payment):  # 继承了Payment的子类必须实现pay方法
    def pay(self, money):  # 并且参数必须保持一致
        print("微信支付了{}元".format(money))


class ZhiFuBaoPay(Payment):
    def pay(self, money):
        print("支付宝支付{}元".format(money))


pay1 = WeChatPay()
pay1.pay(100)

 

　　或者是间接的使用了其它类

　　更正:说是接口可能不对,也许更接近于api

class Cpu:
    @staticmethod
    def run():
        print("CPU运行了")

    @staticmethod
    def stop():
        print("CPU关闭了")


class Disk:
    @staticmethod
    def run():
        print("硬盘运行了")

    @staticmethod
    def stop():
        print("硬盘关闭了")


class Memory:
    @staticmethod
    def run():
        print("内存运行了")

    @staticmethod
    def stop():
        print("内存关闭了")


class Computer:
    def __init__(self):
        self.cpu = Cpu()
        self.disk = Disk()
        self.memory = Memory()

    def run(self):
        self.cpu.run()
        self.disk.run()
        self.memory.run()

    def stop(self):
        self.cpu.stop()
        self.disk.stop()
        self.memory.stop()

 

3、面向对象设计的SOLID5大原则

　　（1）开放封闭原则：一个软件实体如类、模块和函数都应该对扩展功能开放，对代码修改关闭。即软件实体应该在尽量不修改源代码的基础上拓展功能。

　　（2）里氏替换原则：所有引用父类的地方必须可以透明的引用其子类的对象。

#里氏替换原则
class User:
    def __init__(self, name):
        self.name = name

    def show_name(self):
        print("用户名字为{}".format(self.name))

        
class VIP(User):
    def show_name(self):
        print("尊贵的vip用户，您的用户名为{}".format(self.name))

　　（3）依赖倒置原则：高层模块不应该依赖底层模块，二者都应该依赖其抽象；抽象不应该依赖于细节，细节应该依赖于抽象。

#里氏替换原则
class User:
    def __init__(self, name):
        self.name = name

    def show_name(self):
        print("用户名字为{}".format(self.name))


class VIP(User):
    def show_name(self):
        print("尊贵的vip用户，您的用户名为{}".format(self.name))

# 依赖倒置原则
from abc import ABCMeta, abstractmethod


class BuyInterface(metaclass=ABCMeta):  # 高层和底层所依赖的抽象
    @abstractmethod
    def buy(self, good, quantity):
        pass


# 底层模块
class TaoBaoBuy(BuyInterface):
    def buy(self, good, quantity):
        print("您购买了商品{}{}件".format(good, quantity))


class JDBuy(BuyInterface):
    def buy(self, good, quantity):
        print("您购买了商品{}{}件".format(good, quantity))


# client（高层模块）
t = TaoBaoBuy()
t.buy("薯条", 8)

　　（4）接口隔离原则：使用多个专门的接口，而不使用一个总接口。即客户端不应该依赖其不需要使用的接口。

　　　　错误的

class Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        pass

    @abstractmethod
    def swim(self):
        pass

    @abstractmethod
    def fly(self):
        pass


class Tiger(Animal):
    def walk(self):
        print("在走路")

    def swim(self):  # 老虎不会游泳
        print("在游泳")

    def fly(self):  # 也不会飞
        print("在飞")


class Bird(Animal):
    def walk(self):
        print("在走路")

    def swim(self):  # 小鸟不会游泳
        print("在游泳")

    def fly(self):
        print("在飞")

　　　　正确的

class LandAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        pass


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


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


class Tiger(LandAnimal):
    def walk(self):
        print("在走路")


class Bird(LandAnimal, SkyAnimal):
    def walk(self):
        print("在走路")

    def fly(self):
        print("在飞")

　　（5）单一责任原则：只允许最多一种因素影响到类的变更。即一个类只负责一个职责。

 

4、设计模式的归纳命名

　　创建型模式（针对对象的创建的一些模式）

　　　　简单工厂模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式

　　结构型模式（针对类之间关系的一些模式）

　　　　适配器模式、桥模式、外观模式、组合模式、享元模式、代理模式、装饰模式

　　行为型模式

　　　　解释器模式、责任链模式、命令模式、迭代模式、观察者模式、备忘录模式、中介模式、状态模式、访问者模式、策略模式、模块方法模式