软件设计师：08-设计模式

章节	章节
01 - 计算机组成原理与体系结构	07 - 法律法规与标准化与多媒体基础
02 - 操作系统基本原理	08 - 设计模式
03 - 数据库系统	09 - 软件工程
04 - 计算机网络	10 - 面向对象
05 - 数据结构与算法	11 - 结构化开发与UML
06 - 程序设计语言与语言处理程序基础	12 - 下午题历年真题
End - 二周目上午真题	End – 二周目下午真题
End - 临考快速记忆	Java工程师的进阶之路
菜鸟教程设计模式

---

---

一、设计模式分类

• 创建型对象：抽生原单 4
• 结构型对象：适桥组装外享代 7
• 行为型对象：责命迭终备观状策访 9

真题1

---

二、创建型设计模式

模式	意图
工厂方法	定义一个用于创建对象的接口，让子类决定实例化哪一个类
抽象工厂	提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
生成器模式	将一个复杂对象的构建与它的表示分类，使得同样的构建过程可以创建不同的表示
原型模式	用原型实例指定创建对象的种类，并且通过复制这些原型对象创建新的对象
单例模式	保证一个类仅有一个实例，并提供一个访问它的全局访问点

---

2.0、简单工厂模式

class Factory {
    
    
    public void createProduct(Product product) {
    
    
        product.info();
    }
}

abstract class Product {
    
    
    public abstract void info();
}

class ProductA extends Product {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：A");
    }
}

class ProductB extends Product {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：B");
    }
}

public class SimpleFactory {
    
    
    public static void main(String[] args) {
    
    
        Factory factory = new Factory();
        Product productA = new ProductA();
        Product productB = new ProductB();
        factory.createProduct(productA);
        factory.createProduct(productB);
    }
}

// 产品信息：A
// 产品信息：B

---

2.1、工厂方法模式（Factory Method）

interface Product {
    
    
    void info();
}

class ProductA implements Product {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：A");
    }
}

class ProductB implements Product {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：B");
    }
}

interface Factory {
    
    
    Product createProduct();
}

class FactoryA implements Factory {
    
    
    @Override
    public Product createProduct() {
    
    
        return new ProductA();
    }
}

class FactoryB implements Factory {
    
    
    @Override
    public Product createProduct() {
    
    
        return new ProductB();
    }
}

public class SimpleFactory {
    
    
    public static void main(String[] args) {
    
    
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.info();

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.info();
    }
}

---

2.2、抽象工厂模式（Abstract Factory）

1、定义

interface Factory {
    
    
    // 手机
    ProductA createProductA();
    // 平板
    ProductB createProductB();
}

// 苹果工厂
class Factory1 implements Factory {
    
    
    // 苹果手机
    @Override
    public ProductA createProductA() {
    
    
        return new ProductA1();
    }
    // 苹果平板
    @Override
    public ProductB createProductB() {
    
    
        return new ProductB1();
    }
}

// 小米工厂
class Factory2 implements Factory {
    
    
    // 小米手机
    @Override
    public ProductA createProductA() {
    
    
        return new ProductA2();
    }
    // 小米平板
    @Override
    public ProductB createProductB() {
    
    
        return new ProductB2();
    }
}

// 手机
interface ProductA {
    
    
    void info();
}

class ProductA1 implements ProductA {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：A1");
    }
}

class ProductA2 implements ProductA {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：A2");
    }
}

// 平板
interface ProductB {
    
    
    void info();
}

class ProductB1 implements ProductB {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：B1");
    }
}

class ProductB2 implements ProductB {
    
    
    @Override
    public void info() {
    
    
        System.out.println("产品信息：B2");
    }
}

public class SimpleFactory {
    
    
    public static void main(String[] args) {
    
    
        Factory factory1 = new Factory1();
        Factory factory2 = new Factory2();

        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.info();
        productB1.info();

        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.info();
        productB2.info();
    }
}

---

2、上午真题

真题1

真题2

---

2、下午真题

真题1

扫描二维码关注公众号，回复： 14716523 查看本文章

解析

---

2.3、生成器模式（Builder）

1、定义

---

2、上午真题

真题1

真题2

真题3

---

3、下午真题

真题1

---

2.4、原型模式（Prototype）

1、定义

interface Prototype {
    
    
    Object clone();
}

class Product implements Prototype {
    
    
    private int id;
    private String name;

    public Product() {
    
    
    }

    public Product(int id, String name) {
    
    
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
    
    
        return id + " " + name;
    }

