（Java根本笔记log）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）

核心思想：封装化所有构造方法确保一个类只有一个实例，并提供一个全局访问点。
示例：

2. public class Singleton {
3.     // 类加载时不创建实例
4.     private static volatile Singleton instance;
6.     // 私有构造函数，防止外部实例化
7.     private Singleton() {}
9.     // 提供全局访问点，使用双重检查锁定机制保证线程安全
10.     public static Singleton getInstance() {
11.         if (instance == null) {
12.             synchronized (Singleton.class) {
13.                 if (instance == null) {
14.                     instance = new Singleton();
15.                 }
16.             }
17.         }
18.         return instance;
19.     }
20. }

复制代码

2.工厂模式（Factory Pattern）

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

2. // 接口
3. interface Shape {
4.     void draw();
5. }
7. // 实现类
8. class Circle implements Shape {
9.     @Override
10.     public void draw() {
11.         System.out.println("画一个圆形");
12.     }
13. }
15. class Rectangle implements Shape {
16.     @Override
17.     public void draw() {
18.         System.out.println("画一个矩形");
19.     }
20. }
22. // 工厂类
23. class ShapeFactory {
24.     public Shape getShape(String shapeType) {
25.         if (shapeType == null) {
26.             return null;
27.         }
28.         if (shapeType.equalsIgnoreCase("CIRCLE")) {
29.             return new Circle();
30.         } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
31.             return new Rectangle();
32.         }
33.         return null;
34.     }
35. }

复制代码

3.代理模式（Proxy Pattern）

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

2. // 抽象主题接口
3. public interface Subject {
4.     void request();
5. }
7. // 真实主题类
8. public class RealSubject implements Subject {
9.     @Override
10.     public void request() {
11.         System.out.println("RealSubject request");
12.     }
13. }
15. // 代理类
16. public class Proxy implements Subject {
17.     private RealSubject realSubject;
19.     @Override
20.     public void request() {
21.         if (realSubject == null) {
22.             realSubject = new RealSubject();
23.         }
24.         realSubject.request();  // 代理控制对真实主题的访问
25.     }
26. }
28. // 客户端代码
29. public class Client {
30.     public static void main(String[] args) {
31.         Subject proxy = new Proxy();
32.         proxy.request();  // 通过代理访问真实主题
33.     }
34. }

复制代码

4.装饰器模式（Decorator Pattern）

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

2. // 接口
3. interface Coffee {
4.     double getCost();
5.     String getDescription();
6. }
8. // 基础实现
9. class SimpleCoffee implements Coffee {
10.     @Override
11.     public double getCost() {
12.         return 1.0;
13.     }
14.     @Override
15.     public String getDescription() {
16.         return "简单咖啡";
17.     }
18. }
20. // 装饰器抽象类
21. abstract class CoffeeDecorator implements Coffee {
22.     protected Coffee decoratedCoffee;
23.     public CoffeeDecorator(Coffee decoratedCoffee) {
24.         this.decoratedCoffee = decoratedCoffee;
25.     }
26.     @Override
27.     public double getCost() {
28.         return decoratedCoffee.getCost();
29.     }
30.     @Override
31.     public String getDescription() {
32.         return decoratedCoffee.getDescription();
33.     }
34. }
36. // 具体装饰器
37. class Milk extends CoffeeDecorator {
38.     public Milk(Coffee decoratedCoffee) {
39.         super(decoratedCoffee);
40.     }
41.     @Override
42.     public double getCost() {
43.         return decoratedCoffee.getCost() + 0.5;
44.     }
45.     @Override
46.     public String getDescription() {
47.         return decoratedCoffee.getDescription() + ", 加牛奶";
48.     }
49. }

复制代码

5.观察者模式（Observer Pattern）

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

2. import java.util.ArrayList;
3. import java.util.List;
5. // 主题接口
6. interface Subject {
7.     void registerObserver(Observer o);
8.     void removeObserver(Observer o);
9.     void notifyObservers();
10. }
12. // 观察者接口
13. interface Observer {
14.     void update(double temperature, double humidity, double pressure);
15. }
17. // 具体主题
18. class WeatherData implements Subject {
19.     private List<Observer> observers;
20.     private double temperature;
21.     private double humidity;
22.     private double pressure;
24.     public WeatherData() {
25.         observers = new ArrayList<>();
26.     }
28.     @Override
29.     public void registerObserver(Observer o) {
30.         observers.add(o);
31.     }
33.     @Override
34.     public void removeObserver(Observer o) {
35.         observers.remove(o);
36.     }
38.     @Override
39.     public void notifyObservers() {
40.         for (Observer observer : observers) {
41.             observer.update(temperature, humidity, pressure);
42.         }
43.     }
45.     public void measurementsChanged() {
46.         notifyObservers();
47.     }
49.     public void setMeasurements(double temperature, double humidity, double pressure) {
50.         this.temperature = temperature;
51.         this.humidity = humidity;
52.         this.pressure = pressure;
53.         measurementsChanged();
54.     }
55. }

复制代码

6.战略模式（Strategy Pattern）

核心思想：战略模式界说一系列的算法，并将每个算法封装起来，使他们可以相互更换。
示例：

