Java设计模式是指在Java编程中，经过长期实践总结出的、用于解决特定设计问题的可复用解决方案。这些设计模式可以帮助开发者更加优雅、高效地进行软件设计，提高代码的可维护性和可重用性。
Java设计模式大致可以分为三大类：创建型模式、结构型模式和行为型模式。以下是每种类型的详细解释和常见的设计模式示例：
创建型模式
创建型模式主要关注对象的创建过程，通过控制对象的实例化过程，来实现解耦和灵活创建对象。常见的创建型模式有：
- 工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
以下是一个简单的Java示例来说明工厂方法模式：
假设我们有一个形状（Shape）的抽象类和几个具体的形状类（如圆形Circle、矩形Rectangle）。我们想要一个统一的接口来创建这些形状，但不希望直接依赖于具体的形状类。这时，我们可以使用工厂方法模式。
首先，我们定义一个抽象的Shape接口和一个抽象的ShapeFactory类：
// 形状接口
public interface Shape {
void draw();
}
// 圆形
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a circle.");
}
}
// 矩形
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a rectangle.");
}
}
// 抽象工厂类
public abstract class ShapeFactory {
// 工厂方法，由子类实现
public abstract Shape createShape();
}
然后，我们为每种形状创建一个具体的工厂类，它们实现了ShapeFactory的createShape()方法：
// 圆形工厂
public class CircleFactory extends ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}
// 矩形工厂
public class RectangleFactory extends ShapeFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
}
最后，我们可以在客户端代码中使用这些工厂类来创建形状对象：
public class FactoryMethodDemo {
public static void main(String[] args) {
// 使用圆形工厂创建圆形
ShapeFactory circleFactory = new CircleFactory();
Shape circle = circleFactory.createShape();
circle.draw(); // 输出: Drawing a circle.
// 使用矩形工厂创建矩形
ShapeFactory rectangleFactory = new RectangleFactory();
Shape rectangle = rectangleFactory.createShape();
rectangle.draw(); // 输出: Drawing a rectangle.
}
}
在这个例子中，ShapeFactory是一个抽象工厂类，它定义了一个createShape()方法作为工厂方法。具体的工厂类（CircleFactory和RectangleFactory）继承自ShapeFactory并实现了createShape()方法，分别返回Circle和Rectangle的实例。这样，客户端代码就可以通过具体的工厂类来创建不同类型的形状对象，而无需直接依赖于具体的形状类。这增加了代码的灵活性和可维护性。
- 抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
以下是一个使用抽象工厂模式的Java示例，其中有两个产品族：汽车（Car）和摩托车（Motorcycle），每个产品族下都有两种类型的产品：电动车（Electric）和燃油车（Gasoline）。
首先，我们定义产品的接口：
// 汽车接口
public interface Car {
void manufacture();
}
// 电动车
public class ElectricCar implements Car {
@Override
public void manufacture() {
System.out.println("Manufacturing an electric car.");
}
}
// 燃油车
public class GasolineCar implements Car {
@Override
public void manufacture() {
System.out.println("Manufacturing a gasoline car.");
}
}
// 摩托车接口
public interface Motorcycle {
void manufacture();
}
// 电动摩托车
public class ElectricMotorcycle implements Motorcycle {
@Override
public void manufacture() {
System.out.println("Manufacturing an electric motorcycle.");
}
}
// 燃油摩托车
public class GasolineMotorcycle implements Motorcycle {
@Override
public void manufacture() {
System.out.println("Manufacturing a gasoline motorcycle.");
}
}
接下来，我们定义抽象工厂接口和具体工厂类：
// 抽象工厂接口
public interface VehicleFactory {
Car createCar();
Motorcycle createMotorcycle();
}
// 具体工厂类：电动车工厂
public class ElectricVehicleFactory implements VehicleFactory {
@Override
public Car createCar() {
return new ElectricCar();
}
@Override
public Motorcycle createMotorcycle() {
return new ElectricMotorcycle();
}
}
// 具体工厂类：燃油车工厂
public class GasolineVehicleFactory implements VehicleFactory {
@Override
public Car createCar() {
return new GasolineCar();
}
@Override
public Motorcycle createMotorcycle() {
return new GasolineMotorcycle();
}
}
最后，我们编写客户端代码来使用这些工厂：
public class AbstractFactoryDemo {
public static void main(String[] args) {
// 使用电动车工厂
VehicleFactory electricFactory = new ElectricVehicleFactory();
Car electricCar = electricFactory.createCar();
Motorcycle electricMotorcycle = electricFactory.createMotorcycle();
electricCar.manufacture();
electricMotorcycle.manufacture();
// 使用燃油车工厂
VehicleFactory gasolineFactory = new GasolineVehicleFactory();
Car gasolineCar = gasolineFactory.createCar();
Motorcycle gasolineMotorcycle = gasolineFactory.createMotorcycle();
gasolineCar.manufacture();
gasolineMotorcycle.manufacture();
}
}
运行客户端代码，你将看到以下输出：
Manufacturing an electric car.
Manufacturing an electric motorcycle.
Manufacturing a gasoline car.
Manufacturing a gasoline motorcycle.
这个示例展示了抽象工厂模式如何使客户端代码与具体的产品实现解耦，客户端只需要知道它正在使用的工厂类型，而不需要知道实际创建的产品类型。这增加了代码的灵活性和可维护性。
- 单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。常见的实现方式有懒汉式和饿汉式。
以下是一个简单的Java示例来说明单例模式：
public class Singleton {
// 声明一个静态的Singleton实例，使用volatile确保线程安全（在Java 1.5及以上）
private volatile static Singleton instance;
// 私有的构造方法，防止外部类实例化
private Singleton() {}
// 提供一个静态的公有方法，用于获取Singleton的实例
public static Singleton getInstance() {
// 如果instance为null，则创建一个新的实例
// 双重检查锁定确保线程安全且只创建一个实例
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
// 其他方法...
public void doSomething() {
// ...
}
}
在这个例子中，Singleton类有一个私有的构造方法，这意味着外部类不能实例化它。相反，它提供了一个静态的公有方法getInstance()，该方法在第一次被调用时创建Singleton的实例，并在后续调用时返回该实例。
注意这里使用了双重检查锁定（double-checked locking）来确保线程安全。这是因为在多线程环境中，多个线程可能同时检查instance是否为null，并尝试创建新的实例。双重检查锁定确保只有一个线程能够创建实例，而其他线程则等待直到实例被创建。
另外，volatile关键字用于确保instance变量的可见性，即当一个线程修改了instance的值时，其他线程能够立即看到这个修改。
建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
结构型模式
结构型模式主要关注类和对象的组合方式，通过组合已有类来创建具有全新功能的结构。常见的结构型模式有：
适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而无法一起工作的类能够一起工作。
桥接模式（Bridge）：将抽象部分与实现部分分离，使它们都可以独立地变化。
组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构，使得客户对单个对象和复合对象的使用具有一致性。
装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活。
外观模式（Facade）：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度对象的复用。
代理模式（Proxy）：为其他对象提供一个代理以控制对这个对象的访问。
行为型模式
行为型模式主要关注对象之间的通信和协作方式，通过定义对象之间的交互规则，实现更加灵活和高效的功能。常见的行为型模式有：
- 策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换。策略模式使得算法可以独立于使用它的客户变化。
以下是一个简单的策略模式的例子，用于描述不同的支付方式：
首先，我们定义一个支付策略接口（Strategy）：
public interface PaymentStrategy {
double calculatePayment(double amount);
}
然后，我们实现几个具体的支付策略（ConcreteStrategy），比如现金支付和信用卡支付：
public class CashPaymentStrategy implements PaymentStrategy {
@Override
public double calculatePayment(double amount) {
// 假设没有手续费
return amount;
}
}
public class CreditCardPaymentStrategy implements PaymentStrategy {
private double serviceFeeRate = 0.02; // 假设手续费率为2%
@Override
public double calculatePayment(double amount) {
return amount * (1 + serviceFeeRate);
}
}
接着，我们定义一个环境类（Context），它持有一个对支付策略的引用，并提供一个方法来执行支付策略：
public class PaymentContext {
private PaymentStrategy paymentStrategy;
public PaymentContext(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public double pay(double amount) {
return paymentStrategy.calculatePayment(amount);
}
// 可以提供方法来更换支付策略
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
}
最后，我们在客户端代码中使用这些类：
public class PaymentClient {
public static void main(String[] args) {
// 创建一个现金支付的上下文
PaymentContext cashPaymentContext = new PaymentContext(new CashPaymentStrategy());
double cashPayment = cashPaymentContext.pay(100.0);
System.out.println("Cash payment: " + cashPayment);
// 切换到信用卡支付
cashPaymentContext.setPaymentStrategy(new CreditCardPaymentStrategy());
double creditCardPayment = cashPaymentContext.pay(100.0);
System.out.println("Credit card payment: " + creditCardPayment);
}
}
在这个例子中，PaymentStrategy是一个抽象策略类，定义了所有支持的算法的公共接口。CashPaymentStrategy和CreditCardPaymentStrategy是具体策略类，实现了具体的支付算法。PaymentContext是环境类，它持有对PaymentStrategy对象的引用，并定义了一个pay方法来执行支付策略。客户端代码可以根据需要选择使用哪种支付策略，并可以随时更改支付策略。
模板方法模式（Template Method）：定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
观察者模式（Observer）：定义对象之间的一对多依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生改变时，它的所有依赖者（观察者）都会收到通知并自动更新。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
责任链模式（Chain of Responsibility）：避免请求发送者与接收者耦合在一起，让多个对象都有可能成为请求的接收者，将这些对象连接成一条链，并且沿着这条链传递该请求，直到有对象处理它为止。
命令模式（Command）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
解释器模式（Interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
这些设计模式在Java编程中都有广泛的应用，它们可以帮助我们更好地理解和设计复杂的软件系统。