场景：

一家饭店菜单上有两种饭，分别是黄焖鸡米饭和河北正宗安徽牛肉板面，顾客点餐我们要做出顾客选的那种饭

首先肯定是有一个接口Cook，cook方法表示做饭

public interface Cook {
    void cook();
}

创建两个类来实现Cook接口

public class CookMi implements Cook{
    @Override
    public void cook() {
        System.out.println("黄焖鸡米饭");
    }
}

public class CookMian implements Cook{
    @Override
    public void cook() {
        System.out.println("河北正宗安徽牛肉板面");
    }
}

不使用工厂模式：

直接通过new对象的方式，调用cook方法

public class Test {
    public static void main(String[] args) {
        Cook cook;
        System.out.println("请输入你要点的餐：");
        Scanner scanner = new Scanner(System.in);
        String type = scanner.nextLine();
        if("mi".equals(type)){
            cook = new CookMi();
        }else if ("mian".equals(type)) {
            cook = new CookMian();
        }else{
            System.out.println("请输入正确的类型");
            cook = null;
        }
        if(cook != null){
            cook.cook();
        }
    }
}

普通工厂模式

创建工厂类CookFactory，将判断语句放到这里，return Cook对象

public class CookFactory{
    public Cook cookCreate(String type){
        if("mi".equals(type)){
            return new CookMi();
        }else if("mian".equals(type)){
            return new CookMian();
        }else{
            System.out.println("请输入正确的类型");
            return null;
        }
    }
}

在测试类Test中new工厂对象，调用cookCreate方法来创建对象

public class Test {
    public static void main(String[] args) {
        Cook cook;
        CookFactory cookFactory = new CookFactory();
        cook = cookFactory.cookCreate("mi");
        if(cook != null){
            cook.cook();
        }
    }
}

多个工厂方法模式

在普通工厂模式中，我们发现可能会出现点的餐在菜单上不存在的情况，这时我们可以把做饭方法分为两个，做米饭和做面条

public class CookFactory{
    public Cook cookMiCreate(){
        return new CookMi();
    }
    public Cook cookMianCreate(){
        return new CookMian();
    }
}

测试类Test只需要调用对应的方法，不用参数就可以创建Cook对象

public class Test {
    public static void main(String[] args) {
        Cook cook;
        CookFactory cookFactory = new CookFactory();
        cook = cookFactory.cookMianCreate();
        if(cook != null){
            cook.cook();
        }
    }
}

静态工厂模式

在普通工厂模式或者多个工厂模式的基础上把create方法设置为静态方法即可

public class CookFactory{
    public static Cook cookMiCreate(){
        return new CookMi();
    }
    public static Cook cookMianCreate(){
        return new CookMian();
    }
}

在测试类Test中不需要创建工厂对象，直接调用方法即可

public class Test {
    public static void main(String[] args) {
        Cook cook;
        cook = CookFactory.cookMiCreate();
        if(cook != null){
            cook.cook();
        }
    }
}

抽象工厂模式

前面几种模式都有一个问题，就是如果想要拓展程序，就是在菜单上加菜，必须修改工厂类，违背了闭包原则，我们可以使用抽象工厂模式，创建多个工厂类，一旦想要进行拓展，只需要添加新的工厂即可，不需要修改之前的代码

创建一个接口CookCreate，此后每个工厂类都要实现这个接口

public interface CookCreate {
    Cook cookCreate();
}

两个工厂，分别为做米饭和做面条

public class CookMiFactory implements CookCreate{
    @Override
    public Cook cookCreate() {
        return new CookMi();
    }
}

public class CookMianFactory implements CookCreate{
    @Override
    public Cook cookCreate() {
        return new CookMian();
    }
}

在测试类Test中，new出对应工厂，调用接口方法即可创建对象

public class Test {
    public static void main(String[] args) {
        Cook cook;
        CookCreate create = new CookMianFactory();
        cook = create.cookCreate();
        cook.cook();
    }
}

如果想要在菜单上加菜，只需要创建一个做饭类实现Cook接口，再创建一个工厂并实现CookCreate接口即可