创建型设计模式----简单工厂、工厂、抽象工厂

简单工厂模式

在简单工厂中可以根据字符串的不同返回不同的实例。它定义了一个专门的工厂类去创建类的实例，将类的创建和使用解耦。

具体实现如下，
1、定义一个接口

public  interface Fruit {
    String fruitName();
}

2、定义具体的实现

class Apple implements Fruit {
    @Override
    public String fruitName() {
        return "apple";
    }
}
class Banana implements Fruit {
    @Override
    public String fruitName() {
        return "banana";
    }
}
......

3、简单工厂类

class SimpleFactory {

    public static Fruit createFruit(String type) {
        Fruit f = null;
        switch (type) {
            case "apple" : f = new Apple();break;
            case "banana" : f = new Banana();break;
            default: break;
        } 
        return f;
    }
}

这里的工厂只有创建对象的功能，实际上也可以添加一些业务代码，如判断，日志等

优点：将对象的创建和对象的使用分离。工厂类隐藏了具体的创建细节
缺点：工厂类不够灵活，产品需要变动时每次都需要修改工厂类；而且产品过多的时候，工厂类代码会非常臃肿。

常见的场景：
Java中的工具类DateFormat，加密技术KeyGenerator（密钥生成器）、Cipher（密码器）、Executors等

工厂模式

工厂模式的实现就是将上面简单工厂进行了解耦，在工厂方法模式中，每一个产品都对应了一个工厂子类，由工厂子类来负责生成具体的产品对象。这样生产产品的代码就不会耦合在同一个类中了。
工厂方法模式的结构图是这个样子的：

我们对上面的代码进行修改
1、创建工厂接口

interface FactoryI {
    Fruit createFruit();
}

2、具体产品类和简单工厂一样
3、工厂类

class AppleFac implements FactoryI {
    @Override
    public Fruit createFruit() {
        System.out.println("apple");
        return new Apple();
    }
}

class BananaFac implements FactoryI {
    @Override
    public Fruit createFruit() {
        System.out.println("banana");
        return new Banana();
    }
}

优点：当需要增加新产品时，无须修改现有的系统，并且封装了产品对象的创建细节。具有良好的灵活性和扩展性。
缺点：在添加新产品时需要添加新的工厂类，导致系统类的个数成对增加，一定程度上提高了系统的复杂程度。

常见的使用场景：
JDBC中的工厂方法

抽象工厂模式

假如现在的需求改变了，我还需要水果罐头，苹果罐头，香蕉罐头。如果使用工厂方法模式则需要增加抽象罐头工厂，苹果罐头类，香蕉罐头类 ， 还有两个具体生产罐头类。那么增加这么多类势必会增加代码的复杂程度。那么我们可以使用抽象工厂来解决这个问题。

抽象工厂是解决产品族的问题，产品族比如海尔既有冰箱也有电视等这算是一个产品族。而工厂方法是解决产品等级，比如对于电视机，既有海尔的，也有TCL的。
抽象工厂的结构图：

1、罐头接口及其实现

interface Can {
    String canName();
}

class AppleCan implements Can{
    @Override
    public String canName() {
        return "appleCan";
    }
}

class BananaCan implements Can {
    @Override
    public String canName() {
        return "bananaCan";
    }
}

2、定义抽象工厂

interface AbstractFactory {
    Fruit createFruit();
    Can createCan();
}

3、定义Apple的相关产品工厂

class AppleFactory implements AbstractFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();//苹果本身
    }

    @Override
    public Can createCan() {
        return new AppleCan();//苹果罐头
    }
}

4、定义Banana的相关产品

class BananaFactory implements AbstractFactory {
    @Override
    public Fruit createFruit() {
        return new Banana();
    }

    @Override
    public Can createCan() {
        return new BananaCan();
    }
}

所以抽象工厂和工厂方法模式区别就是抽象工厂是可以生产多个产品的，是一个产品族。

优点：隔离了具体类的生成，而且每次可以通过具体工厂创建一个产品族的多个产品，修改产品族比较方便，增加新的具体工厂和产品族比较方便
缺点：增加新的产品等级很复杂，需要修改抽象工厂和所有的具体工厂类

常见的应用场景：
JavaAWT的抽象窗口工具包，程序中更换主题的功能

（如有错误，欢迎大家留言纠正 ，感谢！）

参考文章：
简单工厂模式、工厂模式以及抽象工厂模式