Java程序员拧螺丝之打底常备知识点

// 声明一个整型变量 x，并赋值为 10
int x = 10;
// 声明一个浮点型变量 y，并赋值为 3.14
double y = 3.14;
// 声明一个字符型变量 c，并赋值为 'A'
char c = 'A';
// 声明一个布尔型变量 b，并赋值为 true
boolean b = true;

// if-else 控制流程
if (x > 5) {
    System.out.println("x 大于 5");
} else {
    System.out.println("x 小于等于 5");
}

// for 循环
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

面向对象基本概念

// 定义一个简单的类
public class Dog {
    // 实例变量
    private String name;
    private int age;

    // 构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法重载
    public void bark() {
        System.out.println("汪汪");
    }

    public void bark(int times) {
        for (int i = 0; i < times; i++) {
            System.out.println("汪汪");
        }
    }
}

继承与多态

// 父类：Animal
public class Animal {
    public void speak() {
        System.out.println("动物发出声音");
    }
}

// 子类：Dog，继承自 Animal
public class Dog extends Animal {
    // 方法重写
    @Override
    public void speak() {
        System.out.println("汪汪");
    }
}

// 子类：Cat，继承自 Animal
public class Cat extends Animal {
    // 方法重写
    @Override
    public void speak() {
        System.out.println("喵喵");
    }
}

// 多态的使用
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.speak(); // 输出：汪汪

        animal = new Cat();
        animal.speak(); // 输出：喵喵
    }
}

接口与抽象类

// 定义一个接口
public interface Drawable {
    void draw();
}

// 实现接口的类
public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 抽象类
public abstract class Shape {
    // 抽象方法
    public abstract double getArea();
}

// 继承抽象类的子类
public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    // 实现抽象方法
    @Override
    public double getArea() {
        return width * height;
    }
}

Java 集合

// List 示例
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

// Set 示例
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);

// Map 示例
Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);

Java I/O

// 文件 I/O
File file = new File("example.txt");

// 字符流
FileReader fileReader = new FileReader(file);
FileWriter fileWriter = new FileWriter(file);

// 缓冲流
BufferedReader bufferedReader = new BufferedReader(fileReader);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

// 序列化与反序列化
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("object.ser"));
objectOutputStream.writeObject(new ExampleObject());
objectOutputStream.close();

ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("object.ser"));
ExampleObject exampleObject = (ExampleObject) objectInputStream.readObject();
objectInputStream.close();

异常处理

try {
    // 可能抛出异常的代码
    int result = 1 / 0;
} catch (ArithmeticException e) {
    // 处理异常
    System.out.println("发生除数为零的异常");
} finally {
    // 无论是否发生异常，都会执行
    System.out.println("finally 代码块");
}

Java 网络编程

// 创建一个服务器套接字
ServerSocket serverSocket = new ServerSocket(1234);

// 接受客户端连接
Socket socket = serverSocket.accept();

// 从套接字获取输入输出流
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();

// 关闭套接字
socket.close();

多线程编程

// 创建一个线程
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
        System.out.println("Hello from MyThread");
    }
}

// 启动线程
MyThread myThread = new MyThread();
myThread.start();

// 线程同步与互斥
class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }
}

// 线程间通信：wait() 和 notify()
class ProducerConsumer {
    private List<Integer> buffer = new ArrayList<>();
    private static final int MAX_BUFFER_SIZE = 10;

    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == MAX_BUFFER_SIZE) {
            wait();
        }
        buffer.add(value);
        notify();
    }

    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();
        }
        int value = buffer.remove(0);
        notify();
        return value;
    }
}

《Java 核心技术》

Java 程序设计环境
Java 基本程序设计结构
对象与类

// 获取 Class 对象
Class<?> clazz = MyClass.class;

// 动态创建对象
MyClass myObject = (MyClass) clazz.newInstance();

// 访问字段
Field field = clazz.getDeclaredField("myField");
field.setAccessible(true);
field.set(myObject, 42);

// 访问方法
Method method = clazz.getDeclaredMethod("myMethod");
method.setAccessible(true);
method.invoke(myObject);

// 调用构造函数
Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
MyClass anotherObject = (MyClass) constructor.newInstance("Hello, world!");

继承
接口、lambda 表达式与内部类

// Lambda 表达式
Runnable runnable = () -> System.out.println("Hello, world!");

// 函数式接口
@FunctionalInterface
public interface MyFunction {
int apply(int a, int b);
}

