设计模式-基础概念入门

创建型

工厂方法：隔离创建对象的细节，使得创建对象的行为可扩展

抽象工厂：该模式抽象出一组相关对象的接口

建造者：与工厂不同的是，该模式包含了对象构造的若干过程

原型：用于以某个对象为模子创建一个新对象的场景，例如幻灯片中的母版与普通页、对象的克隆

单例

结构型

适配器：处理遗留系统的不二法宝，也可以用空方法实现接口作为抽象父类

桥接：使用关联代替继承，解决类多维度的扩展导致的类爆炸问题

组合：将组件组装为整体使用

装饰：常见于各种wrapper，常用于在原函数执行前后做一些额外的工作

外观：封装扇出，利用树状减少调用者的复杂度

假设我们有一个计算机类，它有许多复杂的子系统，如CPU、内存、硬盘等。我们可以使用外观模式来隐藏这些子系统的复杂性，提供一个简单的接口给客户端使用。

public class Computer {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;

public Computer() {
this.cpu = new CPU();
this.memory = new Memory();
this.hardDrive = new HardDrive();
}

public void start() {
cpu.start();
memory.start();
hardDrive.start();
}

public void shutdown() {
cpu.shutdown();
memory.shutdown();
hardDrive.shutdown();
}
}

``` 然后，我们定义一个外观类，它提供了一个简单的接口给客户端使用：

public class ComputerFacade { private Computer computer; public ComputerFacade() { this.computer = new Computer(); } public void start() { computer.start(); } public void shutdown() { computer.shutdown(); } }

最后，我们可以使用外观类来启动和关闭计算机：

public class Client { public static void main(String[] args) { ComputerFacade computerFacade = new ComputerFacade(); computerFacade.start(); // do some work computerFacade.shutdown(); } }

在这个示例中，客户端只需要使用外观类提供的简单接口来启动和关闭计算机，而不需要了解计算机的复杂子系统。外观类将客户端的请求委托给计算机类进行处理。

亨元模式（Flyweight Pattern）是一种结构型设计模式，它旨在通过共享对象来最大程度地减少内存使用和对象创建的开销。该模式适用于需要创建大量相似对象的情况，通过共享这些对象的公共部分，可以节省内存空间。在Java中，我们可以使用亨元模式来实现对象的共享。下面是一个简单的示例，展示了如何使用亨元模式来共享字符串对象：

import java.util.HashMap;
import java.util.Map;

public class FlyweightPatternExample {
private static final Map<String, String> flyweights= new HashMap<>);
public static String getSharedString(String key) {
if (!flyweights.containsKey(key)) {
flyweights.put(key, new String(key));
return flyweights.get(key);
public static void main(Stringll args) {
String str1 = getSharedString("Hello");
String str2= getSharedString("World"):
String str3 = getSharedString("Hello");
System.out.println(str1 == str2); // false
System.out.println(str1 == str3); // true
}

在上面的示例中，`getSharedString`方法用于获取共享的字符串对象。如果该字符串对象已经存在于`flyweights`缓存中，则直接返回该对象；否则，创建一个新的字符串对象并将其添加到缓存中。通过使用亨元模式，我们可以看到`str1`和`str3`实际上引用了同一个字符串对象，而`str2`引用了另一个不同的字符串对象。这样，通过共享相同的字符串对象，我们可以节省内存空间，并提高程序的性能。

享元模式的优势在于共享内部状态，减少对象的创建和内存占用。而外部状态则是不可共享的，需要在使用时传递给享元对象。

举个例子，假设有一个游戏中的棋盘，棋盘上有很多棋子，每个棋子都有自己的颜色和位置。如果使用传统的方式创建棋子对象，每个棋子都会占用一定的内存空间。但是如果使用享元模式，可以将棋子的颜色作为内部状态，而位置作为外部状态。这样，如果有多个棋子颜色相同，那么它们可以共享同一个内部状态，减少内存占用。而每个棋子的位置则是不同的，需要在使用时传递给享元对象。如果棋盘上的棋子数量很多，使用享元模式可以大大减少内存占用，提高程序的性能。但是如果每个棋子的颜色都不同，那么就无法共享内部状态，享元模式的优势就会减弱。

行为型

解释器：一般用于解释执行自定义的某种语法

模版方法：框架与钩子

责任链：责任链模式是一种行为设计模式，它允许多个对象按照顺序处理请求，直到其中一个对象能够处理请求为止。每个对象都可以选择将请求传递给下一个对象，也可以选择自己处理请求。

abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(int request);
}

class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("ConcreteHandler1 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandler2 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println("ConcreteHandler3 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        handler1.handleRequest(5);
        handler1.handleRequest(15);
        handler1.handleRequest(25);
    }
}

命令：将行为抽象和解耦

迭代器：封装数据的访问行为（顺序、可见性等）

中介者：用一个中介对象来封装一系列的交互；新增一个模块处理两个模块的交互

备忘录模式：将当前对象的状态信息保存为一个对象，使得当前对象可以基于状态镜像快速恢复原状态

观察者：订阅、发布模型，用于事件驱动的设计

状态：封装FSM（有限状态机）的状态与状态转移，每个状态定义了自身的输入与状态转移

策略：使用接口即使用strategy，用于隔离变化

访问者：数据与行为分离方法。通过这种分离，可达到一个被访问者动态添加新的操作而无需做其他的修改的效果

posted @ 2023-09-27 08:39 Adom_ye 阅读(1) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Adam_ye

设计模式-基础概念入门

创建型

结构型

行为型

公告