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);
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/296186.html

標籤：其他

上一篇：7Java基礎補充

下一篇：9Java基礎總結