// 使用 Lambda 表达式实现函数式接口
MyFunction add = (a, b) -> a + b;

// Stream API 示例
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.filter(n -> n % 2 == 1)
.map(n -> n * n)
.reduce(0, Integer::sum);

异常、断言和日志
泛型

// 泛型类
public class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }
}

// 泛型方法
public static <T> void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

集合
Java I/O
多线程
并发库
注解

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomAnnotation {
    String value() default "default value";
}

// 使用自定义注解
public class MyClass {
    @CustomAnnotation(value = "Hello, world!")
    public void myMethod() {
    }
}

Java 平台模块系统

2. Java 集合框架

《Java 集合框架详解》

Java 集合框架简介
List 接口及实现类
Set 接口及实现类
Map 接口及实现类
Queue 接口及实现类
迭代器与 ListIterator
Comparator 与 Comparable
Java 8 集合流操作

3. 并发编程

《Java 并发编程实战》

并发简介
线程安全性

// 使用 synchronized 保证线程安全
public class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

// 使用 volatile 保证变量的可见性
public class VolatileFlag {
    private volatile boolean flag;

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean getFlag() {
        return flag;
    }
}

对象的共享
对象的组合
基础构建模块
任务执行
取消与关闭
应用线程池
GUI 应用程序
性能与可伸缩性
测试并发程序
构建自定义同步工具
Java 内存模型

《Java 并发编程的艺术》

Java 并发机制的底层实现原理
Java 内存模型
Java 并发编程基础
Java 中的锁
Java 并发容器和框架
Java 中的线程池
Java 并发工具类
性能优化和最佳实践

4. JVM

《深入理解 Java 虚拟机》

Java 内存区域与内存溢出异常
垃圾收集器与内存分配策略
虚拟机性能监控与故障处理工具
类文件结构
虚拟机类加载机制
虚拟机字节码执行引擎
类加载及执行子系统的案例与实战
Java 内存模型与线程
程序编译与代码优化
高效并发

5. 设计模式

《设计模式：可复用面向对象软件的基础》

设计模式简介
创建型模式
- 单例模式
- 工厂方法模式
- 抽象工厂模式
- 建造者模式
- 原型模式
结构型模式
- 适配器模式
- 桥接模式
- 组合模式
- 装饰模式
- 外观模式
- 享元模式
- 代理模式
行为型模式
- 责任链模式
- 命令模式
- 解释器模式
- 迭代器模式
- 中介者模式
- 备忘录模式
- 观察者模式
- 状态模式
- 策略模式
- 模板方法模式
- 访问者模式

《Head First 设计模式》

策略模式：定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。例如：

// 策略接口
public interface QuackBehavior {
    void quack();
}

// 具体策略实现
public class Quack implements QuackBehavior {
    public void quack() {
        System.out.println("Quack");
    }
}

// 使用策略
public class Duck {
    private QuackBehavior quackBehavior;

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }

    public void performQuack() {
        quackBehavior.quack();
    }
}

观察者模式：定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。例如：

// 主题接口
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者接口
public interface Observer {
    void update(float temperature, float humidity, float pressure);
}

// 具体主题实现
public class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    // ...

    public void measurementsChanged() {
        notifyObservers();
    }

    // ...
}

// 具体观察者实现
public class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;

    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }

    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

装饰器模式：动态地将责任附加到对象上。在扩展功能方面，它提供了比继承更有弹性的替代方案。例如：

// 抽象组件
public abstract class Beverage {
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

// 具体组件
public class Espresso extends Beverage {
    public Espresso() {
        description = "Espresso";
    }

    public double cost() {
        return 1.99;
    }
}

// 装饰者抽象类
public abstract class CondimentDecorator extends Beverage {
    public abstract String getDescription();
}

// 具体装饰者
public class Mocha extends CondimentDecorator {
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
   }

