设计模式学习

1、策略模式是一种常用的设计模式，它允许在运行时选择算法的行为。在Java中，可以使用以下方式实现策略模式：
首先，定义策略接口（Strategy Interface），该接口定义了一个或多个算法方法。假设策略接口定义如下：
public interface Strategy {
void execute();
}
然后，创建具体的策略类（Concrete Strategy Classes），每个具体的策略类实现策略接口，并实现自己的算法。以下是两个具体策略类的示例：
public class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
// 实现策略A的算法逻辑
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
// 实现策略B的算法逻辑
}
}
在上述代码中，ConcreteStrategyA 和 ConcreteStrategyB 分别实现了策略接口 Strategy，并且根据自身的算法逻辑来实现 execute() 方法。
接下来，创建使用策略的上下文类（Context Class），该类持有一个策略接口的引用，并提供设置和使用策略的方法。以下是上下文类的示例：
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
在上述代码中，上下文类 Context 持有一个策略接口 Strategy 的引用，并提供了设置策略的方法 setStrategy() 和执行策略的方法 executeStrategy()。执行策略的方法实际上会调用当前设置的策略对象的 execute() 方法。
现在，可以在客户端代码中使用策略模式了：
public class Client {
public static void main(String[] args) {
Context context = new Context();
Strategy strategyA = new ConcreteStrategyA();
context.setStrategy(strategyA);
context.executeStrategy();
Strategy strategyB = new ConcreteStrategyB();
context.setStrategy(strategyB);
context.executeStrategy();
}
}
在客户端代码中，创建了上下文类 Context 的实例，并分别创建了策略对象 ConcreteStrategyA 和 ConcreteStrategyB。通过调用上下文类的 setStrategy() 方法设置不同的策略，然后调用 executeStrategy() 方法执行当前策略的算法。
这样就完成了策略模式的实现，可以根据需要在运行时选择不同的策略来完成相应的算法逻辑。

2、适配器模式是一种常用的设计模式，用于将一个类的接口转换成客户端所期望的另一种接口形式。在Java中，可以使用以下方式实现适配器模式：
首先，定义目标接口（Target Interface），这是客户端所期望的接口形式。假设目标接口定义如下：
public interface Target {
void request();
}
然后，创建适配器类（Adapter Class），该类实现目标接口，并且持有被适配的类的实例。适配器类需要将目标接口方法的调用转发给被适配的类。以下是一个简单的适配器类示例：
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
在上述代码中，适配器类实现了目标接口 Target，并且在构造函数中接受一个被适配的类 Adaptee 的实例。在 request() 方法中，适配器将调用被适配类的特定方法 specificRequest()。
最后，创建被适配的类（Adaptee Class），该类是需要被适配的现有类。假设被适配的类如下：
public class Adaptee {
public void specificRequest() {
// 执行特定的业务逻辑
}
}
现在，可以在客户端代码中使用适配器模式了：
public class Client {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target adapter = new Adapter(adaptee);
adapter.request();
}
}
在客户端代码中，创建了被适配的类 Adaptee 的实例，然后将其传递给适配器类 Adapter 的构造函数创建适配器实例。通过适配器实例调用目标接口的方法 request()，实际上会触发被适配类的方法 specificRequest() 的执行。
这样就完成了适配器模式的实现，使得客户端可以通过目标接口调用被适配类的功能。

3、代理模式是一种常见的设计模式，它允许通过代理对象来控制对真实对象的访问。在Java中，你可以使用接口或者继承来实现代理模式。下面是一种基于接口的代理模式实现示例：
首先，我们需要定义一个共享的接口，代表真实对象和代理对象的共同行为：
// 共享接口
public interface Image {
void display();
}
然后，我们创建真实对象实现该接口：
// 真实对象
public class RealImage implements Image {
private String filename;
public RealImage(String filename) {
this.filename = filename;
loadFromDisk();
}
private void loadFromDisk() {
System.out.println("从硬盘加载图像: " + filename);
}
public void display() {
System.out.println("显示图像: " + filename);
}
}
接下来，我们创建代理对象实现相同的接口，并在必要时调用真实对象：
// 代理对象
public class ProxyImage implements Image {
private String filename;
private RealImage realImage;
public ProxyImage(String filename) {
this.filename = filename;
}
public void display() {
if (realImage == null) {
realImage = new RealImage(filename);
}
realImage.display();
}
}
最后，我们可以使用代理对象来调用真实对象的方法：
// 客户端代码
public class Client {
public static void main(String[] args) {
Image image = new ProxyImage(“test.jpg”);
// 第一次调用，会加载真实对象
image.display();
// 第二次调用，直接使用代理对象
image.display();
}
}
运行以上代码，输出将会是：
从硬盘加载图像: test.jpg
显示图像: test.jpg
显示图像: test.jpg
通过代理对象，我们可以在真实对象的加载、初始化或者其他操作前后进行控制。这使得代理模式在需要控制对象访问的场景中非常有用，比如延迟加载、权限验证等。

4、生产者-消费者模式是一种并发设计模式，用于解决生产者和消费者之间的数据共享和通信问题。在Java中，可以使用多线程和相关的同步机制来实现生产者-消费者模式。以下是一种基本的Java实现示例：
import java.util.LinkedList;
// 共享的缓冲区
class Buffer {
private LinkedList buffer = new LinkedList<>();
private int maxSize;
public Buffer(int maxSize) {
this.maxSize = maxSize;
}
public synchronized void produce(int item) throws InterruptedException {
while (buffer.size() == maxSize) {
// 缓冲区已满，等待消费者消费
wait();
}
buffer.add(item);
System.out.println("生产者生产: " + item);
notifyAll(); // 通知消费者可以消费
}
public synchronized int consume() throws InterruptedException {
while (buffer.isEmpty()) {
// 缓冲区为空，等待生产者生产
wait();
}
int item = buffer.removeFirst();
System.out.println("消费者消费: " + item);
notifyAll(); // 通知生产者可以生产
return item;
}
}
// 生产者线程
class Producer implements Runnable {
private Buffer buffer;
private int count;
public Producer(Buffer buffer, int count) {
this.buffer = buffer;
this.count = count;
}
public void run() {
try {
for (int i = 0; i < count; i++) {
buffer.produce(i);
Thread.sleep(100); // 模拟生产时间
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
// 消费者线程
class Consumer implements Runnable {
private Buffer buffer;
private int count;
public Consumer(Buffer buffer, int count) {
this.buffer = buffer;
this.count = count;
}
public void run() {
try {
for (int i = 0; i < count; i++) {
buffer.consume();
Thread.sleep(200); // 模拟消费时间
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
// 主程序
public class ProducerConsumerExample {
public static void main(String[] args) {
Buffer buffer = new Buffer(5); // 创建缓冲区，最大容量为5
// 创建生产者和消费者线程
Producer producer = new Producer(buffer, 10);
Consumer consumer = new Consumer(buffer, 10);
// 创建线程并启动
Thread producerThread = new Thread(producer);
Thread consumerThread = new Thread(consumer);
producerThread.start();
consumerThread.start();
}
}
上述示例中，Buffer 类表示共享的缓冲区，produce() 方法用于生产数据，consume() 方法用于消费数据。Producer 类和 Consumer 类分别表示生产者线程和消费者线程。在主程序中，创建了一个缓冲区和两个线程，分别用于生产和消费数据。
通过使用synchronized关键字和wait()、notifyAll()方法来实现线程间