简介：

备战软考中级软件设计师，设计模式模块占分高、考点深？本文专为高效备考打造！

直击考点：逐条解析23种设计模式的核心意图与适用场景，搭配UML类图快速理解模式本质，告别抽象理论。
代码实战：提供Java语言示例源码（附完整下载链接），通过真实场景还原设计模式应用，助你打通理论与编码的断层。
提分利器：精选历年高频考题+原创模拟题库，覆盖创建型、结构型、行为型三大类模式，附详细答案解析，考前冲刺必备。
应试技巧：总结判卷标准与答题模板，教你避开“只懂模式不会答题”的坑，精准锁定得分点。

适合人群：时间紧迫的软考冲刺者、设计模式基础薄弱的开发者、需快速掌握模式实战应用的编程学习者。

👉 立即学习：下载源码文件，搭配练习题查漏补缺，一次过关！

一、设计模式基本概念

分类

创建模式：5种

结构模式：7种

行为模式：11种

需求

设计模式的核心在于提供相关的解决方案，使可以复用成功的设计和体系结构

4个要素

模式名称

问题

解决方案

效果

二十三种设计模式

注意：终结为中介

结构型记忆方案：桥代理组装适配器，享元回家装饰外观

例题

二、创建型设计模式

类：

工厂方法（factory method）

对象：

抽象工厂（abstract factory ）

单例（Singleton）

原型（prototype）

生成器（Builder ）

扩展：简单工厂模式（Simple Factory）

别名：静态工厂方法（static factory method）
定义一个工厂类，它可以根据参数的不同，返回不同类的实例。把创建的实例通常具有共同的父类
缺点：违反了开闭原则
UML图

public class SimpleFactory {
    public static void main(String[] args) {
        
        Product  productA= Factroy.createProduct("A");
        productA.info(); // 输出结果A
        Product  productB= Factroy.createProduct("B");
        productB.info(); // 输出结果B
    }
}
// 简单工厂
class Factroy{
    public static Product createProduct(String type){
        Product product = null;
        switch (type){
            case "A":
                product= new ProductA();
                break;
            case "B":
                product = new ProductB();
                break;
            default:
                System.out.println("error");
                break;
        }
        return  product;
    }
}
// 产品
abstract class Product{
    abstract void info();
}
// 基本产品A
class ProductA extends  Product{
    @Override
    void info() {
        System.out.println("A");
    }
}
// 基本产品B
class ProductB extends  Product{
    @Override
    void info() {
        System.out.println("B");
    }
}

工厂方法模式（Factory Method）

意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例延迟到其子类
适用性

UML图

package factoryMethod;
public class FactoryMethod{
    public static void main(String[] args) {
        Product productA= new FactoryA().createProdcut();
        productA.info();
        Product productB=  new FactoryB().createProdcut();
        productB.info();
    }
}
// 产品类
interface Product {
    void info();
}
// 工厂类
interface Factory{
    Product createProdcut();
}
//具体产品1
class  ProductA implements Product{
    public void info(){
        System.out.println("A");
    }
}
// 具体工厂A
class FactoryA implements Factory{
    @Override
    public Product createProdcut(){
        return  new ProductA();
    }
}
//具体产品1
class  ProductB implements Product{
    public void info(){
        System.out.println("B");
    }
}
// 具体工厂A
class FactoryB implements Factory{
    @Override
    public Product createProdcut(){
        return  new ProductB();
    }
}

抽象工厂模式（Abstract Factory）

意图：提供一个创建一条相关或下相互依赖对象的接口，而无须指定它们具体的类
适用性

UML图

package AbstractFactory;
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new Factory1();
        factory1.createProductA().info();
        factory1.createProductB().info();
        
        AbstractFactory factory2 = new Factory2();
        factory2.createProductA().info();
        factory2.createProductB().info();
    }
}
// 抽象工厂
interface AbstractFactory{
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}
// 具体工厂1生产A1和B1产品
class Factory1 implements AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}
// 具体工厂2生产A2和B2产品
class Factory2 implements  AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}
// 抽象产品A
interface AbstractProductA{
    void info();
}
// A1
class  ProductA1 implements AbstractProductA{
    @Override
    public void info(){
        System.out.println("A1");
    }
}
// A2
class  ProductA2 implements AbstractProductA{
    @Override
    public void info(){
        System.out.println("A2");
    }
}
// 抽象产品B
interface  AbstractProductB{
    void info();
}
// B1
class  ProductB1 implements AbstractProductB{
    @Override
    public void info(){
        System.out.println("B1");
    }
}
// B2
class  ProductB2 implements AbstractProductB{
    @Override
    public void info(){
        System.out.println("B2");
    }
}

例题1

例题2

生成器模式（Builder）

