应用最广泛的模式——工厂方法模式

工厂方法模式定义

定义一个用于创建对象的接口，让子类决定实例化哪个类。

使用场景

• 在任何需要生成复杂对象的地方
• 用new可以完成创建的对象无需使用工厂模式

其实工厂模式在初学java的时候就学过，比如，我们通过一个方法来返回一个对象，在android中很多类获取对象的方式都是这样设计的。在看完工厂模式，我觉得工厂模式适用于当我们频繁的对一个对象进行操作时，就像很多增、删、改、查的工作，同时这个对象也有和他相同功能的类需要增删改查，我们就可以采用工厂模式。

工厂方法模式的通用模式代码

抽象产品类

public abstract Product{
    public abstract void method();
}

具体产品类A

public class ProductA extends Product{
    public void method(){
        System.out.println("产品A")；
    }
}

具体产品类B

public class ProductB extends Product{
    public void method(){
        System.out.println("产品B")；
    }
}

抽象工厂类

public abstract class Factory{
    public abstract Product createProduct();
}

具体工厂类

puclic class ConcreteFactory extends Factory{
    public Product createProduct(){
        return new ProductA();
    }
}

客户类

public class Client{
    public static void main(String[] args){
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct();
        p.method();
    }
}

上述过程主要分为四大模块：

• 抽象工厂
• 具体工厂
• 抽象产品
• 具体产品

利用反射生产产品

public abstract class Factory{
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

具体工厂类：

public class ConcreateFactory extends Factory{
    public <T extends Product> T createProduct(Class<T> clz){
        Product p = null;
        try{
            p = (Product)Class.forName(clz.getName()).newInstance();
        }catch(Exception e){
            e.printStackTrace();
        }
        return (T) p;
    }
}

Client中的实现：

public class Client{
    public static void main(String[] args){
        Factory factory = new CreateFactory();
        Product p = factory.createFactory(ProductA.class);
    }
}

需要哪一个类就传入哪一个类，这中方法比较简洁，动态。

多工厂方法模式

puclic class ConcreteFactoryA extends Factory{
    public Product createProduct(){
        return new ProductA();
    }
}

puclic class ConcreteFactoryB extends Factory{
    public Product createProduct(){
        return new ProductB();
    }
}

public class Client{
    public static void main(String[] args){
        Factory factoryA = new ConcreateFactoryA();
        ProductA productA = factoryA.createProduct();
        productA.method();
        
        Factory factoryB = new ConcreateFactoryB();
        ProductB productB = factoryB.createProduct();
        productB.method();
    }
}

简单工厂模式和静态工厂模式

public class Factory{
    public static Product createProduct(){
        return new ProductA();
    }
}

是工厂方法模式的一个弱化版本

抽象工厂模式

抽象工厂模式就是通过提供一个抽象工厂类，再由生产不同产品的工厂类去实现，同时还有抽象产品类和具体产品类，适用于多种产品但样式不同有差异的情况。例如：在想写主题切换的功能时，可以采用抽象工厂模式。

抽象工厂模式的通用代码：
抽象产品类A

public abstract class AbstractFactoryA{
    public abstract void method();
}

抽象产品类B

public abstract class AbstractFactoryB{
    public abstract void method();
}

具体产品类A1

public class ProductA1 extends AbstractFactoryA{
    public void method(){
        System.out.println("具体产品类A1")；
    }
}

具体产品类A2

public class ProductA2 extends AbstractFactoryA{
    public void method(){
        System.out.println("具体产品类A2")
    }
}

具体产品类B1

public class ProductB1 extends AbstractFactoryB{
    public void method(){
        System.out.println("具体产品类B1")；
    }
}

具体产品类B2

public class ProductB2 extends AbstractFactoryB{
    public void method(){
        System.out.println("具体产品类B2")；
    }
}

抽象工厂类

public class abstract AbstractFactory{
    public abstract AbstractFactoryA createProductA();
    public abstract AbstractFactoryB createProductB();
}

工厂类1

public class Factory1 extends AbstractFactory{
    public AbstractFactoryA createProductA{
        return new ProductA1();
    }
    
    public AbstractFactoryB createProductB{
        return new ProductB1();
    }
}

工厂类2

public class Factory2 extends AbstractFactory{
    public AbstractFactoryA createProductA{
        return new ProductA2();
    }
    
    public AbstractFactoryB createProductB{
        return new ProductB2();
    }
}

优点：接口与实现分离

缺点：类文件爆炸性增长 且不容易扩展新产品 触一发而动全身