   public double cost() {
       return beverage.cost() + 0.20;
   }

工厂模式：定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。工厂方法让类把实例化推迟到子类。例如：


4. 工厂方法模式（Factory Method Pattern）：定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。工厂方法让类把实例化推迟到子类。例如：

```java
// 抽象产品
public abstract class Pizza {
    // ...
}

// 具体产品
public class CheesePizza extends Pizza {
    // ...
}

// 抽象工厂
public abstract class PizzaStore {
    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        // ...
        return pizza;
    }

    protected abstract Pizza createPizza(String type);
}

// 具体工厂
public class NYPizzaStore extends PizzaStore {
    protected Pizza createPizza(String type) {
        if (type.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else {
            // ...
        }
    }
}

单例模式：确保一个类只有一个实例，并提供一个全局访问点。例如：

public class Singleton {
    private static Singleton uniqueInstance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

命令模式：将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。例如：

// 命令接口
public interface Command {
    void execute();
    void undo();
}

// 具体命令
public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.on();
    }

    public void undo() {
        light.off();
    }
}

// 调用者
public class RemoteControl {
    private Command[] onCommands;
    private Command[] offCommands;
    private Command undoCommand;

    // ...

    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
        undoCommand = onCommands[slot];
    }

    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
        undoCommand = offCommands[slot];
    }

    public void undoButtonWasPushed() {
        undoCommand.undo();
    }
}

适配器模式与外观模式：将一个类的接口转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以相互合作。例如：

// 目标接口
public interface Duck {
    void quack();
    void fly();
}

// 需要适配的类
public class Turkey {
    public void gobble() {
        System.out.println("Gobble gobble");
    }

    public void fly() {
        System.out.println("I'm flying a short distance");
    }
}

// 适配器
public class TurkeyAdapter implements Duck {
    private Turkey turkey;

    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    public void quack() {
        turkey.gobble();
    }

    public void fly() {
        turkey.fly();
    }
}

模板方法模式（Template Method Pattern）：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法让子类在不改变算法结构的情况下，重新定义算法中的某些步骤。例如：

// 抽象基类
public abstract class CaffeineBeverage {
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    abstract void brew();
    abstract void addCondiments();

    void boilWater() { /* ... */ }
    void pourInCup() { /* ... */ }
}

// 具体实现
public class Coffee extends CaffeineBeverage {
    void brew() { /* ... */ }
    void addCondiments() { /* ... */ }
}

public class Tea extends CaffeineBeverage {
    void brew() { /* ... */ }
    void addCondiments() { /* ... */ }
}

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。例如：

// 迭代器接口
public interface Iterator {
    boolean hasNext();
    Object next();
}

// 具体迭代器
public class ArrayIterator implements Iterator {
    private Object[] items;
    private int position = 0;

    public ArrayIterator(Object[] items) {
        this.items = items;
    }

    public boolean hasNext() {
        return position < items.length && items[position] != null;
    }

    public Object next() {
        if (hasNext()) {
            return items[position++];
        }
        return null;
    }
}

// 聚合接口
public interface Menu {
    Iterator createIterator();
}

// 具体聚合类
public class BreakfastMenu implements Menu {
    private MenuItem[] menuItems;

    public BreakfastMenu() {
        // ...
    }

    public Iterator createIterator() {
        return new ArrayIterator(menuItems);
    }
}

组合模式（Composite Pattern）：允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。例如：

// 组件抽象类
public abstract class MenuComponent {
    public void add(MenuComponent menuComponent) { /* ... */ }
    public void remove(MenuComponent menuComponent) { /* ... */ }
    public MenuComponent getChild(int i) { /* ... */ }
    public void print() { /* ... */ }
}

// 叶子节点
public class MenuItem extends MenuComponent {
    private String name;

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

    public void print() {
        System.out.println(" " + name);
    }
}

// 组合节点
public class Menu extends MenuComponent {
    private ArrayList<MenuComponent> menuComponents = new ArrayList<>();
    private String name;

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

    public void add(MenuComponent menuComponent) {
        menuComponents.add(menuComponent);
    }

    public void remove(MenuComponent menuComponent) {
        menuComponents.remove(menuComponent);
    }

    public MenuComponent getChild(int i) {
        return menuComponents.get(i);
    }

    public void print() {
        System.out.println("\n" + name);
        System.out.println("----------");

        for (MenuComponent menuComponent : menuComponents) {
            menuComponent.print();
        }
    }
}

状态模式：允许对象在内部状态改变时改变它的行为。对象看起来好像修改了它的类。例如：

// 状态接口
public interface State {
    void insertQuarter();
    void ejectQuarter();
    void turnCrank();
    void dispense();
}

// 具体状态
public class NoQuarterState implements State {
    GumballMachine gumballMachine;

    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() { /* ... */ }
    public void ejectQuarter() { /* ... */ }
    public void turnCrank()
   { /* ... */ }
   public void dispense() { /* ... */ }
}

// 其他具体状态类...

// 上下文
public class GumballMachine {
private State noQuarterState;
private State hasQuarterState;
// 其他状态
   private State state;
   private int count;

   public GumballMachine(int count) {
       this.count = count;
       noQuarterState = new NoQuarterState(this);
       hasQuarterState = new HasQuarterState(this);
       // 初始化其他状态

       state = noQuarterState;
   }

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

   public void insertQuarter() {
       state.insertQuarter();
   }

   public void ejectQuarter() {
       state.ejectQuarter();
   }

   public void turnCrank() {
       state.turnCrank();
   }

   public void releaseBall() {
       System.out.println("A gumball comes rolling out the slot...");
       if (count != 0) {
           count--;
       }
   }

   // 其他方法，如获取不同状态的对象等
}

代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。例如：

// 主题接口
public interface Image {
    void display();
}

// 真实主题
public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImage();
    }

    private void loadImage() { /* ... */ }

    public void display() { /* ... */ }
}

// 代理
public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

复合模式
桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变化。例如：

// 实现部分接口
public interface DrawAPI {
    void drawCircle(int radius, int x, int y);
}

// 具体实现
public class RedCircle implements DrawAPI {
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle [color: red, radius: " + radius + ", x: " + x + ", y:" + y + "]");
    }
}

public class GreenCircle implements DrawAPI {
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle [color: green, radius: " + radius + ", x: " + x + ", y:" + y + "]");
    }
}

// 抽象部分
public abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

// 扩展抽象部分
public class Circle extends Shape {
    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    public void draw() {
        drawAPI.drawCircle(radius, x, y);
    }
}

生成器模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。例如：

// 产品
public class Meal {
    private List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public float getCost() {
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }

    public void showItems() {
        for (Item item : items) {
            System.out.print("Item: " + item.name());
            System.out.print(", Packing: " + item.packing().pack());
            System.out.println(", Price: " + item.price());
        }
    }
}

// 生成器
public interface Item {
    String name();
    Packing packing();
    float price();
}

public interface Packing {
    String pack();
}

public abstract class Burger implements Item {
    public Packing packing() {
        return new Wrapper();
    }
}

public abstract class ColdDrink implements Item {
    public Packing packing() {
        return new Bottle();
    }
}

// 具体生成器
public class VegBurger extends Burger {
    public String name() {
        return "Veg Burger";
    }

    public float price() {
        return 25.0f;
    }
}

public class ChickenBurger extends Burger {
    public String name() {
        return "Chicken Burger";
    }

    public float price() {
        return 50.5f;
    }
}

public class Coke extends ColdDrink {
    public String name() {
        return "Coke";
    }

    public float price() {
        return 30.0f;
    }
}

public class Pepsi extends ColdDrink {
    public String name() {
        return "Pepsi";
    }

    public float price() {
        return 35.0f;
    }
}

// 指挥者
public class MealBuilder {
    public Meal prepareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

责任链模式：为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。例如：

// 抽象处理者
public abstract class Handler {
    protected Handler successor;

    // 设置下一个处理者
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    // 处理请求的抽象方法
    public abstract void handleRequest(int request);
}

// 具体处理者1
public class ConcreteHandler1 extends Handler {
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("Handler1处理请求" + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者2
public class ConcreteHandler2 extends Handler {
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("Handler2处理请求" + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者3
public class ConcreteHandler3 extends Handler {
    public void handleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println("Handler3处理请求" + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 客户端代码
public class ChainPatternDemo {
    private static Handler getChainOfHandlers() {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();

        h1.setSuccessor(h2);
        h2.setSuccessor(h3);

        return h1;
    }

    public static void main(String[] args) {
        Handler handlerChain = getChainOfHandlers();

        for (int i = 0; i < 35; i += 5) {
            handlerChain.handleRequest(i);
        }
    }
}

享元模式：运用共享技术有效地支持大量细粒度的对象。例如：

// 享元接口
public interface Shape {
    void draw();
}

// 具体享元
public class Circle implements Shape {
    private String color;
    private int x, y, radius;

    public Circle(String color) {
        this.color = color;
    }

    public void setX(int x) { this.x = x; }
    public void setY(int y) { this.y = y; }
    public void setRadius(int radius) { this.radius = radius; }

    public void draw() {
        System.out.println("Drawing Circle [color: " + color + ", x: " + x + ", y: " + y + ", radius: " + radius + "]");
    }
}

// 享元工厂
public class ShapeFactory {
    private final HashMap<String, Shape> circleMap = new HashMap<>();

    public Shape getCircle(String color) {
        Circle circle = (Circle)circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
        }
        return circle;
    }
}

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。例如：

// 解释器接口
public interface Expression {
    boolean interpret(String context);
}

// 终结符表达式
public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

// 非终结符表达式 - 或
public class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

// 非终结符表达式 - 与
public class AndExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public AndExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) && expr2.interpret(context);
    }
}

// 客户端代码
public class InterpreterPatternDemo {
    // 规则：Robert和John是男性
    public static Expression getMaleExpression() {
        Expression robert = new TerminalExpression("Robert");
        Expression john = new TerminalExpression("John");
        return new OrExpression(robert, john);
    }

    // 规则：Julie是一个已婚的女性
    public static Expression getMarriedWomanExpression() {
        Expression julie = new TerminalExpression("Julie");
        Expression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

    public static void main(String[] args) {
        Expression isMale = getMaleExpression();
        Expression isMarriedWoman = getMarriedWomanExpression();

        System.out.println("John 是男性吗？ " + isMale.interpret("John"));
        System.out.println("Julie 是一个已婚的女性吗？ " + isMarriedWoman.interpret("Married Julie"));
    }
}

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

// 抽象同事类
public abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void send(String message);

    public abstract void receive(String message);
}

// 抽象中介者类
public interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 具体同事类
public class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public void send(String message) {
        System.out.println("同事1发送消息: " + message);
        mediator.sendMessage(message, this);
    }

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

public class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void send(String message) {
        System.out.println("同事2发送消息: " + message);
        mediator.sendMessage(message, this);
    }

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

// 具体中介者类
public class ConcreteMediator implements Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

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

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

    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receive(message);
        } else {
            colleague1.receive(message);
        }
    }
}

// 客户端代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

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

        colleague1.send("你好，同事2！");
        colleague2.send("你好，同事1！");
    }
}

备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。

// 发起人
public class Originator {
    private String state;

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

    public String getState() {
        return state;
    }

    public Memento saveStateToMemento() {
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}

// 备忘录
public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

// 负责人
public class CareTaker {
    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento memento) {
        mementoList.add(memento);
    }

    public Memento get(int index) {
        return mementoList.get(index);
    }
}

// 客户端代码
public class MementoPatternDemo {
    public static void main(String[] args) {
        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();
        
        originator.setState("状态1");
        careTaker.add(originator.saveStateToMemento());
        
        originator.setState("状态2");
        careTaker.add(originator.saveStateToMemento());
        
        originator.setState("状态3");
        careTaker.add(originator.saveStateToMemento());
        
        System.out.println("当前状态: " + originator.getState());
        originator.getStateFromMemento(careTaker.get(0));
        System.out.println("恢复到状态1: " + originator.getState());
        originator.getStateFromMemento(careTaker.get(1));
        System.out.println("恢复到状态2: " + originator.getState());
    }
}

访问者模式：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

// 抽象元素
public interface Element {
    void accept(Visitor visitor);
}

// 具体元素
public class ConcreteElementA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return "具体元素A的操作";
    }
}

public class ConcreteElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationB() {
        return "具体元素B的操作";
    }
}

// 抽象访问者
public interface Visitor {
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}

// 具体访问者
public class ConcreteVisitor1 implements Visitor {
    public void visit(ConcreteElementA element) {
        System.out.println("访问者1访问：" + element.operationA());
    }

    public void visit(ConcreteElementB element) {
        System.out.println("访问者1访问：" + element.operationB());
    }
}

public class ConcreteVisitor2 implements Visitor {
    public void visit(ConcreteElementA element) {
        System.out.println("访问者2访问：" + element.operationA());
    }

    public void visit(ConcreteElementB element) {
        System.out.println("访问者2访问：" + element.operationB());
    }
}

// 对象结构
public class ObjectStructure {
    private List<Element> elements = new ArrayList<>();

    public void attach(Element element) {
        elements.add(element);
    }

    public void detach(Element element) {
        elements.remove(element);
    }

    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

// 客户端代码
public class VisitorPatternDemo {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.attach(new ConcreteElementA());
        objectStructure.attach(new ConcreteElementB());

        ConcreteVisitor1 visitor1 = new ConcreteVisitor1();
        ConcreteVisitor2 visitor2 = new ConcreteVisitor2();

        System.out.println("访问者1访问：");
        objectStructure.accept(visitor1);
        System.out.println("访问者2访问：");
        objectStructure.accept(visitor2);
    }
}