意图：将一个，使得同样的构建可以创建不同的表示
适用性：

UML图

解释：

package Builder;
import com.sun.org.apache.xpath.internal.XPathAPI;
import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        Director director  = new Director();
        // 装配产品1
        Builder builder1= new ConcreteBuilder1();
        director.Construct(builder1);
        builder1.getResult().show();
        // 装配产品2
        Builder builder2 = new ConcreteBuilder2();
        director.Construct(builder2);
        builder2.getResult().show();
    }
}
// 产品
class Product{
    List<String> parts = new ArrayList<>();
    // 添加零件
    public  void add(String part){
        parts.add(part);
    }
    // 打印零件
    public void show(){
        System.out.println("================");
        for (String part : parts) {
            System.out.println(part);
        }
        System.out.println("================");
    }
}
// 抽象生成器
interface  Builder{
    void builbderPart();
    Product getResult();
}
// 具体生成器
 class ConcreteBuilder1 implements  Builder{
  private  Product product = new Product();
     @Override
     public void builbderPart() {
         product.add("零件A1");
         product.add("零件B1");
     }
     @Override
     public Product getResult() {
         return this.product;
     }
 }
// 具体生成器
class ConcreteBuilder2 implements  Builder{
    private  Product product = new Product();
    @Override
    public void builbderPart() {
        product.add("零件A2");
        product.add("零件B2");
    }
    @Override
    public Product getResult() {
        return this.product;
    }
}
// 导演：使用生成器
class Director{
    
    // 构建装配方式
    public void Construct(Builder builder){
        builder.builbderPart();
    }
}

例题1

例题2

例题3

答案：ACAD

A选项：为原型模式

原型模式（Prototype）

意图：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
适用性：

UML图：

解释：

package protoType;
public class Client {
    public static void main(String[] args) {
        Prodcut prodcut = new Prodcut("产品1",1.11);
        System.out.println(prodcut.toString());
        Prodcut clone = (Prodcut) prodcut.clone();
        System.out.println(clone.toString());
    }
}
interface ProtoType{
    Object clone();
}
// 克隆产品类
class  Prodcut  implements  ProtoType{
    private  String name ;
    private  double weight;
    public Prodcut(){
    }
    public Prodcut(String name, double weight){
        this.name =name;
        this.weight=weight;
    }
    @Override
    public Object clone() {
        Prodcut prodcut = new Prodcut(this.name,this.weight);
        return prodcut;
    }
    @Override
    public String toString() {
        return "Prodcut{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
}

单例模式（Singleton）

意图：
适用性：

UML图：

package Singleton;
public class Test {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.uniqueInstance();
        Singleton singleton2 = Singleton.uniqueInstance();
        singleton2.setNum(1);
        System.out.println(singleton1.toString());
        singleton2.setNum(3);
        System.out.println(singleton2.toString());
        System.out.println(singleton2.toString());
    }
}
class  Singleton{
    private  int num;
    private static Singleton singleton;
    private  Singleton(){
    }
    public void setNum(int num) {
        this.num = num;
    }
    // 入口
    public static  Singleton uniqueInstance(){
        if (singleton==null) {
            singleton = new Singleton();
        }
        return singleton;
    }
    @Override
    public String toString() {
        return "Singleton{" +
                "num=" + num +
                '}';
    }
}

例题1

例题2

例题3

三、结构型设计模式

类：

适配器模式

对象：

适配器模式

代理模式

桥接模式

组合模式

装饰模式

外观模式

享元模式

考过次数（2022年以前）

适配器模式（Adapter）

意图：将一个类的接口转换成客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

例如：USB接口转成type-C接口

适用性：

扩展：多态的缺点：使用不了子类特有的方法

类模式（了解）

类模式适用多重继承对一个接口与另一个接口进行匹配。
UML图

对象模式

对象适配器依赖于对象组合
UML图

package adapter;
public class client {
    public static void main(String[] args) {
        Target adapter = new Adapter();
        adapter.request();
    }
}
// 目标
class Target{
    public void request(){
        System.out.println("USB接口");
    }
}
// 通过适配器适配让USB类型接口可以转换成Type—C接口
class Adapter extends Target{
    private  Adaptee adaptee = new Adaptee();
    @Override
    public void request(){
            adaptee.SpecificRequest();
    }
}
// 被适配
class Adaptee{
    public void SpecificRequest(){
        System.out.println("Type—C接口");
    }
}

例题

桥接模式（Bridge）

意图：将抽象部分与其实现部分分离，使它们都可以独立地变化
适用性：

理解：比如说抽象产品有产品A和产品B和产品C，但是产品ABC又分出了红色、黄色、绿色三中，直接适用继承的话，耦合度太高了。

