【设计模式】Java常见设计模式

在Java中，有一些常见的设计模式，它们是在软件开发中解决常见问题的经典方法。这些设计模式有助于提高代码的可维护性、可扩展性和可重用性。以下是一些常见的Java设计模式，以及它们的详细介绍：

1、单例模式（Singleton Pattern）：

示例代码：

• 单例模式确保一个类只有一个实例，并提供一个全局访问点。
• 通过将构造函数私有化，限制了该类的实例化，然后提供一个静态方法来获取唯一的实例。
• 用途：全局配置、线程池、数据库连接池等。

  public class Singleton {
      private static Singleton instance;
  
      private Singleton() { }
  
      public static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }
  

  2、工厂模式（Factory Pattern）：

• 工厂模式用于创建对象，封装对象的创建逻辑。
• 有多种工厂模式，包括简单工厂、工厂方法和抽象工厂。
• 用途：隐藏对象的创建细节，提供统一的接口供客户端使用。

  interface Product {
      void produce();
  }
  
  class ConcreteProductA implements Product {
      public void produce() {
          System.out.println("Product A is produced.");
      }
  }
  
  class ConcreteProductB implements Product {
      public void produce() {
          System.out.println("Product B is produced.");
      }
  }
  
  class Factory {
      public Product createProduct(String productType) {
          if ("A".equals(productType)) {
              return new ConcreteProductA();
          } else if ("B".equals(productType)) {
              return new ConcreteProductB();
          }
          return null;
      }
  }
  

  3、观察者模式（Observer Pattern）：

• 观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。
• 用途：事件处理、UI更新、发布-订阅系统等。

  import java.util.ArrayList;
  import java.util.List;
  
  interface Observer {
      void update(String message);
  }
  
  class ConcreteObserver implements Observer {
      private String name;
  
      public ConcreteObserver(String name) {
          this.name = name;
      }
  
      public void update(String message) {
          System.out.println(name + " received message: " + message);
      }
  }
  
  class Subject {
      private List<Observer> observers = new ArrayList<>();
  
      public void addObserver(Observer observer) {
          observers.add(observer);
      }
  
      public void removeObserver(Observer observer) {
          observers.remove(observer);
      }
  
      public void notifyObservers(String message) {
          for (Observer observer : observers) {
              observer.update(message);
          }
      }
  }
  

  4、策略模式（Strategy Pattern）：

• 策略模式定义一系列算法，将它们封装起来，并使它们可以互相替换，以使算法的选择独立于客户端。
• 用途：动态选择算法、解耦算法的实现。

  interface PaymentStrategy {
      void pay(int amount);
  }
  
  class CreditCardPayment implements PaymentStrategy {
      private String cardNumber;
  
      public CreditCardPayment(String cardNumber) {
          this.cardNumber = cardNumber;
      }
  
      public void pay(int amount) {
          System.out.println("Paid $" + amount + " with credit card: " + cardNumber);
      }
  }
  
  class CashPayment implements PaymentStrategy {
      public void pay(int amount) {
          System.out.println("Paid $" + amount + " in cash");
      }
  }
  
  class ShoppingCart {
      private PaymentStrategy paymentStrategy;
  
      public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
          this.paymentStrategy = paymentStrategy;
      }
  
      public void checkout(int amount) {
          paymentStrategy.pay(amount);
      }
  }
  

  5、装饰器模式（Decorator Pattern）：

• 装饰器模式允许在不改变对象结构的情况下动态地添加功能。
• 通过创建一系列装饰类，每个装饰类包装一个组件，以添加特定功能。
• 用途：动态扩展对象功能、避免类爆炸。

  interface Coffee {
      String getDescription();
      double cost();
  }
  
  class SimpleCoffee implements Coffee {
      public String getDescription() {
          return "Coffee";
      }
  
      public double cost() {
          return 2.0;
      }
  }
  
  class MilkDecorator implements Coffee {
      private Coffee coffee;
  
      public MilkDecorator(Coffee coffee) {
          this.coffee = coffee;
      }
  
      public String getDescription() {
          return coffee.getDescription() + ", Milk";
      }
  
      public double cost() {
          return coffee.cost() + 0.5;
      }
  }
  

  接下来仔细讲讲工厂模式。

  工厂模式是一种创建型设计模式，用于创建对象，封装了对象的创建逻辑，使客户端代码不需要了解对象的具体创建过程。工厂模式提供了一种方法，通过调用工厂方法来获取对象实例，从而将对象的创建和使用分离。在Java中，有几种工厂模式的变体，包括简单工厂、工厂方法和抽象工厂。

  以下是工厂模式的详细介绍：

