1、單例模式（Singleton Pattern）

單例模式是（Singleton Pattern）Java中最常用的設(shè)計(jì)模式之一，它保證一個(gè)類僅有一個(gè)實(shí)例，并提供一個(gè)全局訪問(wèn)點(diǎn)。

實(shí)現(xiàn)單例模式的核心是將類的構(gòu)造方法私有化，以防止外部直接通過(guò)構(gòu)造函數(shù)創(chuàng)建實(shí)例。同時(shí)，類內(nèi)部需要提供一個(gè)靜態(tài)方法或變量來(lái)獲取該類的唯一實(shí)例。

以下是一個(gè)簡(jiǎn)單的單例模式實(shí)現(xiàn)：

public class Singleton {
    private static Singleton instance = null;

    // 私有構(gòu)造方法
    private Singleton() {
    }

    // 靜態(tài)方法，獲取唯一實(shí)例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2、工廠模式（Factory Pattern）

工廠模式（Factory Pattern）是Java中常用的一種創(chuàng)建型設(shè)計(jì)模式，它提供了一種將對(duì)象創(chuàng)建的過(guò)程封裝起來(lái)的方法，可以根據(jù)不同的參數(shù)來(lái)創(chuàng)建不同類型的對(duì)象。

工廠模式有三種常用的實(shí)現(xiàn)方式：簡(jiǎn)單工廠模式、工廠方法模式和抽象工廠模式。以簡(jiǎn)單工廠模式為例，實(shí)現(xiàn)過(guò)程如下：

1. 定義抽象產(chǎn)品類：

public abstract class Product {
    public abstract void use();
}

2. 定義具體產(chǎn)品類：

public class ProductA extends Product {
    @Override
    public void use() {
        System.out.println("使用產(chǎn)品A");
    }
}

public class ProductB extends Product {
    @Override
    public void use() {
        System.out.println("使用產(chǎn)品B");
    }
}

3. 定義工廠類：

public class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("無(wú)效的產(chǎn)品類型");
        }
    }
}

4. 調(diào)用工廠類創(chuàng)建產(chǎn)品：

Product productA = Factory.createProduct("A");
productA.use(); // 輸出：使用產(chǎn)品A

Product productB = Factory.createProduct("B");
productB.use(); // 輸出：使用產(chǎn)品B

在上述實(shí)現(xiàn)中，AbstractProduct是一個(gè)抽象產(chǎn)品類，定義了產(chǎn)品的基本屬性和方法。ProductA和ProductB是具體的產(chǎn)品類，實(shí)現(xiàn)了抽象產(chǎn)品類中定義的方法。

Factory是一個(gè)工廠類，根據(jù)不同的參數(shù)創(chuàng)建不同類型的產(chǎn)品對(duì)象。Factory中的方法是靜態(tài)的，無(wú)需先創(chuàng)建工廠對(duì)象再調(diào)用方法。

通過(guò)使用工廠模式，可以有效地封裝對(duì)象的創(chuàng)建過(guò)程，實(shí)現(xiàn)了高內(nèi)聚、低耦合的設(shè)計(jì)思想，也使得代碼更加易于維護(hù)和擴(kuò)展。

3、抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式（Abstract Factory Pattern）是Java中常用的一種創(chuàng)建型設(shè)計(jì)模式，它提供了一種創(chuàng)建一系列相關(guān)或相互依賴的對(duì)象接口，而無(wú)需指定它們具體的類。

抽象工廠模式和工廠方法模式類似，不同之處在于抽象工廠模式中工廠類不單獨(dú)生產(chǎn)一種產(chǎn)品，而是生產(chǎn)一系列相關(guān)的產(chǎn)品。

以下是一個(gè)簡(jiǎn)單的抽象工廠模式實(shí)現(xiàn)：

1. 定義抽象產(chǎn)品類：

public interface AbstractProductA {
    void use();
}

public interface AbstractProductB {
    void consume();
}

2. 定義具體產(chǎn)品類：