所以我们将颜色抽象分离出来，分别设置各种颜色，并在抽象产品中留出设置颜色的类。就可以将产品和颜色桥接在在一起了。

UML图：

package Bridge;
public class Test {
    public static void main(String[] args) {
        AbstractProduct productA = new ProductA();
        productA.setName("apple");
        productA.setColor(new Red());
        productA.Operation();
    }
}
//抽象产品
abstract class  AbstractProduct{
    private  String name;
    // 受保护的
    protected Color color= null;
    public void setName(String name) {
        this.name = name;
    }
    public void setColor(Color color) {
        this.color = color;
    }
    public String getName() {
        return name;
    }
    abstract void Operation();
}
// 具体产品
class  ProductA extends  AbstractProduct{
    @Override
    void Operation() {
        color.OperationImp(getName());
    }
}
// 依赖抽象产品的一部分：例如：手机中的颜色
interface  Color{
    // 行为实现
    void OperationImp(String name);
}
class  Red implements  Color{
    @Override
    public void OperationImp(String name) {
        System.out.println(name +":Red");
    }
}
class  Green implements  Color{
    @Override
    public void OperationImp(String name) {
        System.out.println(name +":Green");
    }
}

例题1

答案：AD

例题2

答案：DABA

例题3

答案：CDAB

组合模式（Composite）

意图：将对象组合成树结构以表示“部分-整体”的层次结构，Composite使得用户对单个对象和组合对象的使用具有一致性。
理解：文件和文件夹。文件夹包含文件。文件夹是整体，文件时部分。

适用性：

UML图

package composite;
import java.util.ArrayList;
import java.util.List;
public class Client {
    public static void main(String[] args) {
        AbstractFile abstractFile = new Folder("/");
        AbstractFile folder1 = new Folder("folder1");
        AbstractFile folder2 = new Folder("folder2");
        AbstractFile file1 = new File("file2");
        AbstractFile file2 = new File("file2");
        abstractFile.add(folder1);
        abstractFile.add(file1);
        folder1.add(folder2);
        folder1.add(file2);
        AbstractFile folder3 = new Folder("folder3");
        AbstractFile file3 = new File("file");
        folder2.add(folder3);
        folder2.add(file3);
        printFileName(abstractFile);
    }
    // 遍历文件名
    public static void  printFileName(AbstractFile abstractFile){
        abstractFile.print();
        List<AbstractFile> child = abstractFile.getChild();
        if(child==null){
            return;
        }
        for (AbstractFile file : child) {
         printFileName(file);
        }
    }
}
abstract  class  AbstractFile{
    protected  String name;
    public AbstractFile(){
    }
    public AbstractFile(String name){
        this.name=name;
    }
    public void print(){
        System.out.println(name);
    }
    // 添加文件或文件夹
    public abstract  boolean add(AbstractFile abstractFile);
    // 删除文件或文件夹
    public  abstract  boolean remove(AbstractFile abstractFile);
    // 获取文件夹中的文件和文件夹
    public abstract List<AbstractFile> getChild();
}
// 文件架
class  Folder extends  AbstractFile{
    public Folder(String name){
        super(name);
    }
    private List<AbstractFile> abstractFileList = new ArrayList<>();
    @Override
    public boolean add(AbstractFile abstractFile) {
        return abstractFileList.add(abstractFile);
    }
    @Override
    public boolean remove(AbstractFile abstractFile) {
        return abstractFile.remove(abstractFile);
    }
    @Override
    public List<AbstractFile> getChild() {
        return  abstractFileList;
    }
}
class  File extends AbstractFile{
    public  File(String name){
        super(name);
    }
    @Override
    public boolean add(AbstractFile abstractFile) {
        return false;
    }
    @Override
    public boolean remove(AbstractFile abstractFile) {
        return false;
    }
    @Override
    public List<AbstractFile> getChild() {
        return null;
    }
}

例题1

例题2

例题3

装饰器模式（Decorator）

意图：动态地给一个对象添加一些额外的职责，就增加功能而言，该模式比生成模块更加灵活。
适用性：

UML图：

package decorator;
public class Client {
    public static void main(String[] args) {
        new ConcreteDecoraterB(new ConcreteDecoraterA(new Student("张三"))).Operation();
    }
}
// 第一步创建人的抽象类
abstract class Person{
    String name;
    public Person(){
    }
    public Person(String name){
        this.name = name;
    }
    // 职责
    abstract  void Operation();
}
// 学生类
class  Student extends Person{
    public Student(){
    }
    public Student(String name){
        super(name);
    }
    @Override
    void Operation() {
        System.out.print("张三"+"学生的职责为：学习");
    }
}
// 第三步：创建抽象适配器类并继承Person
abstract  class Decorater extends Person{
    protected  Person person ;
  public Decorater (){
  }
  public Decorater(Person  person ){
        this.person =person;
  }
}
// 具体的职责类
class ConcreteDecoraterA extends  Decorater{
    public ConcreteDecoraterA(Person person){
        super(person);
    }
    @Override
    void Operation() {
        person.Operation();
        System.out.print("   快乐");
    }
}
class ConcreteDecoraterB extends  Decorater{
    public ConcreteDecoraterB(Person person){
        super(person);
    }
    @Override
    void Operation() {
        person.Operation();
        System.out.print("   睡觉");
    }
}