2. // 策略接口
3. interface PaymentStrategy {
4.     void pay(int amount);
5. }
7. // 具体策略
8. class CreditCardStrategy implements PaymentStrategy {
9.     private String cardNumber;
10.     private String cvv;
11.     private String dateOfExpiry;
13.     public CreditCardStrategy(String cardNumber, String cvv, String dateOfExpiry) {
14.         this.cardNumber = cardNumber;
15.         this.cvv = cvv;
16.         this.dateOfExpiry = dateOfExpiry;
17.     }
19.     @Override
20.     public void pay(int amount) {
21.         System.out.println(amount + " 元使用信用卡支付");
22.     }
23. }
25. class PayPalStrategy implements PaymentStrategy {
26.     private String emailId;
27.     private String password;
29.     public PayPalStrategy(String emailId, String password) {
30.         this.emailId = emailId;
31.         this.password = password;
32.     }
34.     @Override
35.     public void pay(int amount) {
36.         System.out.println(amount + " 元使用PayPal支付");
37.     }
38. }
40. // 上下文
41. class ShoppingCart {
42.     private PaymentStrategy paymentStrategy;
44.     public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
45.         this.paymentStrategy = paymentStrategy;
46.     }
48.     public void pay(int amount) {
49.         paymentStrategy.pay(amount);
50.     }
51. }

复制代码

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

核心思想：模板方法模式界说一个操作中的算法的骨架，而将一些步调耽误到子类中。
示例：

2. // 抽象类
3. abstract class Game {
4.     abstract void initialize();
5.     abstract void startPlay();
6.     abstract void endPlay();
8.     // 模板方法
9.     public final void play() {
10.         // 初始化游戏
11.         initialize();
12.         // 开始游戏
13.         startPlay();
14.         // 结束游戏
15.         endPlay();
16.     }
17. }
19. // 具体类
20. class Cricket extends Game {
21.     @Override
22.     void initialize() {
23.         System.out.println("板球游戏初始化，准备场地");
24.     }
25.     @Override
26.     void startPlay() {
27.         System.out.println("板球游戏开始，玩起来！");
28.     }
29.     @Override
30.     void endPlay() {
31.         System.out.println("板球游戏结束，统计分数");
32.     }
33. }
35. class Football extends Game {
36.     @Override
37.     void initialize() {
38.         System.out.println("足球游戏初始化，准备场地和球");
39.     }
40.     @Override
41.     void startPlay() {
42.         System.out.println("足球游戏开始，踢起来！");
43.     }
44.     @Override
45.     void endPlay() {
46.         System.out.println("足球游戏结束，统计分数");
47.     }
48. }

复制代码

8.适配器模式（Adapter Pattern）

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

2. // 目标接口
3. interface MediaPlayer {
4.     void play(String audioType, String fileName);
5. }
7. // 被适配的类
8. class VlcPlayer {
9.     public void playVlc(String fileName) {
10.         System.out.println("播放VLC文件: " + fileName);
11.     }
12. }
14. // 适配器
15. class MediaAdapter implements MediaPlayer {
16.     private VlcPlayer vlcPlayer;
18.     public MediaAdapter() {
19.         vlcPlayer = new VlcPlayer();
20.     }
22.     @Override
23.     public void play(String audioType, String fileName) {
24.         if (audioType.equalsIgnoreCase("vlc")) {
25.             vlcPlayer.playVlc(fileName);
26.         }
27.     }
28. }
30. // 具体实现类
31. class AudioPlayer implements MediaPlayer {
32.     private MediaAdapter mediaAdapter;
34.     @Override
35.     public void play(String audioType, String fileName) {
36.         if (audioType.equalsIgnoreCase("vlc")) {
37.             mediaAdapter = new MediaAdapter();
38.             mediaAdapter.play(audioType, fileName);
39.         } else {
40.             System.out.println("播放 " + audioType + " 文件: " + fileName);
41.         }
42.     }
43. }

复制代码

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

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

2. // 抽象处理者
3. abstract class Handler {
4.     protected Handler nextHandler;
6.     public void setNextHandler(Handler nextHandler) {
7.         this.nextHandler = nextHandler;
8.     }
10.     public abstract void handleRequest(int request);
11. }
13. // 具体处理者
14. class ConcreteHandler1 extends Handler {
15.     @Override
16.     public void handleRequest(int request) {
17.         if (request < 10) {
18.             System.out.println("处理请求: " + request);
19.         } else if (nextHandler != null) {
20.             nextHandler.handleRequest(request);
21.         }
22.     }
23. }
25. class ConcreteHandler2 extends Handler {
26.     @Override
27.     public void handleRequest(int request) {
28.         if (request >= 10 && request < 20) {
29.             System.out.println("处理请求: " + request);
30.         } else if (nextHandler != null) {
31.             nextHandler.handleRequest(request);
32.         }
33.     }
34. }
36. class ConcreteHandler3 extends Handler {
37.     @Override
38.     public void handleRequest(int request) {
39.         if (request >= 20) {
40.             System.out.println("处理请求: " + request);
41.         } else if (nextHandler != null) {
42.             nextHandler.handleRequest(request);
43.         }
44.     }
45. }

复制代码

 
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告