设计-模式-CSDN博客

本文链接：https://blog.csdn.net/qq_18671803/article/details/121071081

一.七大设计原则

二.23种设计模式

1.创建型模式-5种

1.1单例模式

懒汉式

恶汉式

双检锁

静态内部类

枚举

1.2原型模式

1.3工厂方法模式

简单工厂

工厂方法

1.4抽象工厂模式

1.5建造者模式

2.结构型模式-7种

2.1代理模式

2.2适配器模式

2.3桥接模式

2.4装饰模式

2.5外观模式

2.6享元模式

2.7组合模式

3.行为型模式-11种

3.1模板方法模式

3.3命令模式

3.4责任链模式

3.5状态模式

3.6观察模式

3.7中介者模式

中介者模式(Mediator Pattern)：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，减少对象间混乱的依赖关系，从而使其耦合松散，而且可以独立地改变它们之间的交互。对象行为型模式。

Mediator（抽象中介者角色）：定义一个接口用于各同事之间的通讯。
ConcreteMediator（具体中介者角色）：它从具体的同事对象接受信息，向具体同事对象发出命令，负责协调同事之间的交互。
Colleague（抽象同事角色）：通过中介者对象与其它同事类进行交互，并定义所有相互影响的同事类的公共功能。
ConcreteColleague（具体同事角色）：继承于Colleague，每个具体同事类都知道本身在小范围内的行为，而不知道它在大范围内的目的。

abstract class AbstractChatClient {
    protected ChatMediator chatMediator;
    private String name;

    public ChatMediator getChatMediator() {
        return chatMediator;
    }

    public void setChatMediator(ChatMediator chatMediator) {
        this.chatMediator = chatMediator;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public AbstractChatClient(ChatMediator chatMediator, String name) {
        this.chatMediator = chatMediator;
        this.name=name;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

public class ChatClient extends AbstractChatClient {

    public ChatClient(ChatMediator chatMediator, String name) {
        super(chatMediator, name);
        chatMediator.register(this);
    }

    @Override
    public void send(String message) {
        System.out.println(super.getName()+"：发送消息"+message);
        this.chatMediator.sendMessage(this,message);
    }

    @Override
    public void receive(String message) {
        System.out.println(super.getName()+"接受消息："+message);
    }

    public static void main(String[] args) {
        ChatMediator chatRoom = new ChatRoom();
        AbstractChatClient chatClient1 = new ChatClient(chatRoom,"用户1");
        AbstractChatClient chatClient2 = new ChatClient(chatRoom,"用户2");
        AbstractChatClient chatClient3 = new ChatClient(chatRoom,"用户3");
        chatClient1.send("你好");
    }
}
abstract class ChatMediator {

    public abstract  void  register(ChatClient chatClient);
    public abstract  void  sendMessage(ChatClient chatClient,String message);
}
public class ChatRoom extends ChatMediator {
    private List<ChatClient> chatClientList=new ArrayList<>();
    @Override
    public void register(ChatClient chatClient) {
         chatClientList.add(chatClient);
    }

    @Override
    public void sendMessage(ChatClient chatClient, String message) {
        for (ChatClient client : chatClientList) {
            if (!client.equals(chatClient)){
                client.receive(message);
            }
        }
    }
}

什么场景用到？

SpringMVC 的 DispatcherServlet是一个中介者，他会提取Controller、Model、View来进行调用。而无需controller直接调用view之类的渲染方法
分布式系统中的网关
迪米特法则的一个典型应用
中介者和外观（门面）模式区别？
中介者双向操作，门面偏向于封装某一方

3.8迭代器模式

3.9访问者模式

3.10备忘录模式

3.11解释器模式

模板方法模式定义：定义一个算法的骨架，将一些可变的部门延迟到子类。模板方法模式可以是得子类在不改变算法骨架的情况下，即可重新定义算法的某些特定的步骤。

生活中的例子：煎饼果子，整套流程中，加东西的时候，老板会问你加什么，这里你就会参与到其中。

//模板方法
public class TemplateFunction {
    public static void main(String[] args) {
        UserManger userManger = new UserManger();
        userManger.action("admin","add");
    }
}
abstract class Manger{
        //登录验证
    public void action(String name,String method){
        //验证操作
        if("admin".equals(name)){
              excute(method);
        }else{
            System.out.println("没有权限");
        }
    }
    public abstract void excute(String method);
}
class UserManger extends Manger{

    @Override
    public void excute(String method) {
         if ("add".equals(method)){
             System.out.println("add");
         }
         if ("del".equals(method)){
             System.out.println("del");
         }
    }
}

3.2策略模式（Strategy Pattern）

策略模式（Strategy Pattern）：定义了一系列的算法，将每一种算法封装起来并可以相互

替换使用，策略模式让算法独立于使用它的客户应用而独立变化。

public class StrategyFunction {
    public static void main(String[] args) {

        UserService userService = new UserService();
        userService.setIsave(new FileSave());
        userService.saveFile("文件");
        userService.setIsave(new NetClass());
        userService.saveFile("文件");

    }
}
interface Isave{
//封装可变
    void save(String data);
}
class FileSave implements Isave{

    @Override
    public void save(String data) {
        System.out.println(data+"保存到磁盘");
    }
}
class NetClass implements Isave{

    @Override
    public void save(String data) {
        System.out.println(data+"保存到网络");
    }
}
abstract class BaseService{
//组合
    private Isave isave;

    public BaseService() {
    }

    public Isave getIsave() {
        return isave;
    }

    public void setIsave(Isave isave) {
        this.isave = isave;
    }

    public void saveFile(String data){
//面向接口编程，BaseService 就是算法的使用，就跟FileSave 没有关系，解耦。
//具体算法想用哪个，就传哪个。
        isave.save(data);
    }
}
class UserService extends BaseService{
    
}