例题1

外观模式（Facade）

意图：为子系统中的一组接口提供一个一致的界面。Facade模式定义了一个高层接口，这个接口使得这个子系统更加容易适用。
适用性：

package facade;
public class Test {
    public static void main(String[] args) {
        // 可以通过一个外观类直接适用子系统的方法
        Facade facade = new Facade();
        facade.print1();
        facade.print2();
        facade.print3();
    }
}
// 外观类
class Facade{
    SubSystem1 subSystem1;
    SubSystem2 subSystem2;
    SubSystem3 subSystem3;
    public Facade(){
        // 初始哈子系统
        subSystem1 = new SubSystem1();
        subSystem2=new SubSystem2();
        subSystem3 = new SubSystem3();
    }
    public void print1(){
        subSystem1.printA();
    }
    public void print2(){
        subSystem2.printA();
    }
    public void print3(){
        subSystem3.printA();
    }
}
// 子系统类1
class SubSystem1{
    // 有一个打印方法
    public void printA(){
        System.out.println("subSystem1");
    }
}
// 子系统类2
class SubSystem2{
    // 有一个打印方法
    public void printA(){
        System.out.println("subSystem2");
    }
}
// 子系统类3
class SubSystem3{
    // 有一个打印方法
    public void printA(){
        System.out.println("subSystem3");
    }
}

例题1

例题2

享元模式（Flyweight）

意图：运用共享技术有效地支持大量细颗粒度的对象。
理解：在享元工厂中写一个方法，如果没有该对象没有创建过就new一个，如果创建过了就将对象复制给它。
适用性：

UML图：

package flyweight;
import java.awt.*;
import java.util.HashMap;
import java.util.Map;
public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Product red = factory.getFlyweight("red");
        Product red1 = factory.getFlyweight("red");
        Product red2 = factory.getFlyweight("red");
        Product red3 = factory.getFlyweight("red");
        System.out.println(red);
        System.out.println(red1);
        System.out.println(red2);
        System.out.println(red3);
        /**
         * 
         * 
         * 结果：都是一个对象
         flyweight.Canvas@4554617c
         flyweight.Canvas@4554617c
         flyweight.Canvas@4554617c
         flyweight.Canvas@4554617c
         */
        /
    }
}
// 抽象产品的享元类
abstract class  Product{
    protected String name;
    protected String color;
    public Product(){
    }
    public Product(String color){
        this.color = color;
    }
    abstract void operation();
}
// 画布
class Canvas extends  Product{
    public Canvas(String color){
        super(color);
    }
    @Override
    void operation() {
        System.out.println("画布的颜色为："+color);
    }
}
// 享元工厂
class  FlyweightFactory{
    Map<String, Product> map = new HashMap<>();
    public Product getFlyweight(String color){
        if (!map.containsKey(color)){
            map.put(color,new Canvas(color));
        }
        return map.get(color);
    }
}

例题1

代理模式（Proxy）

意图：为其他对象提供一种代理以控制对这个对象的访问。
例如：商品代购（你代理我去做这件事）
适用性：

UML图：

package proxy;
public class Client {
    public static void main(String[] args) {
        Subject proxy = new Proxy(new RealSubJect());
        proxy.Request();
    }
}
interface Subject{
    void Request();
}
// 买家
class  RealSubJect implements  Subject{
    @Override
    public void Request() {
        System.out.println("买车");
    }
}
// 代理商收到请求，代替行为
class Proxy implements  Subject{
    Subject realSubJect ;
    public Proxy(Subject subject){
        this.realSubJect= subject;
    }
    @Override
    public void Request() {
        realSubJect.Request();
    }
}

例题1

三、行为性设计模式

考点分布（2021年前）

责任链模式（chain Responsibility）

意图：使多个对象都有机会处理请求，从而避免请求的发送者和接收者间的耦合关系，将这些对象联系成一条链，并沿着这条链传递请求，直到有一个对象处理它位置。
例如：学生找辅导员批请假条，时间在1天内，可以通过，1到7天，需要院长，7天到30天需要校长。

适用性：

UML图：