public class ProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用ProductA1");
    }
}

public class ProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用ProductA2");
    }
}

public class ProductB1 implements AbstractProductB {
    @Override
    public void consume() {
        System.out.println("消費(fèi)ProductB1");
    }
}

public class ProductB2 implements AbstractProductB {
    @Override
    public void consume() {
        System.out.println("消費(fèi)ProductB2");
    }
}

3. 定義抽象工廠類：

public interface AbstractFactory {
    AbstractProductA createProductA();

    AbstractProductB createProductB();
}

4. 定義具體工廠類：

public class Factory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class Factory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

5. 調(diào)用抽象工廠生成產(chǎn)品：

AbstractFactory factory1 = new Factory1();
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.use(); // 輸出：使用ProductA1
productB1.consume(); // 輸出：消費(fèi)ProductB1

AbstractFactory factory2 = new Factory2();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.use(); // 輸出：使用ProductA2
productB2.consume(); // 輸出：消費(fèi)ProductB2

以上是一個(gè)簡(jiǎn)單的抽象工廠模式實(shí)現(xiàn)。其中，抽象工廠類AbstractFactory定義抽象方法createProductA()和createProductB()，用于創(chuàng)建AbstractProductA和AbstractProductB類型的對(duì)象。

具體工廠類Factory1和Factory2分別實(shí)現(xiàn)AbstractFactory接口，并實(shí)現(xiàn)了接口中定義的兩個(gè)抽象方法，分別生產(chǎn)ProductA1、ProductB1和ProductA2、ProductB2類型的對(duì)象。

通過(guò)使用抽象工廠模式，可以更加靈活地生成一系列相關(guān)的產(chǎn)品。它能夠隔離類的實(shí)例化過(guò)程，客戶端使用抽象工廠創(chuàng)建的對(duì)象是一系列相關(guān)的產(chǎn)品，無(wú)需關(guān)心具體的實(shí)現(xiàn)。

4、建造者模式（Builder Pattern）

建造者模式（Builder Pattern）是Java中常用的一種創(chuàng)建型設(shè)計(jì)模式，它將一個(gè)復(fù)雜的對(duì)象的構(gòu)建過(guò)程和表示分離開(kāi)來(lái)，使得同樣的構(gòu)建過(guò)程可以創(chuàng)建不同的表示。

建造者模式主要由4部分組成：抽象建造者、具體建造者、指揮者和產(chǎn)品。其中，抽象建造者和具體建造者用于定義和實(shí)現(xiàn)產(chǎn)品的創(chuàng)建過(guò)程，指揮者協(xié)調(diào)建造者來(lái)構(gòu)建產(chǎn)品，而產(chǎn)品則是最終構(gòu)建出的對(duì)象。

以下是一個(gè)簡(jiǎn)單的建造者模式實(shí)現(xiàn)：

1. 定義產(chǎn)品類：

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

2. 定義抽象建造者類：

public abstract class Builder {
    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    public abstract Product getResult();
}

3. 定義具體建造者類：

