创建对象的类称之为工厂。工厂模式用来约束对象创建行为，通常为借口创建实例，统一收敛对象创建口径，管理不同实现。

例如 spring 框架的 BeanFactory。

简单工厂（静态工厂）

在工厂类中提供一个封装的静态工厂方法，用于隐藏对象初始化细节，使客户端代码可以专注于使用，而不用关心类的初始化过程。

如果一个对象的创建比较简单，推荐使用简单工厂模式。

public interface Cache {

    void get(String key);
    void put(String key, String value);

}

public class MemoryCache implements Cache {

    @Override
    public void get(final String key) {
        System.out.printf("get from memory: %s \r\n", key);
    }

    @Override
    public void put(final String key, final String value) {
        System.out.printf("put memory: %s - %s \r\n", key, value);
    }

}

public class RedisCache implements Cache {

    @Override
    public void get(final String key) {
        System.out.printf("get from redis: %s \r\n", key);
    }

    @Override
    public void put(final String key, final String value) {
        System.out.printf("put redis: %s - %s \r\n", key, value);
    }

}

public enum CacheType {

    MEMORY(MemoryCache::new),
    REDIS(RedisCache::new),
    ;

    private final Supplier<Cache> constructor;

    CacheType(final Supplier<Cache> constructor) {
        this.constructor = constructor;
    }

    public Supplier<Cache> getConstructor() {
        return constructor;
    }
}

public class CacheFactory {

    public static Cache createCache(CacheType type) {
        return type.getConstructor().get();
    }

}

// 测试
public class CacheApp {

    public static void main(String[] args) {
        final Cache cache = CacheFactory.createCache(CacheType.REDIS);
        String key = "k1";
        String value = "v1";
        cache.put(key, value);
        cache.get(key);
    }
}

工厂方法

如果对象创建有点复杂，可以考虑用工厂方法模式，将代码剥离，可读性会更好一些。

// 运算操作接口
public interface Operation {

    int getResult(int a, int b);

}

// 加法运算
public class AddOperation implements Operation {

    @Override
    public int getResult(final int a, final int b) {
        return a + b;
    }
}

// 减法运算
public class SubOperation implements Operation {

    @Override
    public int getResult(final int a, final int b) {
        return a - b;
    }
}

public interface OperationFactory {

    Operation createOperation();

}

public class AddOperationFactory implements OperationFactory {

    @Override
    public Operation createOperation() {
        return new AddOperation();
    }
}


public class SubOperationFactory implements OperationFactory {

    @Override
    public Operation createOperation() {
        return new SubOperation();
    }
}

测试类

public class OperationApp {

    public static void main(String[] args) {
        OperationFactory factory = new AddOperationFactory();
        final Operation operation = factory.createOperation();
        int a = 10;
        int b = 20;
        final int result = operation.getResult(a, b);
        System.out.println("result: " + result);
    }

}

抽象工厂

抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。避免创建过多的 factory 类。

参考：https://zh.wikipedia.org/zh-hans/抽象工厂 (opens new window)

public interface Button {

    void click();

}

public class MacButton implements Button {

    @Override
    public void click() {
        System.out.println("mac button click");
    }
}

public class WindowsButton implements Button {

    @Override
    public void click() {
        System.out.println("windows button click");
    }
}

public interface Border {

    void draw();

}

public class MacBorder implements Border {

    @Override
    public void draw() {
        System.out.println("mac border draw");
    }
}

public class WindowsBorder implements Border {
    @Override
    public void draw() {
        System.out.println("windows border draw");
    }
}

public interface UiFactory {

    Button createButton();

    Border createBorder();

}

public class MacUiFactory implements UiFactory {

    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Border createBorder() {
        return new MacBorder();
    }
}


public class WindowsUiFactory implements UiFactory {

    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Border createBorder() {
        return new WindowsBorder();
    }
}