package chainResponsibility;
public class Client {
    public static void main(String[] args) {
        // 教师<院长<校长
        Handle handle  = new Teacher(1, new Teacher(7,new Teacher(30,null)));
        handle.handleRequest(31);
    }
}
abstract class Handle{
    protected  Handle handle;
    protected int day;
    public Handle(){
    }
    public Handle (int day ,Handle handle){
        this.handle = handle;
        this.day = day;
    }
    abstract void handleRequest(int day);
}
// 学校领导
class Teacher extends Handle{
        public Teacher(int day ,Handle handle){
            this.day = day;
            this.handle = handle;
        }
    @Override
    void handleRequest(int day) {
        if(day  <=this.day){
            System.out.println("审核过");
        }else{
            if (handle!=null){
                System.out.println("===============");
                System.out.println(this.handle);
                System.out.println(this.day);
                System.out.println("===============");
                handle.handleRequest(day);
            }else{
                System.out.println("无法审批");
            }
        }
    }
}

代码结果示例

命令模式（Command）

意图：将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化，对请求排队或记录请求日志以及支持可撤销的操作。
理解：请求者--->给一个具体的命令---->接收者对请求操作。

例如：遥控器发出开关机请求，电视机作为接收者执行开关机

适用性：

UML图：

package command;
import com.sun.org.apache.regexp.internal.RE;
public class Client {
    public static void main(String[] args) {
        Invoker invoker = new Invoker();
        Receiver receiver = new Receiver();
        OffConcreteCommand offConcreteCommand  = new OffConcreteCommand(receiver);
        OnConcreteCommand onConcreteCommand = new OnConcreteCommand(receiver);
        invoker.setCommand(offConcreteCommand);
        invoker.call();// 关机
    }
}
//遥控器
class  Invoker{
    protected  Command command;
    public void setCommand(Command command) {
        this.command = command;
    }
    public Command getCommand() {
        return command;
    }
    public void call(){
        command.Execute();
    }
}
// 命令接口
abstract class Command{
    protected   Receiver receiver;
    public Command(Receiver receiver){
        this.receiver = receiver;
    }
    public void setReceiver(Receiver receiver) {
        this.receiver = receiver;
    }
    // 执行方法
    abstract void  Execute();
}
// 开机具体命令类
class OnConcreteCommand extends Command{
    public OnConcreteCommand(Receiver receiver) {
        super(receiver);
    }
    @Override
    public void Execute() {
        receiver.action("on");
    }
}
// 关机
class OffConcreteCommand extends Command{
    public OffConcreteCommand(Receiver receiver) {
        super(receiver);
    }
    @Override
    public void Execute() {
        receiver.action("off");
    }
}
// 电视机
class  Receiver{
    public void action(String command){
        if (command=="on") {
            System.out.println("开机");
        } else if (command=="off") {
            System.out.println("关机");
        }else{
            System.out.println("错误命令");
        }
    }
}

例题1

例题2

解释器模式（Interpreter）

意图：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器适用该表示来解析语言中句子。
例如：程序设计语言中的，上下文无关文法
适用性：

UML图：

示例代码：

package interpreter;
import java.util.HashSet;
import java.util.Set;
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.check("A区的老师");
        context.check("C区的小孩");
        context.check("f区的小孩");
    }
}
// 上下文环境
class Context{
    String[] region =  {"A区","B区","C区"};
    String[] person ={"小孩","青年","老师"};
    private  NoterminalExpression noterminalExpression;
    private TerminalExpression regionCheck;
    private TerminalExpression persionCheck;
    public Context(){
        regionCheck = new TerminalExpression(region);
        persionCheck =new TerminalExpression(person);
        noterminalExpression = new NoterminalExpression(regionCheck,persionCheck);
    }
    public void check(String info){
        if (noterminalExpression.interpreter(info)) {
            System.out.println("success");
        }else{
            System.out.println("error");
        }
    }
}
abstract class AbstractExpression{
    abstract  boolean interpreter(String info);
}
class NoterminalExpression extends  AbstractExpression{
    private  TerminalExpression region ;
    private TerminalExpression person;
    public NoterminalExpression(TerminalExpression region,TerminalExpression person){
        this.person = person;
        this.region  = region;
    }
    @Override
    boolean interpreter(String info) {
        String[]  checks = info.split("的");
        return region.interpreter(checks[0]) && person.interpreter(checks[1]);
    }
}
// 终结符
class TerminalExpression extends  AbstractExpression{
    private Set<String> strings = new HashSet<>();
    public TerminalExpression (String[] strs){
        for (String str : strs) {
            strings.add(str);
        }
    }
    @Override
    boolean interpreter(String info) {
        return strings.contains(info);
    }
}

迭代器（Iterator）

意图：用一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象大的内部表示。
例如：Java中集合的迭代器

