8Java設計模式（持續更新）

1.單例模式（Singleton pattern）：

單例模式的實現方式是，一個類能返回對象的一個引用（永遠是同一個）和一個得到該惟一實例的方法（必須是靜態方法）。

餓漢式:

public class SingleTon {
public static SingleTon singleTon = new SingleTon();
private SingleTon(){
    
}
public static SingleTon getInstance(){
    return singleTon;
}
}

懶漢式：

public class SingleTon {
    public static SingleTon singleTon ;
    private SingleTon(){

    }
    public static SingleTon getInstance(){
        if(singleTon==null) singleTon = new SingleTon();
        return singleTon;
    }
}

2.工廠模式（Factory pattern）：

工廠一般是一個用來建立其餘對象的對象。工廠模式根據不一樣的參數來實現不一樣的分配方案和建立對象。

工廠模式一般分爲：

• 普通工廠模式
• 多個工廠方法模式
• 靜態工廠方法模式

public class FactoryTest {
    public static void main(String[] args) {
        //普通工廠模式，有可能由於傳入參數有誤，形成建立對象失敗。
        ProductFactory factory = new ProductFactory();
        Product p1 = factory.createProduct("product1");
        p1.A();//product1 calls A
        p1.B();//product1 calls B
        //多個工廠模式，缺點是須要建立工廠對象
        MultiProductFactory factory1 = new MultiProductFactory();
        Product2 p2 = factory1.createProduct2();
        p2.A();//product2 calls A
        p2.B();//product2 calls B
        //靜態工廠模式，能夠直接經過類方法得到對象實例
        Product1 p3 = StaticProductFactory.createProduct1();
        p3.A();//product1 calls A
        p3.B();//product1 calls B

    }

}
interface Product{
    void A();
    void B();
}
class Product1 implements Product{

    @Override
    public void A() {
        System.out.println("product1 calls A");
    }

    @Override
    public void B() {
        System.out.println("product1 calls B");
    }
}
class Product2 implements Product{

    @Override
    public void A() {
        System.out.println("product2 calls A");
    }

    @Override
    public void B() {
        System.out.println("product2 calls B");
    }
}
class ProductFactory{
    public Product createProduct(String casename){
        if(casename.equals("product1"))
            return new Product1();
       else if(casename.equals("product2"))
            return new Product2();
       else return null;
    }
}
class MultiProductFactory{
    public Product1 createProduct1(){
        return new Product1();
    }
    public Product2 createProduct2(){
        return new Product2();
    }
}
class StaticProductFactory{
    public static Product1 createProduct1(){
        return new Product1();
    }
    public static Product2 createProduct2(){
        return new Product2();
    }
}

 3.模板方法設計模式：

抽象類體現的是一種模板方法設計模式，抽象類中具備抽象方法，這些抽象方法讓子類實現一些必要功能，還具備普通方法，這些方法提升了代碼的複用性。子類再繼承抽象類的基礎上進行拓展，整體上保持抽象類的行爲模式。

解決了讓肯定功能在抽象類中實現，把不肯定的功能暴露給子類去實現。

public class TemplateTest {
    public static void main(String[] args) {
        Template temp = new SubTemplate();
        temp.getTime();//724毫秒
    }
}
abstract class  Template{
    public  void getTime(){
        long startTime= System.currentTimeMillis();
        code();
        System.out.println((System.currentTimeMillis()-startTime)+"毫秒");
    }
    public abstract  void code();
}
class SubTemplate extends Template{

    @Override
    public void code() {
        for(int i=0;i<100000;i++)
            System.out.println(i);
    }
}