（Java基础笔记vlog）Java中常见的几种设计模式详解

前言：

在 Java 编程里，设计模式是被反复使用、多数人知晓、经过分类编目的代码设计经验总结。他能帮助开发者更高效地解决常见问题，提升代码的可维护性、可扩展性和复用性。下面介绍Java 中几种常见的设计模式。

单例模式（Singleton Pattern）
工厂模式（Factory Pattern）
代理模式（Proxy Pattern）
装饰器模式（Decorator Pattern）
观察者模式（Observer Pattern）
策略模式（Strategy Pattern）
模板方法模式（Template Method Pattern）
适配器模式（Adapter Pattern）
责任链模式（Chain of Responsibility Pattern）

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）

核心思想：他通过封装对象的创建逻辑，实现了对象创建和使用的分离，提高了代码的可维护性和可扩展性。

示例：

// 接口
interface Shape {void draw();
}// 实现类
class Circle implements Shape {@Overridepublic void draw() {System.out.println("画一个圆形");}
}class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("画一个矩形");}
}// 工厂类
class ShapeFactory {public Shape getShape(String shapeType) {if (shapeType == null) {return null;}if (shapeType.equalsIgnoreCase("CIRCLE")) {return new Circle();} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {return new Rectangle();}return null;}
}

3.代理模式（Proxy Pattern）

核心思想：为其他对象提供一种代理以控制对这个对象的访问。

示例：

// 抽象主题接口
public interface Subject {void request();
}// 真实主题类
public class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject request");}
}// 代理类
public class Proxy implements Subject {private RealSubject realSubject;@Overridepublic void request() {if (realSubject == null) {realSubject = new RealSubject();}realSubject.request();  // 代理控制对真实主题的访问}
}// 客户端代码
public class Client {public static void main(String[] args) {Subject proxy = new Proxy();proxy.request();  // 通过代理访问真实主题}
}

4.装饰器模式（Decorator Pattern）

核心思想：装饰器模式动态地给一个对象添加一些额外的职责。

示例：

// 接口
interface Coffee {double getCost();String getDescription();
}// 基础实现
class SimpleCoffee implements Coffee {@Overridepublic double getCost() {return 1.0;}@Overridepublic String getDescription() {return "简单咖啡";}
}// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {protected Coffee decoratedCoffee;public CoffeeDecorator(Coffee decoratedCoffee) {this.decoratedCoffee = decoratedCoffee;}@Overridepublic double getCost() {return decoratedCoffee.getCost();}@Overridepublic String getDescription() {return decoratedCoffee.getDescription();}
}// 具体装饰器
class Milk extends CoffeeDecorator {public Milk(Coffee decoratedCoffee) {super(decoratedCoffee);}@Overridepublic double getCost() {return decoratedCoffee.getCost() + 0.5;}@Overridepublic String getDescription() {return decoratedCoffee.getDescription() + ", 加牛奶";}
}

5.观察者模式（Observer Pattern）

核心思想：观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并被自动更新。

示例：

import java.util.ArrayList;
import java.util.List;// 主题接口
interface Subject {void registerObserver(Observer o);void removeObserver(Observer o);void notifyObservers();
}// 观察者接口
interface Observer {void update(double temperature, double humidity, double pressure);
}// 具体主题
class WeatherData implements Subject {private List<Observer> observers;private double temperature;private double humidity;private double pressure;public WeatherData() {observers = new ArrayList<>();}@Overridepublic void registerObserver(Observer o) {observers.add(o);}@Overridepublic void removeObserver(Observer o) {observers.remove(o);}@Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update(temperature, humidity, pressure);}}public void measurementsChanged() {notifyObservers();}public void setMeasurements(double temperature, double humidity, double pressure) {this.temperature = temperature;this.humidity = humidity;this.pressure = pressure;measurementsChanged();}
}

6.策略模式（Strategy Pattern）

核心思想：策略模式定义一系列的算法，并将每个算法封装起来，使他们可以相互替换。

示例：

// 策略接口
interface PaymentStrategy {void pay(int amount);
}// 具体策略
class CreditCardStrategy implements PaymentStrategy {private String cardNumber;private String cvv;private String dateOfExpiry;public CreditCardStrategy(String cardNumber, String cvv, String dateOfExpiry) {this.cardNumber = cardNumber;this.cvv = cvv;this.dateOfExpiry = dateOfExpiry;}@Overridepublic void pay(int amount) {System.out.println(amount + " 元使用信用卡支付");}
}class PayPalStrategy implements PaymentStrategy {private String emailId;private String password;public PayPalStrategy(String emailId, String password) {this.emailId = emailId;this.password = password;}@Overridepublic void pay(int amount) {System.out.println(amount + " 元使用PayPal支付");}
}// 上下文
class ShoppingCart {private PaymentStrategy paymentStrategy;public void setPaymentStrategy(PaymentStrategy paymentStrategy) {this.paymentStrategy = paymentStrategy;}public void pay(int amount) {paymentStrategy.pay(amount);}
}

7.模板方法模式（Template Method Pattern）

核心思想：模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

示例：

// 抽象类
abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();// 模板方法public final void play() {// 初始化游戏initialize();// 开始游戏startPlay();// 结束游戏endPlay();}
}// 具体类
class Cricket extends Game {@Overridevoid initialize() {System.out.println("板球游戏初始化，准备场地");}@Overridevoid startPlay() {System.out.println("板球游戏开始，玩起来！");}@Overridevoid endPlay() {System.out.println("板球游戏结束，统计分数");}
}class Football extends Game {@Overridevoid initialize() {System.out.println("足球游戏初始化，准备场地和球");}@Overridevoid startPlay() {System.out.println("足球游戏开始，踢起来！");}@Overridevoid endPlay() {System.out.println("足球游戏结束，统计分数");}
}

8.适配器模式（Adapter Pattern）

核心思想：适配器模式将一个类的接口转换成客户希望的另外一个接口。

示例：

// 目标接口
interface MediaPlayer {void play(String audioType, String fileName);
}// 被适配的类
class VlcPlayer {public void playVlc(String fileName) {System.out.println("播放VLC文件: " + fileName);}
}// 适配器
class MediaAdapter implements MediaPlayer {private VlcPlayer vlcPlayer;public MediaAdapter() {vlcPlayer = new VlcPlayer();}@Overridepublic void play(String audioType, String fileName) {if (audioType.equalsIgnoreCase("vlc")) {vlcPlayer.playVlc(fileName);}}
}// 具体实现类
class AudioPlayer implements MediaPlayer {private MediaAdapter mediaAdapter;@Overridepublic void play(String audioType, String fileName) {if (audioType.equalsIgnoreCase("vlc")) {mediaAdapter = new MediaAdapter();mediaAdapter.play(audioType, fileName);} else {System.out.println("播放 " + audioType + " 文件: " + fileName);}}
}

9.责任链模式（Chain of Responsibility Pattern）

核心思想：责任链模式为请求创建了一个接收者对象的链，每个接收者都包含对另一个接收者的引用。

示例：

// 抽象处理者
abstract class Handler {protected Handler nextHandler;public void setNextHandler(Handler nextHandler) {this.nextHandler = nextHandler;}public abstract void handleRequest(int request);
}// 具体处理者
class ConcreteHandler1 extends Handler {@Overridepublic void handleRequest(int request) {if (request < 10) {System.out.println("处理请求: " + request);} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}class ConcreteHandler2 extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 10 && request < 20) {System.out.println("处理请求: " + request);} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}class ConcreteHandler3 extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 20) {System.out.println("处理请求: " + request);} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}