package Interator;
import java.time.Period;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
    public static void main(String[] args) {
        Set<Person> people = new HashSet<>();
        people.add(new Person("张三",13));
        people.add(new Person("李四",33));
        people.add(new Person("王五",32));
        Iterator<Person> iterator = people.iterator();
        while(iterator.hasNext()){
            Person next = iterator.next();
            System.out.println(next.toString());
        }
    }
}
// 对象类
class  Person{
    private  String name;
    private int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

适用性：

UML图：

实例代码：

package Interator;
public class Test {
    public static void main(String[] args) {
        Person[] people =  {
                new Person("张三",1),
                new Person("李四",12),
                new Person("王五",13),
               
        };
        ConcreteAggregate concreteAggregate = new ConcreteAggregate(people);
        Interator iterator = concreteAggregate.createIterator();
        while (iterator.haxNext()){
            System.out.println(iterator.next());
        }
    }
}
// 对象类
class  Person{
    private  String name;
    private int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
// 迭代器接口
abstract class   Interator{
    protected int index=0;
    protected Aggregate aggregate;
    public Interator(Aggregate aggregate){
        this.aggregate= aggregate;
    }
    abstract boolean haxNext();
    abstract  Object next();
}
// 具体迭代器
class  ConcreteInterator extends Interator{
    public ConcreteInterator(Aggregate aggregate) {
        super(aggregate);
    }
    @Override
    boolean haxNext() {
        
        return aggregate.objects.length!=0 && index<aggregate.objects.length;
    }
    @Override
    Object next() {
        return aggregate.objects[index++];
    }
}
abstract  class Aggregate{
    protected Object[] objects;
    abstract Interator createIterator();
    public  Aggregate(Object[] objects){
        this.objects = objects;
    }
}
class ConcreteAggregate  extends Aggregate{
    public ConcreteAggregate(Object[] objects){
        super(objects);
    }
    @Override
    Interator createIterator() {
        return new ConcreteInterator(this);
    }
}

中介者（Mediator）

意图：用一个中介对象来封装一系列的对象交互，中介者使各个对象不需要显式相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
适用场景：

适用中介者模式后的场景

适用性：

UML图

示例代码

package mediator;
import com.sun.org.apache.xpath.internal.operations.Neg;
import java.util.Random;
public class Test {
    public static void main(String[] args) {
      Student a=  new Student("1");
        Student b=           new Student("2");
        Student c=          new Student("3");
        Student d=         new Student("4");
        Student[] students = {
               a,b,c,d
        };
        ConcreteMediator mediator = new ConcreteMediator(students);
        a.send("22222","2");
        mediator.showList();
    }
}
// 同事类
abstract class  Colleague{
    protected Mediator mediator;
    protected String id;
    protected String info;
    abstract void send(String info,String  ColleaGueId);
}
class Student extends  Colleague{
    public Student (String id){
        this.id = id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    public String getId() {
        return id;
    }
    public String getInfo() {
        return info;
    }
    @Override
    void send(String info, String ColleaGueId) {
        mediator.forward(info,ColleaGueId);
    }
}
// 中介者类
abstract class Mediator{
    protected Colleague[] colleagues;
    public Mediator (){
    }
    public Mediator(Colleague[] colleagues){
        this.colleagues = colleagues;
    }
     abstract public void forward(String info,String  ColleaGueId);
}
class ConcreteMediator extends  Mediator{
    public ConcreteMediator(Colleague[] colleagues){
        this.colleagues = colleagues;
        for (Colleague colleague : colleagues) {
            colleague.mediator =this;
        }
    }
    public void showList(){
        for (Colleague colleague : colleagues) {
            System.out.println(colleague.id +":"+colleague.info);
        }
    }
    @Override
    public void forward(String info, String ColleaGueId) {
        for (Colleague colleague : colleagues) {
            if (colleague.id==ColleaGueId){
                colleague.info = info;
                System.out.println("id为"+colleague.id +"以收到消息，消息为："+colleague.info);
            }
        }
    }
}

例题1

备忘录模式（Memento）

意图：在不破环封装性的前提下捕获一个对象的内部状态并在对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态。
例如：虚拟机中的系统快照。
适用性：

UML图：

示例代码：

package memento;
import com.sun.org.apache.xpath.internal.operations.Or;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        Originator originator = new Originator();
        List<Memento> mementos = new ArrayList<>();
        mementos.add(originator.createMemento());
        for (Memento memento : mementos) {
            System.out.println(memento.getState());
        }
        System.out.println("==========================");
        // 假设将原发器状态设置为2.0后，有需要改回1.0
        originator.setState("2.0");
        mementos.add(originator.createMemento());
        for (Memento memento : mementos) {
            System.out.println(memento.getState());
        }
        System.out.println("===========================");
        System.out.println("当前原发器的状态为："+originator.getState());
        System.out.println("===============");
        // 改为1.0
        originator.setMemento(mementos.get(0));
        System.out.println("当前原发器的状态为："+originator.getState());
        
    }
}
// 原发器（需要备忘录的对象）
class Originator{
    private String state;
    public Originator(){
        this.state = "1.0";
    }
    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
    }
    public void setMemento(Memento memento) {
       this.state =memento.getState();
    }
    public Memento createMemento(){
        return  new Memento(state);
    }
}
// 备忘录
class Memento{
    private String state;
    public Memento(){
    }
    public Memento(String state){
        this.state = state;
    }
    public String getState() {
        return state;
    }
}