public class ConcreteBuilder extends Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("PartA");
    }

    @Override
    public void buildPartB() {
        product.setPartB("PartB");
    }

    @Override
    public void buildPartC() {
        product.setPartC("PartC");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

4. 定義指揮者類：

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

5. 創(chuàng)建產(chǎn)品：

Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
director.construct();
Product product = builder.getResult();
System.out.println(product);

在上述實(shí)現(xiàn)中，Product是一個(gè)產(chǎn)品類，該類具有多個(gè)屬性，通過(guò)訪問(wèn)器和修改器可以進(jìn)行屬性的獲取和設(shè)置。

Builder是一個(gè)抽象建造者類，定義了產(chǎn)品的構(gòu)建方法。具體建造者類ConcreteBuilder實(shí)現(xiàn)了建造者接口中的所有方法，實(shí)現(xiàn)了對(duì)產(chǎn)品的創(chuàng)建過(guò)程。Director是一個(gè)指揮者類，負(fù)責(zé)控制整個(gè)建造過(guò)程的進(jìn)行。

最后，通過(guò)建造者模式創(chuàng)建產(chǎn)品。指揮者將具體的建造過(guò)程委托給建造者完成，而建造者根據(jù)指揮者提供的具體信息來(lái)創(chuàng)建不同的產(chǎn)品。通過(guò)使用建造者模式，可以靈活地構(gòu)建具有復(fù)雜結(jié)構(gòu)的產(chǎn)品。

5、策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是Java中常用的一種行為型設(shè)計(jì)模式，它定義了一系列算法，將每個(gè)算法封裝起來(lái)，并且使它們可以互換，讓算法獨(dú)立于使用它的客戶端而變化。

策略模式主要由三部分組成：策略接口、具體策略類和上下文類。策略接口定義了算法的統(tǒng)一接口，具體策略類實(shí)現(xiàn)了策略接口中定義的算法，而上下文類持有一個(gè)策略接口的引用，負(fù)責(zé)調(diào)用具體策略類中的算法。

以下是一個(gè)簡(jiǎn)單的策略模式實(shí)現(xiàn)：

1. 定義策略接口：

public interface Strategy {
    void execute();
}

2. 定義具體策略類：

public class StrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("執(zhí)行策略A");
    }
}

public class StrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("執(zhí)行策略B");
    }
}

3. 定義上下文類：

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void doStrategy() {
        strategy.execute();
    }
}

4. 使用策略模式：

Strategy strategyA = new StrategyA();
Context context = new Context(strategyA);
context.doStrategy(); // 輸出：執(zhí)行策略A

Strategy strategyB = new StrategyB();
context.setStrategy(strategyB);
context.doStrategy(); // 輸出：執(zhí)行策略B

在上述實(shí)現(xiàn)中，Strategy是一個(gè)抽象策略接口，定義了算法的統(tǒng)一接口。具體策略類StrategyA和StrategyB實(shí)現(xiàn)了策略接口中的算法，為策略模式提供了具體的算法實(shí)現(xiàn)。

Context是一個(gè)上下文類，持有一個(gè)策略接口的引用，用于調(diào)用具體策略類中的算法。通過(guò)setStrategy()方法可以動(dòng)態(tài)地改變策略，達(dá)到不同的行為。

6、裝飾器模式（Decorator Pattern）

裝飾器模式（Decorator Pattern）是一種結(jié)構(gòu)型設(shè)計(jì)模式，用于動(dòng)態(tài)地向一個(gè)對(duì)象添加一些額外的行為而不需要修改原來(lái)的類。

在該模式中，定義了一個(gè)裝飾器類和一個(gè)組件類，被裝飾對(duì)象是指該組件類及其子類的實(shí)例對(duì)象，裝飾器類和被裝飾對(duì)象具有相同的父類，即裝飾器類和被裝飾對(duì)象都是通過(guò)實(shí)現(xiàn)相同的接口或繼承相同的抽象類來(lái)實(shí)現(xiàn)。

在實(shí)現(xiàn)時(shí)，裝飾器類包含一個(gè)被裝飾對(duì)象的成員變量，并維護(hù)一個(gè)指向被裝飾對(duì)象的引用，在裝飾器類中調(diào)用被裝飾對(duì)象的方法時(shí)，還可以添加一些新的功能。

以下是簡(jiǎn)單的裝飾器模式示例代碼：

// 抽象組件
interface Component {
    void operation();
}
 
// 具體組件
class ConcreteComponent implements Component {
    public void operation() {
        System.out.println("基礎(chǔ)操作");
    }
}

// 抽象裝飾器
class Decorator implements Component {
    protected Component component;
 
    public Decorator(Component component) {
        this.component = component;
    }
 
    public void operation() {
        component.operation();
    }
}
 
// 具體裝飾器
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }
 
    public void operation() {
        super.operation();
        addedBehavior();
    }
 
    public void addedBehavior() {
        System.out.println("添加額外的行為");
    }
}

