在软件开发中，设计模式是提高代码质量、可维护性以及扩展性的有效工具。Java开发中，JDK的源码中包含了许多经典的设计模式，这些模式不仅为我们提供了有力的编程规范，还能帮助开发者在实际项目中解决常见问题。今天，我们就一起来详细探讨一下在JDK中有哪些常见的设计模式，并分析它们的定义、应用场景，以及如何在JDK源码中体现。
1. 单例模式 (Singleton Pattern)
单例模式是最为常见的设计模式之一，其核心思想是在整个程序运行过程中，确保某个类只有一个实例。对于一些需要全局共享资源的对象（如数据库连接、线程池等），单例模式提供了一个非常有效的解决方案。举个例子，在JDK中，Runtime类就是一个典型的单例模式。
代码示例：
public class Singleton {
private static Singleton instance;
private Singleton() { }
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
Runtime类采用了懒汉模式（Lazy Initialization）。它通过延迟初始化方式，在第一次使用时创建唯一的实例。例如，Runtime.getRuntime()方法返回的是当前JVM的唯一实例。
单例模式的懒汉模式通过双重检查锁（Double-Checked Locking）优化了性能，避免了每次获取实例时都进行同步。
2. 工厂模式 (Factory Pattern)
工厂模式通过定义一个创建对象的接口，让子类决定实例化哪个类。工厂模式常用于解耦复杂对象的创建过程，JDK中许多类都采用了工厂模式。一个典型的例子是ThreadPoolExecutor类中的线程创建。
在JDK中，ThreadFactory接口定义了一个工厂方法，用于创建线程。你可以通过自定义工厂来定制线程的创建逻辑，比如设置线程的优先级、名称等。
代码示例：
public class MyThreadFactory implements ThreadFactory {
private final String namePrefix;
private int threadNumber = 1;
public MyThreadFactory(String namePrefix) {
this.namePrefix = namePrefix;
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, namePrefix + "-thread-" + threadNumber++);
return t;
}
}
这里我们实现了一个自定义的ThreadFactory，每次创建的线程都带有一个特定的名称。
3. 代理模式 (Proxy Pattern)
代理模式通过代理对象来控制对目标对象的访问。JDK提供了动态代理机制，最常见的实现是通过Proxy类和InvocationHandler接口来创建动态代理对象。这个模式在AOP（面向切面编程）中有着广泛的应用，例如Spring框架的事务管理就是基于代理模式实现的。
代码示例：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Service {
void doService();
}
class RealService implements Service {
public void doService() {
System.out.println("Performing service...");
}
}
class MyInvocationHandler implements InvocationHandler {
private final Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method execution...");
Object result = method.invoke(target, args);
System.out.println("After method execution...");
return result;
}
}
public class ProxyExample {
public static void main(String[] args) {
Service realService = new RealService();
Service proxyService = (Service) Proxy.newProxyInstance(
realService.getClass().getClassLoader(),
realService.getClass().getInterfaces(),
new MyInvocationHandler(realService)
);
proxyService.doService();
}
}
在这个例子中，我们使用了JDK的动态代理功能，为RealService类创建了一个代理类，代理类在执行方法前后打印日志。
4. 迭代器模式 (Iterator Pattern)
迭代器模式是处理集合类遍历的常用模式，它允许通过统一的接口遍历不同的数据集合。在JDK中，Iterator接口就是这一模式的体现，它定义了两个核心方法：hasNext()和next()，用于逐一访问集合中的元素。
在JDK的集合类中，几乎所有的集合都实现了Iterable接口，允许我们通过Iterator来遍历数据。
代码示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
在这个例子中，ArrayList实现了Iterable接口，我们可以通过iterator()方法获取到一个Iterator对象，并使用它来遍历集合中的元素。
5. 模板方法模式 (Template Method Pattern)
模板方法模式定义了一个操作中的算法框架，而将一些步骤延迟到子类中。子类可以在不改变算法结构的前提下实现某些特定的步骤。
JDK中的synchronized和AbstractQueuedSynchronizer（AQS）类是模板方法模式的经典例子。AQS定义了加锁、释放锁的模板方法，而具体的加锁逻辑则由子类实现。
代码示例：
abstract class AbstractTask {
public void execute() {
doPreProcessing();
doMainTask();
doPostProcessing();
}
protected abstract void doPreProcessing();
protected abstract void doMainTask();
protected abstract void doPostProcessing();
}
class ConcreteTask extends AbstractTask {
@Override
protected void doPreProcessing() {
System.out.println("Preparing task...");
}
@Override
protected void doMainTask() {
System.out.println("Executing main task...");
}
@Override
protected void doPostProcessing() {
System.out.println("Cleaning up after task...");
}
}
public class TemplateMethodExample {
public static void main(String[] args) {
AbstractTask task = new ConcreteTask();
task.execute();
}
}
在这个例子中，AbstractTask类定义了任务的执行流程，ConcreteTask类实现了具体的操作。
在面向对象设计中，设计模式是解决特定类型问题的一种方法论，它提供了可以重用的解决方案，帮助开发者提高代码的可维护性、灵活性以及可扩展性。以下是三种常见的设计模式，它们分别是：装饰器模式、策略模式和建造者模式。我们将通过Java代码示例来详细解释它们的实现原理和应用场景。
6. 装饰器模式 (Decorator Pattern)
装饰器模式是一种结构型设计模式，它允许在不改变对象自身的情况下，动态地给一个对象增加一些额外的职责。该模式通常用于增强某个对象的功能，而不影响其他对象。
例子：Java IO中的装饰器模式
在Java的IO流处理中，BufferedInputStream和BufferedOutputStream类便是典型的装饰器模式应用。它们“装饰”了原始的InputStream和OutputStream类，通过引入缓冲区来优化读取和写入性能，而不改变原始流的行为。
下面是一个简单的示例代码，展示如何使用装饰器模式增强一个基础的输入流：
import java.io.*;
public class DecoratorPatternExample {
public static void main(String[] args) {
try {
// 创建一个FileInputStream对象，它是原始的输入流
FileInputStream fileInputStream = new FileInputStream("example.txt");
// 使用BufferedInputStream装饰FileInputStream，增加缓冲功能
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
// 读取文件内容
int data;
while ((data = bufferedInputStream.read()) != -1) {
System.out.print((char) data);
}
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
在上述代码中，BufferedInputStream并没有改变FileInputStream的基本行为（如读取文件），而是通过添加缓冲区机制，显著提高了性能。这正是装饰器模式的核心思想。
装饰器模式允许我们在不修改对象代码的情况下，动态地为对象添加新的功能。Java IO类中的BufferedInputStream和BufferedOutputStream正是这一模式的典型实现。
7. 策略模式 (Strategy Pattern)
策略模式是一种行为型设计模式，它通过定义一系列的算法，将每个算法封装起来，让它们可以互换使用。客户端可以根据需要选择合适的策略，而不需要修改算法本身。
例子：支付方式的策略模式
假设你在开发一个电子商务系统，系统需要支持多种支付方式，如支付宝、微信支付和信用卡支付。使用策略模式，可以将每种支付方式封装成一个独立的策略类，通过动态切换策略来完成支付操作。
下面是一个支付策略的Java实现：
// 策略接口
interface PaymentStrategy {
void pay(int amount);
}
// 具体策略：支付宝支付
class AlipayPayment implements PaymentStrategy {
public void pay(int amount) {
System.out.println("Using Alipay to pay " + amount + " dollars.");
}
}
// 具体策略：微信支付
class WeChatPayment implements PaymentStrategy {
public void pay(int amount) {
System.out.println("Using WeChat to pay " + amount + " dollars.");
}
}
// 具体策略：信用卡支付
class CreditCardPayment implements PaymentStrategy {
public void pay(int amount) {
System.out.println("Using Credit Card to pay " + amount + " dollars.");
}
}
// 上下文：用户选择支付方式
class PaymentContext {
private PaymentStrategy paymentStrategy;
// 设置支付策略
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
// 执行支付操作
public void executePayment(int amount) {
paymentStrategy.pay(amount);
}
}
public class StrategyPatternExample {
public static void main(String[] args) {
// 创建支付上下文
PaymentContext context = new PaymentContext();
// 使用支付宝支付
context.setPaymentStrategy(new AlipayPayment());
context.executePayment(100);
// 使用微信支付
context.setPaymentStrategy(new WeChatPayment());
context.executePayment(200);
// 使用信用卡支付
context.setPaymentStrategy(new CreditCardPayment());
context.executePayment(300);
}
}
在上述代码中，PaymentStrategy接口定义了一个pay方法，不同的支付方式（如AlipayPayment、WeChatPayment和CreditCardPayment）都实现了该接口。PaymentContext类则负责选择和执行支付策略。通过策略模式，系统能够方便地扩展新的支付方式，而不需要修改现有代码。
策略模式提供了一种通过定义一系列算法来让它们互换使用的方式。通过将支付方式封装为不同的策略类，我们可以在不修改代码的情况下添加新的支付方式。
8. 建造者模式 (Builder Pattern)
建造者模式是一种创建型设计模式，它通过提供一个步骤化的构建过程，隐藏了对象创建的复杂性。它将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
例子：StringBuilder的建造者模式
在Java中，StringBuilder类便是建造者模式的一个经典例子。StringBuilder允许通过逐步调用append()方法来构建一个字符串，避免了频繁创建中间对象的性能开销。
以下是使用StringBuilder构建字符串的示例：
public class BuilderPatternExample {
public static void main(String[] args) {
// 创建一个StringBuilder对象
StringBuilder stringBuilder = new StringBuilder();
// 逐步构建字符串
stringBuilder.append("Hello");
stringBuilder.append(", ");
stringBuilder.append("World");
stringBuilder.append("!");
// 打印最终构建的字符串
System.out.println(stringBuilder.toString());
}
}
在这个例子中，StringBuilder的append()方法将字符串的各个部分逐步拼接起来，而不需要每次拼接时创建新的字符串对象。这种方式不仅减少了内存开销，而且提高了性能，尤其在需要频繁修改字符串时非常有效。
建造者模式通过一步步构建复杂对象的方式，简化了对象创建的过程。StringBuilder正是通过这个模式，避免了大量不必要的字符串对象创建，提高了性能。
总结：
通过深入理解这些设计模式，开发者可以在项目开发中更灵活地选择合适的设计模式来解决实际问题。同时，在面试过程中，能够清楚地讲解设计模式的定义、应用场景及源码中的实现，将大大提升面试官对你的技术水平的认可。希望大家能够通过学习JDK中的设计模式，提升自己的编程能力和设计思维，写出更加高效、可维护的代码。