    @Override
    public Object clone() {
    
    
        Product obj = new Product();
        obj.id = this.id;
        obj.name = this.name;
        return obj;
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Product a = new Product(1, "A");
        Product clone = (Product) a.clone();
        System.out.println(a);
        System.out.println(clone);
    }
}

---

2、下午真题

真题1

解析

---

2.5、单例模式（Singleton）

---

真题1

真题2

真题3

---

三、结构性设计模式

模式	意图
适配器模式	将一个类的接口转换成客户希望的另一个接口
桥接模式	将抽象与其实现部分分类，使他们都可以独立的变化
组合模式	将对象组合成树形模式以表示 部分与整体
装饰模式	动态地给一个对象添加额外的职责
外观模式	为子系统中的一组接口提供一个一致的接口，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
享元模式	运用共享技术有效地支持大量细粒度的对象
代理模式	为其他对象提供一种代理以控制对这个对象的访问

---

3.1、适配器模式（Adapter）

1、定义

客户使用Lighting接口的手机，适配器继承该手机的充电方式并将其转为TypeC

// 客户使用的手机
class Lighting {
    
    
    public void Request() {
    
    
        System.out.println("Lighting数据线");
    }
}

// 适配器
class Adapter extends Lighting {
    
    
    private TypeC typeC = new TypeC();

    @Override
    public void Request() {
    
    
        typeC.SpecificRequest();
    }
}

// 数据线
class TypeC {
    
    
    public void SpecificRequest() {
    
    
        System.out.println("TypeC数据线");
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Lighting lighting = new Adapter();
        lighting.Request();
    }
}

---

2、上午真题

真题

---

3、下午真题

解析

---

3.2、桥接模式（Bridge）

1、定义

抽象部分调用实现部分

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Product productA = new ProductA();
        Product productB = new ProductA();

        Color red = new Red();
        Color blue = new Blue();

        productA.setName("裙子");
        productA.setColor(red);
        productA.Operation();

        productB.setName("裤子");
        productB.setColor(blue);
        productB.Operation();
    }

}

// 抽象
abstract class Product {
    
    
    private String name;
    protected Color color;

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

    public String getName() {
    
    
        return name;
    }

    public void setColor(Color color) {
    
    
        this.color = color;
    }

    public abstract void Operation();
}

// 抽象部分
class ProductA extends Product {
    
    

    @Override
    public void Operation() {
    
    
        color.OperationImp(this.getName());
    }
}

// 接口
interface Color {
    
    
    public void OperationImp(String name);
}

// 实现部分
class Red implements Color {
    
    

    @Override
    public void OperationImp(String name) {
    
    
        System.out.println(name + ":红色");
    }
}

// 实现部分
class Blue implements Color {
    
    

    @Override
    public void OperationImp(String name) {
    
    
        System.out.println(name + ":蓝色");
    }
}

裙子:红色
裤子:蓝色

---

2、上午真题

真题1

真题2

真题3

---

3、下午真题

真题1

解析

---

真题2

解析

---

3.3、组合模式（Composite）

1、定义

abstract class AbstractFile {
    
    
    protected String name;

    public void printName() {
    
    
        System.out.println(name);
    }

    public abstract boolean add(AbstractFile abstractFile);
    public abstract boolean remove(AbstractFile abstractFile);
    public abstract List<AbstractFile> getChildren();
}

class Folder extends AbstractFile {
    
    
    private List<AbstractFile> childrenList = new ArrayList<>();

    public Folder(String name) {
    
    
        this.name = name;
    }

    @Override
    public boolean add(AbstractFile abstractFile) {
    
    
        return childrenList.add(abstractFile);
    }

    @Override
    public boolean remove(AbstractFile abstractFile) {
    
    
        return childrenList.remove(abstractFile);
    }

    @Override
    public List<AbstractFile> getChildren() {
    
    
        return childrenList;
    }
}

class File extends AbstractFile {
    
    
    public File(String name) {
    
    
        this.name = name;
    }

    @Override
    public boolean add(AbstractFile abstractFile) {
    
    
        return false;
    }

    @Override
    public boolean remove(AbstractFile abstractFile) {
    
    
        return false;
    }

    @Override
    public List<AbstractFile> getChildren() {
    
    
        return null;
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        AbstractFile root = new Folder("root");

        AbstractFile foldA = new Folder("FoldA");
        AbstractFile fileA1 = new File("fileA1");
        AbstractFile fileB = new File("fileB1");
        root.add(fileB);
        root.add(foldA);
        foldA.add(fileA1);

        print(root);
    }

