工厂模式-D- 抽象工厂模式

川长思鸟来 2022-07-12 12:18 171阅读 0赞

package D\_Factory.d;

public class CheesePizza extends Pizza \{  
PizzaIngredientFactory ingredientFactory;

public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
    
    @Override
    public void prepare() {
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }

\}  
package D\_Factory.d;

public class CheesePizza extends Pizza \{  
PizzaIngredientFactory ingredientFactory;

\}  
package D\_Factory.d;

public class ClamPizza extends Pizza \{  
PizzaIngredientFactory ingredientFactory;

public ClamPizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
    
    @Override
    public void prepare() {
        //需要的材料跟工厂要，不同风味的披萨可以使用原料工厂处理地区差异,而不需要设计不同的类进行处理
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        cheese = ingredientFactory.createClam();
    }

\}  
package D\_Factory.d;

public interface Dough \{

\}  
package D\_Factory.d;

public class NYPizzaIngredientFactory implements PizzaIngredientFactory \{

// 可以创建具体的dough材料
    public Dough createDough() {
        return new ThickCrustDough();
    }
    
    public String createSauce() {
        return null;
    }
    
    public String createCheese() {
        return null;
    }
    
    public String createClam() {
        return null;
    }

class ThickCrustDough implements Dough \{

\}  
package D\_Factory.d;

/\*  
\* 需要的材料跟工厂要，不同风味的披萨可以使用原料工厂处理地区差异,而不需要设计不同的类进行处理  
\*/  
public class NYPizzaStore extends PizzaStore \{

@Override
    protected Pizza createPizza(String type) {
        PizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza(pizzaIngredientFactory);
            pizza.setName("cheese");
        } else if (type.equals("clam")) {
            pizza = new ClamPizza(pizzaIngredientFactory);
            pizza.setName("clam");
        }
        return pizza;
    }

\}  
package D\_Factory.d;

import D\_Factory.d.Dough;

public abstract class Pizza \{  
public String name;  
public Dough dough;  
public String sauce;  
public String cheese;  
public String clam;

public void prepare() {
        System.out.println("prepare");
    }
    
    public void bake() {
        System.out.println("bake");
    }
    
    public void cut() {
        System.out.println("cut");
    }
    
    public void box() {
        System.out.println("box");
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

\}  
package D\_Factory.d;

public interface PizzaIngredientFactory \{

public Dough createDough();
    
    public String createSauce();
    
    public String createCheese();
    
    public String createClam();

\}  
package D\_Factory.d;

/\*\*  
\* 由于做披萨做法有差异，使用其他厂商的盒子等等  
\* 解决让披萨制作局限于pizzaStore类，同时又能让加盟店依然可以自由制作该地区风味的披萨  
\*/  
public abstract class PizzaStore \{

public final Pizza orderPizza(String type) {
        Pizza pizza;
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    
    // 让子类决定创建何种口味风格的披萨,此方法如同工厂
    //工厂方法用来处理对象的创建，并将这样的行为封装在子类中，这样客户程序中关于超类的代码和子类对象创建代码解耦了
    protected abstract Pizza createPizza(String type);