在上面的代碼中，Component是被裝飾對(duì)象的抽象接口，ConcreteComponent是具體的被裝飾對(duì)象。在Decorator中，傳入被裝飾對(duì)象進(jìn)行初始化，并重寫operation()方法。而ConcreteDecorator是具體的裝飾器，它繼承自Decorator并擴(kuò)展了被裝飾對(duì)象的行為。

以下是測(cè)試裝飾器的示例代碼：

Component component = new ConcreteComponent(); // 創(chuàng)建被裝飾對(duì)象
component.operation(); // 調(diào)用基礎(chǔ)操作
 
Decorator decorator = new ConcreteDecorator(component); // 使用被裝飾對(duì)象進(jìn)行初始化
decorator.operation(); // 調(diào)用裝飾器的操作方法，同時(shí)也會(huì)執(zhí)行被裝飾對(duì)象的操作方法和新添加的行為

在運(yùn)行時(shí)，我們可以看到以下輸出：

基礎(chǔ)操作
基礎(chǔ)操作
添加額外的行為

這表明操作被成功地傳遞到了被裝飾者對(duì)象，并且具體的裝飾器添加了額外的行為。

7、適配器模式(Adapter Pattern)

適配器模式(Adapter Pattern)是一種結(jié)構(gòu)型設(shè)計(jì)模式，用于將一個(gè)已有類的接口轉(zhuǎn)換成需要的接口形式。

適配器模式目的是讓原本接口不兼容的類可以合作無(wú)間。在適配器模式中，適配器讓一個(gè)類的接口與另一個(gè)類的接口相適應(yīng)。

適配器的實(shí)現(xiàn)方法有兩種：對(duì)象適配器和類適配器。

• 對(duì)象適配器：適配器持有原始對(duì)象的引用，從而將其自己的接口與原始對(duì)象的接口“結(jié)合”在一起。
• 類適配器：適配器通過(guò)多重繼承實(shí)現(xiàn)將一個(gè)類的接口轉(zhuǎn)換成另一個(gè)類所期望的接口形式。

以下是簡(jiǎn)單的適配器模式示例代碼：

• 對(duì)象適配器：

  // 原始接口
  interface Shape {
      void draw();
  }
  
  // 原始類
  class Rectangle implements Shape {
      public void draw() {
          System.out.println("Rectangle draw()");
      }
  }
  
  // 適配器類
  class ObjectAdapter implements Shape {
      private Rectangle rectangle;
  
      public ObjectAdapter(Rectangle rectangle) {
          this.rectangle = rectangle;
      }
  
      public void draw() {
          rectangle.draw();
      }
  }
  
  // 測(cè)試代碼
  public class ObjectAdapterTest {
      public static void main(String[] args) {
          Rectangle rectangle = new Rectangle();
          Shape shape = new ObjectAdapter(rectangle);
          shape.draw();
      }
  }
  

• 類適配器：

  // 原始類
  class Rectangle {
      void draw() {
          System.out.println("Rectangle draw()");
      }
  }
  
  // 目標(biāo)接口
  interface Shape {
      void draw();
  }
  
  // 適配器類
  class ClassAdapter extends Rectangle implements Shape {
      public void draw() {
          super.draw();
      }
  }
  
  // 測(cè)試代碼
  public class ClassAdapterTest {
      public static void main(String[] args) {
          Shape shape = new ClassAdapter();
          shape.draw();
      }
  }
  

在上面的代碼中，我們有一個(gè)原始對(duì)象 Rectangle，它實(shí)現(xiàn)了 Shape 接口。在對(duì)象適配器模式中，我們創(chuàng)建了一個(gè)適配器 ObjectAdapter，以將該原始對(duì)象轉(zhuǎn)換為 Shape 接口。在類適配器模式中，我們通過(guò)多重繼承，將 Rectangle 類轉(zhuǎn)換為 Shape 接口。在測(cè)試代碼中，我們可以看到適配器的使用，將適配器對(duì)象傳入客戶端代碼，并調(diào)用相應(yīng)的方法。