    static void print(AbstractFile abstractFile) {
    
    
        // 打印当前文件夹/文件
        abstractFile.printName();

        // 获取子文件夹/文件
        List<AbstractFile> children = abstractFile.getChildren();
        if (children == null) return;

        for (AbstractFile file : children) {
    
    
            print(file);
        }
    }
}

---

2、上午真题

真题1

真题2

真题3

---

3、下午真题

真题1

解析

---

真题2

解析

---

真题3

解析

真题4

---

3.4、装饰模式（Decorator）

1、定义

abstract class Decorator extends Person {
    
    
    protected Person person;
}

// 装饰器A
class DecoratorA extends Decorator {
    
    

    public DecoratorA(Person person) {
    
    
        this.person = person;
    }

    @Override
    public void operation() {
    
    
        person.operation();  // 原本的职责
        System.out.println("装饰器A新职责：写作业");
    }
}

class DecoratorB extends Decorator {
    
    

    public DecoratorB(Person person) {
    
    
        this.person = person;
    }

    @Override
    public void operation() {
    
    
        person.operation();  // 原本的职责
        System.out.println("装饰器B新职责：做家务");
    }
}
 
abstract class Person {
    
    
    protected String name;
    
    public abstract void operation(); // 职责
}

class Student extends Person {
    
    

    public Student(String name) {
    
    
        this.name = name;
    }

    @Override
    public void operation() {
    
    
        System.out.println(name + "的职责:学习");
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Person zs = new Student("zs");
        zs.operation();

        System.out.println("================");

        zs = new DecoratorB(new DecoratorA(zs));
        zs.operation();
    }
}

zs的职责:学习
================
zs的职责:学习
装饰器B新职责：做家务
装饰器A新职责：写作业

---

2、上午真题

真题

---

3、下午真题

2012上

解析

---

2016下

解析

---

3.5、外观模式（Facade）

---

真题1

---

真题2

---

3.6、享元模式（Flyweight）

1、定义

abstract class Piece {
    
    
    protected String color;

    public abstract void draw(int x, int y);
}

class PieceFactory {
    
    
    private Piece[] pieces = {
    
    new WhitePiece(), new BlackPiece()};

    public Piece getPiece(int key) {
    
    
        if (key == 0) return pieces[0];
        else return pieces[1];
    }
}

class WhitePiece extends Piece {
    
    

    public WhitePiece() {
    
    
        this.color = "while";
    }

    @Override
    public void draw(int x, int y) {
    
    
        System.out.println("draw a color:" + color + "piece x:" + x + "y" + y);
    }
}

class BlackPiece extends Piece {
    
    

    public BlackPiece() {
    
    
        this.color = "black";
    }

    @Override
    public void draw(int x, int y) {
    
    
        System.out.println("draw a color:" + color + "piece x:" + x + "y" + y);
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        PieceFactory factory = new PieceFactory();

        Piece white = factory.getPiece(0);
        System.out.println(white);
        Piece black = factory.getPiece(1);
        System.out.println(black);
    }
}

com.laptoy.structure.flyweight.WhitePiece@1b6d3586
com.laptoy.structure.flyweight.BlackPiece@4554617c

---

1、上午真题

真题1

---

2、下午真题

2021下

解析

---

3.7、代理模式（Proxy）

---

真题1

---

四、行为型设计模式

---

4.1、责任链模式（Chain of Responsibility）

---

4.2、命令模式（Command）

1、定义

class Invoke {
    
     // 请求者
    private Command command;

    public void setCommand(Command command) {
    
    
        this.command = command;
    }

    public void call() {
    
    
        command.execute();
    }
}

interface Command {
    
    
    void execute();
}

class OnCommand implements Command {
    
    
    private Tv tv;
    private Computer computer;

    public OnCommand(Tv tv, Computer computer) {
    
    
        this.tv = tv;
        this.computer = computer;
    }

    @Override
    public void execute() {
    
    
        tv.OnAction();
        computer.OnAction();
    }
}

class OffCommand implements Command {
    
    
    private Tv tv;
    private Computer computer;

    public OffCommand(Tv tv, Computer computer) {
    
    
        this.tv = tv;
        this.computer = computer;
    }

    @Override
    public void execute() {
    
    
        tv.OffAction();
        computer.OffAction();
    }
}

class Tv {
    
    
    public void OnAction() {
    
    
        System.out.println("电视机开机了...");
    }