• 简单工厂模式（Simple Factory Pattern）：

  • 简单工厂模式是最简单的工厂模式，它由一个工厂类负责创建对象。
  • 客户端通过向工厂传递一个参数或者选择性地调用工厂方法来获取对象。
  • 简单工厂通常包含一个静态方法，根据传入的参数创建不同的对象实例。

  示例代码：

  interface Product {
      void produce();
  }
  
  class ConcreteProductA implements Product {
      public void produce() {
          System.out.println("Product A is produced.");
      }
  }
  
  class ConcreteProductB implements Product {
      public void produce() {
          System.out.println("Product B is produced.");
      }
  }
  
  class SimpleFactory {
      public static Product createProduct(String productType) {
          if ("A".equals(productType)) {
              return new ConcreteProductA();
          } else if ("B".equals(productType)) {
              return new ConcreteProductB();
          }
          return null;
      }
  }
  
  // 客户端代码
  Product product = SimpleFactory.createProduct("A");
  product.produce();
  

  工厂方法模式（Factory Method Pattern）：

• 工厂方法模式定义了一个接口，由具体工厂子类来实现，每个具体工厂生产一种类型的产品。
• 客户端通过与工厂接口交互，而不是与具体产品类交互，这使得客户端不需要了解具体产品的细节。
• 每个产品都有一个对应的工厂，客户端通过选择特定的工厂来获取所需的产品。

  interface Product {
      void produce();
  }
  
  class ConcreteProductA implements Product {
      public void produce() {
          System.out.println("Product A is produced.");
      }
  }
  
  class ConcreteProductB implements Product {
      public void produce() {
          System.out.println("Product B is produced.");
      }
  }
  
  interface ProductFactory {
      Product createProduct();
  }
  
  class ConcreteProductFactoryA implements ProductFactory {
      public Product createProduct() {
          return new ConcreteProductA();
      }
  }
  
  class ConcreteProductFactoryB implements ProductFactory {
      public Product createProduct() {
          return new ConcreteProductB();
      }
  }
  
  // 客户端代码
  ProductFactory factoryA = new ConcreteProductFactoryA();
  Product productA = factoryA.createProduct();
  productA.produce();
  

  抽象工厂模式（Abstract Factory Pattern）：

• 抽象工厂模式提供了一组相关或相互依赖的对象，而不需要指定它们的具体类。
• 它包含多个工厂接口，每个工厂接口负责生产一组相关的产品。
• 客户端通过选择一个具体的抽象工厂来创建一组相关的产品，而不需要关心每个产品的具体实现。
• 示例代码：

  // Abstract Factory Interfaces
  interface AbstractProductA {
      void produceA();
  }
  
  interface AbstractProductB {
      void produceB();
  }
  
  interface AbstractFactory {
      AbstractProductA createProductA();
      AbstractProductB createProductB();
  }
  
  // Concrete Product Classes
  class ConcreteProductA1 implements AbstractProductA {
      public void produceA() {
          System.out.println("Product A1 is produced.");
      }
  }
  
  class ConcreteProductB1 implements AbstractProductB {
      public void produceB() {
          System.out.println("Product B1 is produced.");
      }
  }
  
  class ConcreteProductA2 implements AbstractProductA {
      public void produceA() {
          System.out.println("Product A2 is produced.");
      }
  }
  
  class ConcreteProductB2 implements AbstractProductB {
      public void produceB() {
          System.println("Product B2 is produced.");
      }
  }
  
  // Concrete Factory Classes
  class ConcreteFactory1 implements AbstractFactory {
      public AbstractProductA createProductA() {
          return new ConcreteProductA1();
      }
  
      public AbstractProductB createProductB() {
          return new ConcreteProductB1();
      }
  }
  
  class ConcreteFactory2 implements AbstractFactory {
      public AbstractProductA createProductA() {
          return new ConcreteProductA2();
      }
  
      public AbstractProductB createProductB() {
          return new ConcreteProductB2();
      }
  }
  
  // Client Code
  AbstractFactory factory1 = new ConcreteFactory1();
  AbstractProductA productA1 = factory1.createProductA();
  AbstractProductB productB1 = factory1.createProductB();
  
  AbstractFactory factory2 = new ConcreteFactory2();
  AbstractProductA productA2 = factory2.createProductA();
  AbstractProductB productB2 = factory2.createProductB();