工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
抽象工厂模式：提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

1. 工厂方法

public abstract class PizzaStore {
    
    
    public Pizza orderPizza(String type) {
    
    
        Pizza pizza = createPizza(type); //开分店的奥，每个分店需要不同的口味的幺
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    protected abstract Pizza createPizza(String type);
}

public class NYPizzaStore extends PizzaStore {
    
    
    @Override
    protected Pizza createPizza(String item) {
    
    
        if (item.equals("cheese")) {
    
    
            return new NYStyleCheesePizza();
        }
        if (item.equals("veggie")) {
    
    
            return new NYStyleVeggiePizza();
        }
        return null;
    }
}

2. 抽象工厂

public interface PizzaIngredientFactory {
    
    
    Cheese createCheese();
    Clam createClam();
}

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    
    

    @Override
    public Cheese createCheese() {
    
    
        return new ReggianoCheese();
    }

    @Override
    public Clam createClam() {
    
    
        return new FreshClam();
    }
}

public class CheesePizza extends Pizza {
    
    
    private PizzaIngredientFactory ingredientFactory;

    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
    
    
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void prepare() {
    
    
        System.out.println("Preparing " + name);
        cheese = ingredientFactory.createCheese();
    }
}

public class NYPizzaStore extends PizzaStore {
    
    
    @Override
    public Pizza createPizza(String item) {
    
    
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        if (item.equals("cheese")) {
    
    
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
        } else if (item.equals("clam")) {
    
    
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
        }
        return pizza;
    }
}

3. 简单工厂

public class SimplePizzaFactory {
    
    
    public static Pizza createPizza(String type) {
    
    
        Pizza pizza = null;
        if (type.equals("cheese")) {
    
    
            pizza = new CheesePizza();
        } else if (type.equals("veggie")) {
    
    
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

抽象工厂与工厂方法区别：

抽象工厂的方法经常以工厂方法的方式实现。抽象工厂的任务是负责创建一组产品的接口，这个接口中的每个方法负责创建一个具体的产品，同时我们利用实现抽象工厂的子类来实现这些具体的做法，所以，在抽象工厂中利用工厂方法实现生产方法是相当自然的事情；
工厂方法创建对象通过继承，抽象工厂通过组合；
扩展新产品抽象工厂接口要改变，工厂方法不需要改变；
抽象工厂用于创建产品家族，让创建的相关产品集合起来，工厂方法使客户代码从实例化的具体类解耦，使用简单

体现设计原则： 依赖倒置原则(依赖于抽象，而非具体类)

备注： 简单工厂不是一种设计模式，反而更像一种编程习惯