    public void OffAction() {
    
    
        System.out.println("电视机关机了...");
    }
}

class Computer {
    
    
    public void OnAction() {
    
    
        System.out.println("电脑开机了...");
    }

    public void OffAction() {
    
    
        System.out.println("电脑关机了...");
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Tv tv = new Tv();
        Computer computer = new Computer();

        Command onCommand = new OnCommand(tv, computer);
        Command offCommand = new OffCommand(tv, computer);

        Invoke invoke = new Invoke();
        invoke.setCommand(onCommand);
        invoke.call();

        invoke.setCommand(offCommand);
        invoke.call();
    }
}

电视机开机了...
电脑开机了...
电视机关机了...
电脑关机了...

---

2、上午真题

真题1

---

真题2

---

3、下午真题

2014下

解析

---

4.3、解释器模式（Interpreter）

---

4.4、迭代器模式（Iterator）

---

4.5、中介模式（Mediator）

1、定义

abstract class Colleague {
    
    
    protected Mediator mediator;
}

class Colleague1 extends Colleague {
    
    
    public Colleague1(Mediator mediator) {
    
    
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
    
    
        mediator.sendMessage(message, this);
    }

    public void notify(String message) {
    
    
        System.out.println("同事1收到消息" + message);
    }
}

class Colleague2 extends Colleague {
    
    
    public Colleague2(Mediator mediator) {
    
    
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
    
    
        mediator.sendMessage(message, this);
    }

    public void notify(String message) {
    
    
        System.out.println("同事2收到消息" + message);
    }
}

abstract class Mediator {
    
    
    public abstract void sendMessage(String message, Colleague colleague);

}

class ConcreteMediator extends Mediator {
    
    
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1) {
    
    
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague2 colleague2) {
    
    
        this.colleague2 = colleague2;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
    
    
        if (colleague == colleague1) {
    
     // 让2接 收消息
            colleague2.notify(message);
        } else {
    
     // 让1接收消息
            colleague1.notify(message);
        }
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        ConcreteMediator mediator = new ConcreteMediator();

        Colleague1 colleague1 = new Colleague1(mediator);
        Colleague2 colleague2 = new Colleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("Hello C2 I am C1");
        colleague2.sendMessage("Hello C1 I am C2");
    }
}

同事2收到消息Hello C2 I am C1
同事1收到消息Hello C1 I am C2

---

2、上午真题

真题

---

3、下午真题

---

4.6、备忘录模式（Memento）

---

4.7、观察者模式（Observer）

1、定义

interface Subject {
    
    
    void Attach(Observer observer);
    void Detach(Observer observer);
    void Notify();
    String getState();
    void setState(String state);
}

class ConcreteSubject implements Subject {
    
    
    private String state;
    private List<Observer> observerList;

    public ConcreteSubject() {
    
    
        state = "订阅成功"; // 初始状态
        observerList = new ArrayList<>();
    }

    @Override
    public void Attach(Observer observer) {
    
    
        observerList.add(observer);
    }

    @Override
    public void Detach(Observer observer) {
    
    
        observerList.remove(observer);
    }

    @Override
    public void Notify() {
    
    
        for (Observer observer : observerList) {
    
    
            observer.update();
        }
    }

    @Override
    public String getState() {
    
    
        return state;
    }

    @Override
    public void setState(String state) {
    
    
        this.state = state;
        Notify(); // 通知所有观察者更新信息
    }
}

interface Observer {
    
    
    void update();
    void getState();
}

class ConcreteObserver implements Observer {
    
    
    private String state;
    private Subject subject;

    // 目标绑定观察者
    public ConcreteObserver(Subject subject) {
    
    
        this.subject = subject;
        subject.Attach(this);
        state = subject.getState();
    }

    public void getState() {
    
    
        System.out.println(state);
    }

    @Override
    public void update() {
    
    
        state = subject.getState(); // 保持状态一致
        System.out.println("您订阅的频道更新啦：" + state);
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Subject subject = new ConcreteSubject();
        Observer observer = new ConcreteObserver(subject);  // 创建观察者并订阅目标
        observer.getState();
        subject.setState("设计模式入门到精通");
    }
}

订阅成功
您订阅的频道更新啦：设计模式入门到精通

---

2、上午真题

真题1

真题2

真题3

真题4

真题5

---

3、下午真题

真题1

解析

---

真题2

解析

---

4.8、状态模式（State）

1、定义

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Context context = new Context();
        context.Request();
        context.Request();
        context.Request();

        context.Request();
    }
}

