抽象工廠模式

工廠方法模式就是有一個工廠，裡面放工廠要用的方法，如果有多個工廠，就可以使用抽象工廠模式，下面分成兩個部分，第二個部分就是將每一個工廠變成一個產品

提供一系列相關或相互依賴的介面，不用指定他們的具體類別

分成兩個部分
1.產品：寫產品類別後，讓子類繼承
以下寫兩個產品，並寫4個子類別，其中2個子類別繼承第一個；另外2個子類別繼承第二個

2.工廠：工廠裡寫回傳1的物件，然後也是讓子類別實作

※產品

public abstract class AbstractProductXXX {
    public void sameMethod() {
        System.out.println("抽象產品XXX共有的方法");
    }
    
    public abstract void doSomething();
}
--------------------
public abstract class AbstractProductOOO {
    public void sameMethod() {
        System.out.println("抽象產品OOO共有的方法");
    }
    
    public abstract void doSomething();
}
========================================
public class ProductA extends AbstractProductXXX {
    @Override
    public void doSomething() {
        System.out.println("產品A實現抽象產品1的方法");
    }
}
--------------------
public class ProductB extends AbstractProductXXX {
    @Override
    public void doSomething() {
        System.out.println("產品B實現抽象產品1的方法");
    }
}
--------------------
public class ProductC extends AbstractProductOOO {
    @Override
    public void doSomething() {
        System.out.println("產品C實現抽象產品2的方法");
    }
}
--------------------
public class ProductD extends AbstractProductOOO {
    @Override
    public void doSomething() {
        System.out.println("產品D實現抽象產品2的方法");
    }
}

※

※工廠

public abstract class AbstractFactory {
    public abstract AbstractProductXXX getProductXXX();
    
    public abstract AbstractProductOOO getProductOOO();
}
--------------------
public class BreadFactory extends AbstractFactory {
    @Override
    public AbstractProductXXX getProductXXX() {
        return new ProductA();
    }
    
    @Override
    public AbstractProductOOO getProductOOO() {
        return new ProductC();
    }
}
--------------------
public class GrapeFactory extends AbstractFactory {
    @Override
    public AbstractProductXXX getProductXXX() {
        return new ProductB();
    }
    
    @Override
    public AbstractProductOOO getProductOOO() {
        return new ProductD();
    }
}

※

※測試

AbstractFactory bf = new BreadFactory();
AbstractProductXXX bf1 = bf.getProductXXX();
AbstractProductOOO bf2 = bf.getProductOOO();
bf1.sameMethod();
bf1.doSomething();
System.out.println();
bf2.sameMethod();
bf2.doSomething();
System.out.println();
    
AbstractFactory gf = new GrapeFactory();
AbstractProductXXX gf1 = gf.getProductXXX();
AbstractProductOOO gf2 = gf.getProductOOO();
gf1.sameMethod();
gf1.doSomething();
System.out.println();
gf2.sameMethod();
gf2.doSomething();

※結果：
抽象產品XXX共有的方法
產品A實現抽象產品1的方法

抽象產品OOO共有的方法
產品C實現抽象產品2的方法

抽象產品XXX共有的方法
產品B實現抽象產品1的方法

抽象產品OOO共有的方法
產品D實現抽象產品2的方法

※優缺點

優點是不需要知道裡面是如何實作的；缺點是要新增產品時，要改的地方很多