引言
Java设计模式是一套经过验证的、可重用的代码设计解决方案，旨在解决软件开发过程中常见的问题。通过掌握设计模式，开发者能够编写出更加可维护、可扩展和可重用的代码。本文将深入解析Java设计模式，并通过实战案例进行深度剖析，帮助读者更好地理解和应用这些设计模式。
一、创建型模式
1. 单例模式（Singleton Pattern）
单例模式确保一个类只有一个实例，并提供全局访问点。实现方式包括静态内部类、枚举和双检锁等。
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
2. 工厂模式（Factory Pattern）
工厂模式提供创建对象的接口，但不指定具体类。常见实现包括简单工厂、工厂方法和抽象工厂模式。
public interface Product {
void use();
}
public class ConcreteProductA implements Product {
public void use() {
System.out.println("使用具体产品A");
}
}
public class ConcreteProductB implements Product {
public void use() {
System.out.println("使用具体产品B");
}
}
public class Factory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
return null;
}
}
3. 建造者模式（Builder Pattern）
建造者模式将复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
public class Person {
private String name;
private int age;
private String address;
public static class Builder {
private String name;
private int age;
private String address;
public Builder setName(String name) {
this.name = name;
return this;
}
public Builder setAge(int age) {
this.age = age;
return this;
}
public Builder setAddress(String address) {
this.address = address;
return this;
}
public Person build() {
return new Person(this);
}
}
private Person(Builder builder) {
this.name = builder.name;
this.age = builder.age;
this.address = builder.address;
}
}
二、结构型模式
1. 适配器模式（Adapter Pattern）
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以一起工作。
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
System.out.println("特有功能");
}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
2. 桥接模式（Bridge Pattern）
桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。
public abstract class Abstraction {
protected Implementor implementor;
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}
public abstract void operation();
}
public class RefinedAbstraction extends Abstraction {
@Override
public void operation() {
System.out.println("RefinedAbstraction operation");
implementor.operation();
}
}
public abstract class Implementor {
public abstract void operation();
}
public class ConcreteImplementorA extends Implementor {
@Override
public void operation() {
System.out.println("ConcreteImplementorA operation");
}
}
三、行为型模式
1. 策略模式（Strategy Pattern）
策略模式定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。
public interface Strategy {
void execute();
}
public class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("执行策略A");
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
System.out.println("执行策略B");
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
总结
本文深入解析了Java设计模式，并通过实战案例进行了深度剖析。通过学习本文，读者可以更好地理解和应用Java设计模式，从而提高代码质量，降低维护成本。在实际开发过程中，选择合适的设计模式，可以使得代码更加清晰、易维护，提高开发效率。