观察者模式（Observer）

意图：定义对象间的一种一对多的依赖联系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
例如：博主和粉丝之间的关系，粉丝订阅了博主，当博主内容更新时，会通知所有的粉丝。
适用性：

UML图：

示例代码：

package observer;
import java.lang.invoke.ConstantCallSite;
import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        ConcreteSubject concreteSubject = new ConcreteSubject();
        ConcreteObserver c1= new ConcreteObserver();
        ConcreteObserver c2= new ConcreteObserver();
        ConcreteObserver c3= new ConcreteObserver();
        concreteSubject.add(c1);
        concreteSubject.add(c2);
        concreteSubject.add(c3);
        for (ConcreteObserver concreteObserver : concreteSubject.list) {
            System.out.println(concreteObserver.getState());
        }
        System.out.println("======================");
        concreteSubject.setState("更新了，同志们");
        concreteSubject.notifyObserver();
        for (ConcreteObserver concreteObserver : concreteSubject.list) {
            System.out.println(concreteObserver.getState());
        }
    }
}
// 观察者抽象接口
interface    Observer{
  void update();
}
class  ConcreteObserver implements Observer{
    private  String state;
    private ConcreteSubject subject;
    @Override
    public void update() {
        System.out.println("状态更新了");
      this.state = subject.getState();
    }
    public void setSubject(ConcreteSubject subject) {
        this.subject = subject;
    }
    public String getState() {
        return state;
    }
}
interface Subject{
    void add(ConcreteObserver concreteObserver);
    boolean remove(ConcreteObserver concreteObserver);
    void notifyObserver();
}
class  ConcreteSubject implements  Subject{
    private  String state;
    List<ConcreteObserver> list ;
    public ConcreteSubject(){
        list = new ArrayList<>();
    }
    @Override
    public void add(ConcreteObserver concreteObserver) {
        list.add(concreteObserver);
    }
    @Override
    public boolean remove(ConcreteObserver concreteObserver) {
        return list.remove(concreteObserver);
    }
    @Override
    public void notifyObserver() {
        for (ConcreteObserver concreteObserver : list) {
            concreteObserver.setSubject(this);
            concreteObserver.update();
        }
    }
    public void setState(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
}

例题1

例题2

例题3

例题4

例题5

例题6

状态（state）

意图：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类

注意：这个模式时被动改变

例如：自动贩卖机

有货》》可以卖
无货》补货

适用性：

UML图

示例代码

package state;
import java.util.Objects;
import java.util.Timer;
import java.util.logging.Handler;
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Contenxt contenxt = new Contenxt(3);
        contenxt.Request();
        contenxt.Request();
        contenxt.Request();
        contenxt.Request();
        contenxt.Request();
    }
}
// 抽象状态类
abstract class  State{
    abstract void handle() throws InterruptedException;
}
// 有货
class  HaveProductConcreteState extends  State{
    private Contenxt contenxt;
    public HaveProductConcreteState (Contenxt contenxt){
        this.contenxt =contenxt;
    }
    @Override
    void handle() {
        System.out.println("售卖产品中");
        contenxt.setProductNumber(contenxt.productNumber-1);
    }
}
class NoProductConcreteState extends State{
    private Contenxt contenxt;
    public NoProductConcreteState (Contenxt contenxt){
        this.contenxt =contenxt;
    }
    @Override
    void handle() throws InterruptedException {
        System.out.println("暂无余货");
        System.out.println("补货中");
        Thread.sleep(5000);
        contenxt.setProductNumber(3);
        System.out.println("补货完成");
//        new Thread(()->{
//            try {
//
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
//        }).start();
    }
}
// 售卖机
class Contenxt{
    int productNumber ;
    private State state;
    public Contenxt(int productNumber){
        this.productNumber = productNumber;
    }
    // 卖
    public void Request() throws InterruptedException {
        if(productNumber>=1){
           state= new HaveProductConcreteState(this);
        }else{
          state = new NoProductConcreteState(this);
        }
        state.handle();
    }
    public void setProductNumber(int productNumber) {
        this.productNumber = productNumber;
    }
}

