工厂模式

工厂方法模式

在工厂方法模式中，共涉及以下4个角色。
抽象工厂角色，具体工厂角色，抽象产品角色，具体产品角色

抽象工厂

public interface Creator{
    /**
    工厂方法
    创建一个产品对象，其输入参数类型可以自行设置
    */
    
    public <T extends Product> T factory(Class<T> c);
}

抽象产品

public interface Product{
    //产品类的公共方法
    public void method1();
    public void method2();
}

具体工厂

public class ConcreteCreator implements Creator{
    public <T extends Product> T factory(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName()).newInstance();
        } catch(Exception e){
            
        }
        return (T) product;
    }
}

具体产品

public class ConcreteProduct implements Product{
    public void method1(){
        //业务逻辑代码
    }
    
    public void method2(){
        
    }
}

应用代码

public class FactoryMethodDemo{
    public static vodi main(String[] ags){
        Creator creator = new CoreteCreator();
        Product product = creator.factory(ConcreteProduct.class);
        /**
        继续业务处理
        */
    }
}

抽象工厂模式

抽象工厂模式中的角色与工厂方法类似，也是有4个角色。

抽象工厂（Abstract Factory）角色，具体工厂（Concrete Factory）角色，抽象产品（Abstract Product）角色，具体产品（Concrete Product）角色

抽象工厂模式是工厂方法模式的进一步抽象，针对的是一族产品。如果产品族中只有一种产品，则抽象工厂模式就退化为工厂方法模式。

应用需要涉及不同操作系统的时候，可以考虑使用抽象工厂模式，如果需要在三个不同的平台（Windows、Linux、Android）上运行，则可以通过抽象工厂模式屏蔽掉操作系统对应用的影响。三个不同操作系统上的软件功能、应用逻辑、UI都应该是非常类似的，唯一不同的是调用不同的工厂方法，由不同的产品类去处理与操作系统交互的信息。

抽象工厂AbstractFactory.java

public interface AbstractFactory{
    // 创建产品A
    public ProductA factoryA();
    // 创建产品B
    public ProductB factoryB();
}

具体工厂ConcreteFactory1.java

public class ConcreteFactory1 implements AbstractFactory{
    // 创建等级为1的产品A
    public ProductA factoryA(){
        return new ProductA1();
    }
     // 创建等级为1产品B
    public ProductB factoryB(){
        return new ProductB1();
    }
}

具体工厂ConcreteFactory2.java

public class ConcreteFactory2 implements AbstractFactory{
    // 创建等级为2的产品A
    public ProductA factoryA(){
        return new ProductA2();
    }
    // 创建等级为2产品B
    public ProductB factoryB(){
        return new ProductB2();
    }
}

产品A的抽象接口ProductA.java

public interface ProductA{
    //产品A的公共方法
    public void method1();
    public void method2();
}

产品A的两个具体产品ProductA1和ProductA2

public class ProductA1 implements ProductA {
    public void method1() {
        System.out.println("等级为1的产品A的实现方法");
    }
    public void method2() {
        // 业务逻辑处理代码
    }
}

public class ProductA2 implements ProductA {
    public void method1() {
        System.out.println("等级为2的产品A的实现方法");
    }
    public void method2() {
        // 业务逻辑处理代码
    }
}

对于抽象工厂模式的应用代码

public class ClientDemo {
    public static void main(String args[]) {
        // 定义两个工厂
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();
        // 生产等级为1的产品A
        ProductA a1 = factory1.factoryA();
        // 生产等级为2的产品A
        ProductA a2 = factory2.factoryA();
        // 生产等级为1的产品B
        ProductB b1 = factory1.factoryB();
        // 生产等级为2的产品B
        ProductB b2 = factory2.factoryB();
        // 业务处理
        a1.method1();
        a2.method1();
        b1.method1();
        b2.method1();
    }
}