工厂各种模式

前言

工厂模式各种模式

简单工厂模式

简单工厂模式是由一个工厂对象决定创建出哪一种（某个接口的多种具体实现）的实例。客户端只需要传入工厂类建造方法的参数(class对象)，对于如何创建对象的逻辑不需要关心。

提供一个 IPeople 接口，有一个 eat 的方法。

public interface IPeople {
    public void eat();
}

这个接口可以有很多实现类，如：

public class JavaPeople implements IPeople {
    @Override
    public void eat() {
        System.out.println("Java人正在吃饭");
    }
}

接下来是工厂类：

public class PeopleFactory {

    public static IPeople create(Class<? extends IPeople> clazz) {
        try {
            if (null != clazz) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

此时，客户端只需传入要具体实例化对象的class对象，即可创建对象。

public static void main(String[] args) {
    IPeople iPeople = PeopleFactory.create(JavaPeople.class);
    iPeople.eat();
}

这样，如果以后有源源不断的 IPeople 接口的不同的实现类，也可以通过此工厂的方法完成创建。代码实现了解耦。

工厂方法模式

工厂方法模式是对工厂本身也做了一个抽象。由专门的工厂创建专门的对象。主要解决的是扩展问题，如果每个实例的创建逻辑有区别，那么就需要修改简单工厂的方法，不便于维护。如下面的例子，PythonPeople 在创建的时候需要指定 eat 的食物为蛋炒饭：

// 对工厂本身也做一个抽象
public interface IPeopleFactory {
    IPeople create();
}

public class PythonPeople implements IPeople {
    public void setFood(String food) {
        this.food = food;
    }
    private String food;
    @Override
    public void eat() {
        System.out.println("Python人正在吃：" + food);
    }
}

public class PythonPeopleFactory implements IPeopleFactory{
    @Override
    public IPeople create() {
        PythonPeople pythonPeople = new PythonPeople();
        pythonPeople.setFood("蛋炒饭");
        return pythonPeople;
    }
}

public class JavaPeopleFactory implements IPeopleFactory {
    @Override
    public IPeople create() {
        return new JavaPeople();
    }
}

客户端：

public static void main(String[] args) {
    JavaPeopleFactory javaCourseFactory = new JavaPeopleFactory();
    IPeople iPeople = javaCourseFactory.create();
    iPeople.eat();

    PythonPeopleFactory pythonPeopleFactory = new PythonPeopleFactory();
    IPeople iPeople1 = pythonPeopleFactory.create();
    iPeople1.eat();

}

抽象工厂模式

抽象工厂模式是指创提供一个创建一系列相关或相互依赖对象的接口。
比如说 JavaPeople 和 JavaBook 都 属于 Java 这一系列。举个好理解的例子：大米公司 有 ：大米手机、大米电脑、大米平板，它们是不同的东西但是都属于大米这一个品牌。

public interface IBook {
    void read();
}

public interface IPeople {
    void eat();
}

public class JavaBook implements IBook {
    @Override
    public void read() {
        System.out.println("看Java书");
    }
}

public class JavaPeople implements IPeople {
    @Override
    public void eat() {
        System.out.println("Java人吃饭");
    }
}

抽象工厂，具体可以有很多实现，比如：JavaLanguageFactory,PythonLanguageFactory等等

public abstract class LanguageFactory {
    public void init() {
        System.out.println("初始化");
    }

    protected abstract IPeople createPeople();

    protected abstract IBook createBook();

}

public class JavaLanguageFactory extends LanguageFactory {
    @Override
    protected IPeople createPeople() {
        super.init();
        return new JavaPeople();
    }

    @Override
    protected IBook createBook() {
        super.init();
        return new JavaBook();
    }
}

public static void main(String[] args) {
    JavaLanguageFactory javaLanguageFactory = new JavaLanguageFactory();
    javaLanguageFactory.createBook().read();
    javaLanguageFactory.createPeople().eat();
}