總體來(lái)說(shuō)，適配器模式是一種有效的設(shè)計(jì)模式，可以幫助我們處理接口不兼容的問(wèn)題，從而使得不同的類可以相互協(xié)作完成任務(wù)。

8、觀察者模式（Observer Pattern）

觀察者模式（Observer Pattern）是一種行為型設(shè)計(jì)模式，也叫發(fā)布-訂閱模式，它定義了對(duì)象之間一對(duì)多的依賴關(guān)系，使得當(dāng)一個(gè)對(duì)象狀態(tài)改變時(shí)，所有依賴它的對(duì)象都能收到通知并自動(dòng)更新。

觀察者模式中，有兩種類型的對(duì)象：觀察者和主題（或稱為被觀察者）。觀察者將自己注冊(cè)到主題，以便在主題的狀態(tài)改變時(shí)接收通知。主題會(huì)維護(hù)一組觀察者，并在自身狀態(tài)改變時(shí)通知它們。主題通過(guò)調(diào)用觀察者的統(tǒng)一接口來(lái)通知它們狀態(tài)的變化。

以下是簡(jiǎn)單的觀察者模式示例代碼：

// 觀察者接口
interface Observer {
    void update(String message);
}
 
// 具體觀察者1
class ConcreteObserver1 implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserver1：" + message);
    }
}
 
// 具體觀察者2
class ConcreteObserver2 implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserver2：" + message);
    }
}
 
// 主題接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObserver(String message);
}
 
// 具體主題
class ConcreteSubject implements Subject {
    private List<Observer> list = new ArrayList<>();
 
    // 注冊(cè)觀察者
    public void registerObserver(Observer observer) {
        list.add(observer);
    }
 
    // 移除觀察者
    public void removeObserver(Observer observer) {
        list.remove(observer);
    }
 
    // 通知觀察者
    public void notifyObserver(String message) {
        for (Observer observer : list) {
            observer.update(message);
        }
    }
}

在上面的代碼中，我們有觀察者接口 Observer 和具體實(shí)現(xiàn)的兩個(gè)觀察者 ConcreteObserver1 和 ConcreteObserver2。還有主題接口 Subject，它有三個(gè)方法：registerObserver、removeObserver 和 notifyObserver，用于注冊(cè)觀察者、移除觀察者和通知觀察者。最后，我們有一個(gè)具體的主題 ConcreteSubject，它維護(hù)了 Observer 對(duì)象的列表，實(shí)現(xiàn)了 Subject 接口中的三個(gè)方法。

以下是使用Java觀察者模式的示例代碼：

public class ObserverTest {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject(); // 創(chuàng)建具體主題
        Observer observer1 = new ConcreteObserver1(); // 創(chuàng)建具體觀察者1
        Observer observer2 = new ConcreteObserver2(); // 創(chuàng)建具體觀察者2
        subject.registerObserver(observer1); // 注冊(cè)觀察者1
        subject.registerObserver(observer2); // 注冊(cè)觀察者2
        subject.notifyObserver("觀察者模式測(cè)試"); // 通知所有觀察者
    }
}

在測(cè)試代碼中，我們創(chuàng)建了一個(gè)具體主題 ConcreteSubject 和兩個(gè)具體觀察者 ConcreteObserver1 和 ConcreteObserver2。它們的行為是在主題狀態(tài)改變之后被調(diào)用。我們注冊(cè)了這兩個(gè)觀察者，并用 notifyObserver() 方法通知它們主題狀態(tài)已經(jīng)改變。

在觀察者模式中，主題和觀察者的分離使代碼具有更好的松耦合性，使得對(duì)象之間可以更加靈活地交互和協(xié)作。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-507766.html

到了這里，關(guān)于Java七種常用設(shè)計(jì)模式的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！