class Context {
    
    
    private int count;
    private State state;

    public Context() {
    
    
        count = 3;
        state = new StateA();
    }

    public void Request() {
    
     // 购买一个饮料
        state.Handle(this);
    }

    public int getCount() {
    
    
        return count;
    }

    public void setCount(int count) {
    
    
        this.count = count;
    }

    public State getState() {
    
    
        return state;
    }

    public void setState(State state) {
    
    
        this.state = state;
    }
}

interface State {
    
    
    public void Handle(Context context);
}

class StateA implements State {
    
     // 有货

    @Override
    public void Handle(Context context) {
    
    
        int count = context.getCount();

        if (count >= 1) {
    
    
            System.out.println("购买成功！");
            context.setCount(count - 1);
        }
        if (context.getCount() == 0) {
    
    
            System.out.println("售货机状态改变：缺货状态");
            context.setState(new StateB());

        }
    }
}

class StateB implements State {
    
     // 无货

    @Override
    public void Handle(Context context) {
    
    
        int count = context.getCount();

        if (count == 0) {
    
    
            System.out.println("购买失败！等待补货");

            context.setCount(5);
            System.out.println("售货机状态改变：有货状态，请重新购买");
            context.setState(new StateA());
        }
    }
}

---

2、上午真题

真题1

真题2

---

3、下午真题

真题1

解析

---

真题2

解析

---

4.9、策略模式（Strategy）

1、定义

class OperationContext {
    
    
    private Strategy strategy;

    public OperationContext(Strategy strategy) {
    
    
        this.strategy = strategy;
    }

    // 两数相加
    public void operation(int a, int b) {
    
    
        strategy.TwoNumberOperation(a, b);
    }
}

// 算法策略接口
interface Strategy {
    
    
    void TwoNumberOperation(int a, int b);
}

// 加法策略
class AddStrategy implements Strategy {
    
    

    @Override
    public void TwoNumberOperation(int a, int b) {
    
    
        System.out.println("加法策略：" + (a + b));
    }
}

// 减法策略
class SubStrategy implements Strategy {
    
    

    @Override
    public void TwoNumberOperation(int a, int b) {
    
    
        System.out.println("减法策略：" + (a - b));
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        Strategy add = new AddStrategy();
        Strategy sub = new SubStrategy();
        OperationContext context1 = new OperationContext(add);
        OperationContext context2 = new OperationContext(sub);
        context1.operation(1, 2);
        context2.operation(1, 2);
    }
}

加法策略：3
减法策略：-1

---

2、上午真题

真题1

真题2

真题3

---

3、下午真题

真题1

解析

---

真题2

解析

---

真题3

解析

---

4.10、模板方法模式（Template Method）

---

4.11、访问者模式（Visitor）

1、定义

interface Visitor {
    
    
    void visitStudent(Student student);

    void visitTeacher(Teacher teacher);
}

class Visitor1 implements Visitor {
    
    
    @Override
    public void visitStudent(Student student) {
    
    
        System.out.println("访问者1访问学生" + student.name);
    }

    @Override
    public void visitTeacher(Teacher teacher) {
    
    
        System.out.println("访问者1访问老师" + teacher.name);
    }
}

class Visitor2 implements Visitor {
    
    
    @Override
    public void visitStudent(Student student) {
    
    
        System.out.println("访问者2访问学生" + student.name);
    }

    @Override
    public void visitTeacher(Teacher teacher) {
    
    
        System.out.println("访问者2访问老师" + teacher.name);
    }
}

// 对象结构
class PersonStructure {
    
    
    private List<Person> personList = new ArrayList<>();

    public PersonStructure() {
    
    
        personList.add(new Student("A"));
        personList.add(new Student("B"));
        personList.add(new Teacher("AA"));
        personList.add(new Teacher("BB"));
    }

    public void Accept(Visitor visitor) {
    
    
        for (Person person : personList) {
    
    
            person.Accept(visitor);
        }
    }
}

abstract class Person {
    
    
    public String name;

    public abstract void Accept(Visitor visitor);
}

class Student extends Person {
    
    
    public Student(String name) {
    
    
        this.name = name;
    }

    @Override
    public void Accept(Visitor visitor) {
    
    
        visitor.visitStudent(this);
    }
}

class Teacher extends Person {
    
    
    public Teacher(String name) {
    
    
        this.name = name;
    }

