什麼是設計模式？

設計模式，在軟體工程中是對軟體設計過程中普遍存在的問題，所提出的解決方案。

設計模式分類

GoF設計模式一共23種，分為三大類：建立型模式、結構型模式、行為型模式。

常用的設計模式

1.工廠模式（Factory Pattern）

工廠模式是Java中最常用的設計模式之一。這種設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

在工廠模式中，建立物件時不會對客戶暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。

例項：

// 介面
public interface Shape {
    void draw();
}

// 實現類
public class Circle implements  Shape{
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 實現類
public class Square implements  Shape {

    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

// 工廠類
public class ShapeFactory {

    public Shape getShape(String shapeType){

        if( "Square".equals(shapeType)){
            return new Square();
        }else if("Circle".equals(shapeType)){
            return new Circle();
        }else {
            return null;
        }

    }
}

// Demo
public class FactoryPatternDemo {

    public static void main(String[] args) {

        ShapeFactory factory = new ShapeFactory();

        Shape square = factory.getShape("Square");

        Shape circle = factory.getShape("Circle");

        square.draw();

        circle.draw();

    }
}

// 程式輸出結果
Inside Square::draw() method.
Inside Circle::draw() method.

2.抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式是圍繞一個超級工廠建立其他的工廠。該超級工廠又稱為其他工廠的工廠。

這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

在抽象工廠模式中，介面是負責建立一個相關物件的工廠，不需要顯示指定他們的類，每個生成的工廠都能按照工廠模式提供物件。

例項：

// 介面
public interface Shape {
    void draw();
}

// 實現類
public class Circle implements  Shape{
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 實現類
public class Square implements  Shape {

    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

public interface Color {
    void fill();
}

public class Red implements  Color {

    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

public class Blue implements Color {
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

public abstract class AbstractFactory {

    public abstract Shape getShape(String shape) ;

    public abstract Color getColor(String color) ;

}

public class ShapeFactory extends AbstractFactory{

    public Shape getShape(String shapeType){

        if( "Square".equals(shapeType)){
            return new Square();
        }else if("Circle".equals(shapeType)){
            return new Circle();
        }else {
            return null;
        }

    }

    public Color getColor(String color) {
        return null;
    }
}

public class ColorFactory extends  AbstractFactory{

    public Color getColor(String color){

        if( "Red".equals(color)){
            return new Red();
        }else if("Blue".equals(color)){
            return new Blue();
        }else {
            return null;
        }

    }

    public Shape getShape(String shape) {
        return null;
    }
}

public class AbstractFactoryPatternDemo {

    public static void main(String[] args) {

        ShapeFactory shapeFactory = new ShapeFactory();

        ColorFactory colorFactory = new ColorFactory();

        Shape square = shapeFactory.getShape("Square");

        Shape circle = shapeFactory.getShape("Circle");

        Color red = colorFactory.getColor("Red");

        Color blue = colorFactory.getColor("Blue");

        square.draw();

        circle.draw();

        red.fill();

        blue.fill();

    }
}

// 輸出結果
Inside Square::draw() method.
Inside Circle::draw() method.
Inside Red::fill() method.
Inside Blue::fill() method.

3.單例模式（Singleton Pattern）

單例模式是Java中最簡單的設計模式之一。

這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

單例模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要例項化該類的物件。

注意：

　　單例類只能有一個例項

　　單例類必須自己建立自己的唯一例項

　　單例類必須給所有其他物件提供這一例項

例項：

public class SingleObject {

    // 建構函式為私有的,該類就不會被例項化
    private SingleObject(){};

    // 自己建立自己的唯一例項
    private static  SingleObject singleObject = new SingleObject();

    // 獲取唯一可用的物件
    public static SingleObject getSingleObject(){
        return  singleObject;
    }

    public void show(){
        System.out.println("SingleObject.show()");
    }

}

public class SingletonPatternDemo {
    public static void main(String[] args) {
        // 編譯期報錯
        // SingleObject singleObject = new SingleObject();

        SingleObject singleObject = SingleObject.getSingleObject();

        singleObject.show();
    }
}

// 程式碼執行結果
SingleObject.show()

懶漢式：

// 懶漢式單例
public class LazySingletonPattern {
    // 私有的無參構造方法
    private LazySingletonPattern(){}

    // 預設不例項化，什麼時候用什麼時候例項化
    private static LazySingletonPattern lazySingletonPattern = null;

    //  獲取唯一可用的物件
    public static LazySingletonPattern getLazySingletonPattern(){
        if(lazySingletonPattern == null){
            lazySingletonPattern = new LazySingletonPattern();
        }
        return lazySingletonPattern;
    }
}

餓漢式

// 餓漢式單例
public class HungrySingletonPattern {
    // 無參構造方法私有化
    private HungrySingletonPattern (){}
    
　　// 直接例項化
    private static final HungrySingletonPattern hungrySingletonPattern = new HungrySingletonPattern();
    
　　// 獲取唯一可用的物件
    public static HungrySingletonPattern getHungrySingletonPattern(){
        return hungrySingletonPattern;
    }
}

4.建造者模式（Builder Pattern）

建造者模式，使用多個簡單的物件一步一步構建成一個複雜的物件。

一個Builder類會一步一步構造最終的物件。該Builder類是獨立於其他的物件。

5.原型模式（Prototype Pattern）

原型模式，用於建立重複的物件，又可以保證效能。

原型模式是實現了一個原型介面，該介面用於建立當前物件的克隆。當直接建立物件代價比較大時，使用這種模式。

例如:一個物件需要在一個高代價的資料庫操作之後建立。我們可以先快取該物件，在下一個請求時返回他的克隆，在需要的時候更新資料庫，以此來減少資料庫的呼叫。