怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性

介紹

Java工廠設計模式主要分為三種:

簡單工廠模式(Simple Factory Pattern):使用一個工廠類別來封裝物件建立的流程,客戶端只需要透過傳遞不同的參數來獲取不同的產品物件,從而避免了客戶端直接創建產品物件的操作

工廠方法模式(Factory Method Pattern):將工廠類別抽象化,每個具體產品類別對應一個具體工廠類別,工廠類別透過多態性來創建對應的產品物件,客戶端只需要知道工廠介面及其實現類別即可,可以根據需求動態切換工廠實現,擴展性更好.

#抽象工廠模式(Abstract Factory Pattern):在工廠方法模式的基礎上,將工廠類再進行一次抽象,將多個工廠接口放到一個工廠接口中,每個具體產品對應一個具體工廠類,通過多態性來創建對應的產品物件,具有更好的擴展性和更高的抽象程度,但是也增加了系統複雜度

#簡單工廠模式

#首先先定義一個抽象產品類別:

package com.fanqiechaodan.factory.simple.product;
/**
 * @Classname Product
 * @Description 抽象产品类
 */
public abstract class Product {
    public abstract void use();
}

然後定義特定產品類別

public class ProductA extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类A...");
    }
}
public class ProductB extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类B...");
    }
}
public class ProductC extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类C...");
    }
}

接下來定義工廠類別,用於建立不同的產品

package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
 * @Classname SimpleFactory
 * @Description 工厂类
 */
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                throw new RuntimeException("不支持的产品类型:" + type);
        }
    }
}

測試:

package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
 * @Classname Demo
 * @Description 简单工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
        Product productC = SimpleFactory.createProduct("C");
        productC.use();
        Product productD = SimpleFactory.createProduct("D");
        productD.use();
    }
}

工廠方法模式

先定義一個介面表示產品

package com.fanqiechaodan.factory.method.product;
/**
 * @Classname Product
 * @Description 产品接口
 */
public interface Product {
    void use();
}

#其次定義兩個特定的產品實作類別

public class ProductA implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品A...");
    }
}
public class ProductB implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品B...");
    }
}

然後定義一個工廠介面用於建立產品

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
 * @Classname Factory
 * @Description 工厂接口
 */
public interface Factory {
    Product createProduct();
}

接下來,定義兩個特定的工廠實作類別,分別用於建立不同的產品

public class FactoryA implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

測試###

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
 * @Classname FactoryB
 * @Description 工厂实现类B
 */
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

####### #####抽象工廠模式######先定義抽象產品###

public interface ProductA {
    void doSomething();
}
public interface ProductB {
    void doSomething();
}

###其次定義具體產品###

public class ProductA1 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA1 doSomething ...");
    }
}
public class ProductA2 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA2 doSomething ...");
    }
}
public class ProductB1 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB1 doSomething ...");
    }
}
public class ProductB2 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB2 doSomething ...");
    }
}

###然後定義抽象工廠###

package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname AbstractFactory
 * @Description 抽象工厂
 */
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

###接下來定義具體工廠###

public class Factory1 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
public class Factory2 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

###測試###

package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname Demo
 * @Description 抽象工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        // 使用具体工厂1创建产品A和产品B
        AbstractFactory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.doSomething();
        productB1.doSomething();
        // 使用具体工厂2创建产品A和产品B
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.doSomething();
        productB2.doSomething();
    }
}

#########

以上是怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性的詳細內容。更多資訊請關注PHP中文網其他相關文章！