    @Override
    public void Accept(Visitor visitor) {
    
    
        visitor.visitTeacher(this);
    }
}

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        PersonStructure structure = new PersonStructure();

        Visitor1 visitor1 = new Visitor1();
        structure.Accept(visitor1);
        System.out.println("===========");
        Visitor2 visitor2 = new Visitor2();
        structure.Accept(visitor2);
    }
}

访问者1访问学生A
访问者1访问学生B
访问者1访问老师AA
访问者1访问老师BB
===========
访问者2访问学生A
访问者2访问学生B
访问者2访问老师AA
访问者2访问老师BB

public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        PersonStructure structure = new PersonStructure();

        Visitor1 visitor1 = new Visitor1();
        structure.Accept(visitor1);
        System.out.println("学生年龄的总和：" + visitor1.getStudentAgeSum());
        System.out.println("老师年龄的总和：" + visitor1.getTeacherAgeSum());

        System.out.println("=============================");

        Visitor2 visitor2 = new Visitor2();
        structure.Accept(visitor2);
        System.out.println("学生分数最高：" + visitor2.getMaxScore());
        System.out.println("老师工龄最高：" + visitor2.getMaxWorkYear());
    }
}

interface Visitor {
    
    
    void visitStudent(Student student);

    void visitTeacher(Teacher teacher);
}

class Visitor1 implements Visitor {
    
     // 访问者1 分别统计学生和老师的年龄总和
    private int studentAgeSum = 0;
    private int teacherAgeSum = 0;

    public int getStudentAgeSum() {
    
    
        return studentAgeSum;
    }

    public int getTeacherAgeSum() {
    
    
        return teacherAgeSum;
    }

    @Override
    public void visitStudent(Student student) {
    
    
        System.out.println("访问者1访问学生" + student.getName() + "年龄：" + student.getAge());
        studentAgeSum += student.getAge();
    }

    @Override
    public void visitTeacher(Teacher teacher) {
    
    
        System.out.println("访问者1访问老师" + teacher.getName() + "年龄：" + teacher.getAge());
        teacherAgeSum += teacher.getAge();
    }
}

class Visitor2 implements Visitor {
    
     // 访问者2 分别求出学生的最高成绩和老师的最高工龄
    private int maxScore = -1;
    private int maxWorkYear = -1;

    public int getMaxScore() {
    
    
        return maxScore;
    }

    public int getMaxWorkYear() {
    
    
        return maxWorkYear;
    }

    @Override
    public void visitStudent(Student student) {
    
    
        System.out.println("访问者2访问学生" + student.getName() + "成绩：" + student.getScore());
        maxScore = Math.max(maxScore, student.getScore());
    }

    @Override
    public void visitTeacher(Teacher teacher) {
    
    
        System.out.println("访问者2访问老师" + teacher.getName() + "工龄：" + teacher.getWorkYear());
        maxWorkYear = Math.max(maxWorkYear, teacher.getWorkYear());
    }
}

// 对象结构
class PersonStructure {
    
    
    private List<Person> personList = new ArrayList<>();

    public PersonStructure() {
    
    
        personList.add(new Student("小明", 10, 70));
        personList.add(new Student("小红", 11, 90));
        personList.add(new Teacher("王老师", 27, 3));
        personList.add(new Teacher("李老师", 29, 4));
    }

    public void Accept(Visitor visitor) {
    
    
        for (Person person : personList) {
    
    
            person.Accept(visitor);
        }
    }
}

abstract class Person {
    
    
    private String name;
    private int age;

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public String getName() {
    
    
        return name;
    }

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

    public abstract void Accept(Visitor visitor);
}

class Student extends Person {
    
    
    private int score;

    public Student(String name, int age, int score) {
    
    
        super(name, age);
        this.score = score;
    }

    public int getScore() {
    
    
        return score;
    }

    @Override
    public void Accept(Visitor visitor) {
    
    
        visitor.visitStudent(this);
    }
}

class Teacher extends Person {
    
    
    private int workYear;

    public Teacher(String name, int age, int workYear) {
    
    
        super(name, age);
        this.workYear = workYear;
    }

    public int getWorkYear() {
    
    
        return workYear;
    }

    @Override
    public void Accept(Visitor visitor) {
    
    
        visitor.visitTeacher(this);
    }
}

---

2、上午真题

真题1

真题2

---

3、下午真题

解析

---

五、杂题

真题1

真题2

真题3（适桥组装外享代）

真题4

真题5

真题6

真题7

真题8

---

六、设计模式意图及适用性（表格版）

---

七、设计模式意图及适用性（文字版）

1、创建型

---

2、结构型

---

3、行为型