设计模式之三种工厂模式（Factory）

简单工厂模式（Static Factory Method）

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。（百度百科）

代码示例

定义接口

public interface Product {

    void method();
}

新增连个实现类 

//产品A
public class ProductA implements Product{
    @Override
    public void method() {
        System.out.println("产品A方法");
    }
}

//产品B
public class ProductB implements Product{
    @Override
    public void method() {
        System.out.println("产品B方法");
    }
}

工厂类 

public class ProductFactory {

    public static Product createProduct(String productName){
        if (productName == null) {
            return null;
        }
        if (productName.equals("A")) {
            return new ProductA();
        }else if (productName.equals("B")) {
            return new ProductB();
        }else {
            return null;
        }
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("A");
        product.method();
    }
}

输出结果

产品A方法

 

工厂方法模式（Factory Method）

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

依然用简单工厂模式里面的product接口，只需要改一下工厂方法

定义工厂接口

public interface ProductFactory {
    Product createProduct();
}

工厂实现

public class ProductAFactory implements ProductFactory{
    @Override
    public Product createProduct(){
        return new ProductA();
    }
}

public class ProductBFactory implements ProductFactory{
    @Override
    public Product createProduct(){
        return new ProductB();
    }
}

 测试类

public class Test {
    public static void main(String[] args) {
        ProductFactory productFactory = new ProductAFactory();
        Product product = productFactory.createProduct();
        product.method();
    }
}

输出结果 

产品A方法

抽象工厂模式（Abstract Factory）

抽象工厂模式算是工厂相关模式的终极形态，它与工厂方法唯一的区别就是工厂的接口里是一系列创造抽象产品的方法，而不再是一个，而相应的，抽象产品也不再是一个了，而是一系列相关的产品。

抽象工厂模式定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

定义产品A接口

public interface ProductA {
    void methodA();
}

定义产品B接口

public interface ProductB {
    void methodB();
}

添加这些产品的实现类

public class ProductA1 implements ProductA {
    @Override
    public void methodA() {
        System.out.println("产品A系列中1型号产品的方法");
    }
}

public class ProductA2 implements ProductA {
    @Override
    public void methodA() {
        System.out.println("产品A系列中2型号产品的方法");
    }
}

public class ProductB1 implements ProductB {
    @Override
    public void methodB() {
        System.out.println("产品B系列中1型号产品的方法");
    }
}

public class ProductB2 implements ProductB {
    @Override
    public void methodB() {
        System.out.println("产品B系列中2型号产品的方法");
    }
}

定义工厂接口

public interface ProductFactory {
    ProductA createProductA();
    ProductB createProductB();
}

工厂实现

public class ProductFactory1 implements ProductFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class ProductFactory2 implements ProductFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

测试类

public class Test {
    public static void main(String[] args) throws Exception {
        ProductFactory factory = new ProductFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        productA.methodA();
        productB.methodB();

        factory = new ProductFactory2();
        productA = factory.createProductA();
        productB = factory.createProductB();
        productA.methodA();
        productB.methodB();
    }
}

输出结果

产品A系列中1型号产品的方法
产品B系列中1型号产品的方法
产品A系列中2型号产品的方法
产品B系列中2型号产品的方法