例题1

例题2

策略模式（Strategy）

意图：定义一系类的算法，把它们一个个封装起来，时它们可以相互替换，此模式使得算法可以独立于使用它们的客户而变化。
例如：付款方式：

微信支付
支付宝支付
现金支付

适用性：

UML图：

示例代码：

package strategy;
public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        // 加法策略
        Strategy add = new AddSteategy();
        context.setStrategy(add);
        context.ContextInterface(1,1);
        // 减法策略
        Strategy  sub = new SubSteategy();
        context.setStrategy(sub);
        context.ContextInterface(1,1);
    }
}
class  Context{
    private Strategy strategy;
    public  Context(){
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public  Context(Strategy strategy){
        this.strategy= strategy;
    }
    public void ContextInterface(int a,int b){
        strategy.AlgorthmInterface(a,b);
    }
}
// 抽象策略
abstract class Strategy{
    abstract  void AlgorthmInterface(int a,int b);
}
// 加法add
class AddSteategy extends  Strategy{
    @Override
    void AlgorthmInterface(int a,int b) {
        System.out.println(a+b);
    }
}
// 减法sub
class SubSteategy extends  Strategy{
    @Override
    void AlgorthmInterface(int a,int b) {
        System.out.println(a-b);
    }
}

例题1：

例题2

8.例题3：

模板方法（Template Method）

意图：定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构。即可重定义该算法的某些特定步骤：
例如：例如：上课和下课对于学生和老师都是一样的，但是在课上的行为，二者就是不同的了。
适用性：

UML图：

示例代码：

package templateMethod;
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.templateMethod();
    }
}
abstract class ClassUp{
     void templateMethod(){
         System.out.println("上课");
         primitiveOperation1();
         System.out.println("下课");
         primitiveOperation2();
     }
     abstract  void primitiveOperation1();
     abstract  void primitiveOperation2();
}
// 学生
class Student extends  ClassUp{
    @Override
    void primitiveOperation1() {
        // 课中
        System.out.println("学生要：听课、做笔记");
    }
    @Override
    void primitiveOperation2() {
// 课后
        System.out.println("学生要：整理笔记、完成作业，复习");
    }
}

访问者模式（Visitor）

意图：表示一个作用于某对象结构中的各个元素的操作，它允许在不允许各元素的类的前提下定义作用于这些元素的新操作。
适用性：

UML图：

问它

示例代码：

package visitor;
import java.util.ArrayList;
import java.util.List;
public class Client {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Student("张三",11));
        list.add(new Student("李四",13));
        list.add(new Student("王五",12));
        list.add(new Teacher("王老师",32));
        list.add(new Teacher("张老师",42));
        list.add(new Teacher("谢老师",52));
        PersonStructure personStructure = new PersonStructure(list);
        // 访问者1初始化
        ConcreteVisitor1 visitor1 = new ConcreteVisitor1();
        personStructure.visitor(visitor1);
        // 总年龄：
        System.out.println("学生总年龄："+visitor1.getStudentAgeSum());
        System.out.println("老师总年龄："+visitor1.getTeacherAgeSum());
    }
}
abstract  class Visitor{
    abstract void VisitorStudent(Student student);
    abstract  void VisitorTeacher(Teacher teacher);
}
// 访问者1
class ConcreteVisitor1 extends  Visitor{
   private int studentAgeSum=0;
   private int teacherAgeSum =0;
    public int getStudentAgeSum() {
        return studentAgeSum;
    }
    public int getTeacherAgeSum() {
        return teacherAgeSum;
    }
    @Override
    void VisitorStudent(Student student) {
        // 求访问学生的年龄总和
        studentAgeSum+=student.getAge();
    }
    @Override
    void VisitorTeacher(Teacher teacher) {
        // 求访问老师的年龄总和
        teacherAgeSum+=teacher.getAge();
    }
}
abstract class   Person{
    private String name;
    private int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name =name;
        this.age =age;
    }
    abstract void Accept(Visitor visitor);
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}
// 学生
class  Student extends Person{
    public Student(String name,int age){
       super(name,age);
    }
    @Override
    void Accept(Visitor visitor) {
        visitor.VisitorStudent(this);
    }
}
class Teacher extends Person{
    public Teacher(String name,int age){
        super(name,age);
    }
    @Override
    void Accept(Visitor visitor) {
        visitor.VisitorTeacher(this);
    }
}
// 对象结构
class  PersonStructure{
    private List<Person> people;
    public PersonStructure (){
    }
    public PersonStructure(List<Person> list){
        this.people = list;
    }
    public void visitor(Visitor visitor){
        for (Person person : people) {
            person.Accept(visitor);
        }
    }
}