工厂方法（Factory Method）

能够弥补simple factory的不足

将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，有子类决定应实例化哪个类。

角色：
(1) Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类
(2) ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应
(3) Factory(抽象工厂):在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。
(4) ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例。

package com.llb.factory.factoryMethod;

/**
 * 抽象工厂
 */
public interface ProductFactory {
    Product manufacture();
}

package com.llb.factory.factoryMethod;

/**
 * 抽象产品
 */
public interface Product {
    void show();
}

package com.llb.factory.factoryMethod;

/**
 * 具体工厂A
 */
public class FactoryA implements ProductFactory{
    @Override
    public Product manufacture() {
        System.out.println("具体工厂A");
        return new ProductA();
    }
}

package com.llb.factory.factoryMethod;

/**
 * 具体工厂B
 */
public class FactoryB implements ProductFactory{
    @Override
    public Product manufacture() {
        System.out.println("具体工厂B");
        return new ProductB();
    }
}


package com.llb.factory.factoryMethod;

/**
 * 具体产品A
 */
public class ProductA implements Product{
    @Override
    public void show() {
        System.out.println("具体产品A");
    }
}

package com.llb.factory.factoryMethod;

/**
 * 具体产品B
 */
public class ProductB implements Product{
    @Override
    public void show() {
        System.out.println("具体产品B");
    }
}

package com.llb.factory.factoryMethod;

public class Client {
    public static void main(String[] args) {
        ProductFactory factoryA = new FactoryA();
        Product productA = factoryA.manufacture();
        productA.show();

        ProductFactory factoryB = new FactoryB();
        Product productB = factoryB.manufacture();
        productB.show();
    }
}

这种模式的好处是：
1，符合开闭原则：增加新产品时，只需要增加相应的具体工厂类和具体产品类；
2，符合单一职责原则：一个工厂只负责一个产品的创建

package com.llb.factory.factoryMethod;

public class FactoryC implements ProductFactory{
    @Override
    public Product manufacture() {
        System.out.println("具体工厂C");
        return new ProductC();
    }
}


package com.llb.factory.factoryMethod;

public class ProductC implements Product{
    @Override
    public void show() {
        System.out.println("具体产品C");
    }
}


package com.llb.factory.factoryMethod;

public class Client {
    public static void main(String[] args) {
        ProductFactory factoryA = new FactoryA();
        Product productA = factoryA.manufacture();
        productA.show();

        ProductFactory factoryB = new FactoryB();
        Product productB = factoryB.manufacture();
        productB.show();

        ProductFactory factoryC = new FactoryC();
        Product productC = factoryC.manufacture();
        productC.show();
    }
}

缺点是：
1，一个具体工厂只生产一个具体产品，当工厂和产品增多，类也增多，系统复杂度上升；
2，如果需要更换具体工厂里面生产的具体产品还是要更改原有代码，这就违反了开闭原则；