简单工厂模式+工厂方法模式+抽象工厂模式

简单工厂模式

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

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

示例代码如下:

public interface Fruit {
    void description();
}

public class Apple implements Fruit {
    @Override
    public void description() {
        System.out.println("This is an apple");
    }
}

public class Banana implements Fruit {
    @Override
    public void description() {
        System.out.println("This is a banana");
    }
}

public class FruitFactory {
    public static Fruit getFruitInstance(String name){
    switch(name){
        case "apple":
            return new Apple();
        case "banana":
            return new Banana();
            default:
                return null;
    }
    }
}

测试代码:

public class Test {
    public static void main(String[] args) {
        Fruit fruit=FruitFactory.getFruitInstance("apple");
        fruit.description();
        fruit=FruitFactory.getFruitInstance("banana");
        fruit.description();
    }
}

我们首先抽象出来一个水果接口，具体的水果实现此接口，在工厂方法中根据传入的参数动态来创建对应的水果对象。我们来分析一下它的缺点，加入我现在要新加一种橘子水果，代码如下:

public class Orange implements Fruit {
    @Override
    public void description() {
        System.out.println("This is an orange");
    }
}

public class FruitFactory {
    public static Fruit getFruitInstance(String name){
    switch(name){
        case "apple":
            return new Apple();
        case "banana":
            return new Banana();
        case "orange":
            return new Orange();
            default:
                return null;
    }
    }
}

从代码中可以看到，我们除了加一个橘子的实体，还要在工厂方法中新增创建橘子实体的条件，假如以后还要再加其他的水果，那么每次就要修改水果工厂方法，显然这是不可取的，违背了设计原则中的开闭原则(针对扩展开放，针对修改关闭),因此其适用场景在创建对象较少，相对简单的环境情况下使用。

工厂方法模式

工厂方法模式对简单工厂模式的不足做了很好的补充，我们来看一下代码的实现

public interface Fruit {
    void description();
}

public class Apple implements Fruit {
    @Override
    public void description() {
        System.out.println("This is an apple");
    }
}

public class Banana implements Fruit {
    @Override
    public void description() {
        System.out.println("This is a banana");
    }
}

public interface FruitFactory {
    Fruit createFruit();
}

public class AppleFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

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

测试代码:

public class Test {

    public static void main(String[] args) {
        FruitFactory fruitFactory=new AppleFactory();
        Fruit fruit=fruitFactory.createFruit();
        fruit.description();

        fruitFactory=new BananaFactory();
        fruit=fruitFactory.createFruit();
        fruit.description();
    }
}

与简单工厂不同的是，水果工厂也做了抽象，每种水果都有自己的工厂且只创建自己的对象。我们使用的时候创建其水果工厂就可以创建该工厂的水果对象了，如果我们要新加一种水果，代码如下:

public class Orange implements Fruit {
    @Override
    public void description() {
        System.out.println("This is an orange");
    }
}

public class OrangeFactory implements FruitFactory {
    @Override
    public Fruit createFruit() {
        return new Orange();
    }
}

这样新增加一种水果就加一个该水果的工厂，不需要修改原有代码，符合开闭原则，但也有一点不足之处就是类会变得特别多。

抽象工厂模式

抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。上面的工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。它的使用场景是创建一组相关或相互依赖的对象的时候，比如联想公司生产一套设备有键盘，鼠标，电脑；苹果公司也生产电脑，键盘，鼠标。那么联想生产的电脑，鼠标，键盘都属于联想公司的品牌，这些设备和联想公司都是相关的，即可称之为一个产品族。

下面还拿水果来做示例

public interface Fruit {
    void description();
}

public class Apple implements Fruit {
    @Override
    public void description() {
        System.out.println("This is an apple");
    }
}

public class Banana implements Fruit {
    @Override
    public void description() {
        System.out.println("This is a banana");
    }
}

public class ImportedApple implements Fruit {
    @Override
    public void description() {
        System.out.println("This is a imported apple");
    }
}

public class ImportedBanana implements Fruit {
    @Override
    public void description() {
        System.out.println("This is a imported banana");
    }
}

public interface FruitFactory {
    Fruit createApple();
    Fruit CreateBanana();
}

public class ChinaFactory implements FruitFactory {
    @Override
    public Fruit createApple() {
        return new Apple();
    }

    @Override
    public Fruit CreateBanana() {
        return new Banana();
    }
}

public class ImportedFactory implements FruitFactory {
    @Override
    public Fruit createApple() {
        return new ImportedApple();
    }

    @Override
    public Fruit CreateBanana() {
        return new ImportedBanana();
    }
}

public class Test {

    public static void main(String[] args) {
        FruitFactory fruitFactory=new ChinaFactory();
        Fruit fruit=fruitFactory.createApple();
        fruit.description();
        fruitFactory=new ImportedFactory();
        fruit=fruitFactory.createApple();
        fruit.description();
    }
}

测试代码:

这里我们除了国内厂商的水果外，新增了进口水果产品，进口水果也包含了苹果，香蕉等，其组成了进口产品族，在工厂对象里，我们抽象出了一个工厂接口提供了苹果和香蕉的产品，国内厂商实现了抽象接口，提供了国产的苹果和香蕉产品，进口的厂商实现了抽象接口，提供了进口的苹果和香蕉产品，我们在使用的时候，如果去的是国内的厂商，那么得到的就是国内的水果产品，如果去的是国外的厂商，那么得到的就是进口的水果产品。

简单工厂模式+工厂方法模式+抽象工厂模式