java设计模式-工厂模式

工厂模式

工厂模式大致分为三种，分别是简单工厂模式、工厂方法模式和抽象工厂模式，是开发过程中使用最多的一种模式。

简单工厂模式

简单工厂模式一句话解释就是创建一个工厂对象来决定创建哪一种产品对象出来。用工厂类封装了实例化对象的行为。具体的实例如下:
基础对象类

/**
 * 抽象类 设计
 */
public abstract class Pizza {
    protected String name;
    //准备原材料。不同的披萨不一样，因此，我们做成抽象方法
   public abstract void prepare();

    /**
     * 其他的方法都差不多
     */
   public void bake(){
       System.out.println(name + "  baking");
   }
    public void cut(){
        System.out.println(name + "  cutting");
    }
    public void box(){
        System.out.println(name + "  boxing");
    }

    public void setName(String name) {
        this.name = name;
    }
}


public class CheesePizza extends Pizza{

    public void prepare() {
        System.out.println("give CheesePizza prepare ");
    }
}
public class GreekPizza extends Pizza{

    public void prepare() {
        System.out.println("give GreekPizza prepare ");
    }
}

创建工厂对象创建具体的GreekPizza 和CheesePizza ，实例如下：

/**
 * 简单工厂模式(静态工厂模式)
 * 设计模式的目的是，抽离相同的特性放到单独的类或接口中，
 * 在代码扩展的时候尽量最少的修改代码
 */
public class SimpleFactory {

    /**
     * 根据对象
     * @param orderType
     * @return
     */
    public Pizza createPizza(String orderType){
        System.out.println("简单工厂模式");
        Pizza pizza = null;
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" greek ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" cheese");
        }
        return pizza;
    }
}

public class OrderPizza {


    //使用聚合的方式定义SimpleFactory
    SimpleFactory simpleFactory;
    Pizza pizza = null;


    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = ""; //

        this.simpleFactory = simpleFactory; //

        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            if(pizza != null) { //
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" ");
                break;
            }
        }while(true);
    }

    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

总结：在使用的过程中，具体构建对象的方式在工厂类中，外部类只用通过不同的方式调用工厂类就可以实现特定对象的建立。在开发过程中对于代码的扩展更加容易，只用添加新的对象，并且修改工厂对象的创建方法即可。

工厂方法模式

工厂方法模式适用于更加细致的需求，比简单工厂模式稍微复杂一点。
示例如下：
基础类设计

/**
 * 抽象类 设计
 */
public abstract class Pizza {
    protected String name;
    //准备原材料。不同的披萨不一样，因此，我们做成抽象方法
   public abstract void prepare();

    /**
     * 其他的方法都差不多
     */
   public void bake(){
       System.out.println(name + "  baking");
   }
    public void cut(){
        System.out.println(name + "  cutting");
    }
    public void box(){
        System.out.println(name + "  boxing");
    }

    public void setName(String name) {
        this.name = name;
    }
}
//实现类A
public class LDGreekPizza extends Pizza {

    public void prepare() {
        System.out.println("give LDGreekPizza prepare ");
    }
}
//实现类B
public class LDCheesePizza extends Pizza {

    public void prepare() {
        System.out.println("give LDCheesePizza prepare ");
    }
}
//实现类C
public class BJGreekPizza extends Pizza {

    public void prepare() {
        System.out.println("give BJGreekPizza prepare ");
    }
}
//实现类D
public class BJCheesePizza extends Pizza {

    public void prepare() {
        System.out.println("give BJCheesePizza prepare ");
    }
}

工厂类如下：

//A工厂
public class BJOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new BJGreekPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}
//B工厂
public class LDOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDGreekPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

总结：定义了一个创建对象的抽象方法，有子类决定要实例化的类。工厂方法模式将对象的实例化推迟到了子类。

抽象工厂模式

抽象工厂模式在开发过程中是最实用的一种工厂模式。

/**
 * 抽象工厂类
 */
public interface AbsFactory {
    /**
     * 让下面的子类具体去实现
     * @param orderType
     * @return
     */
    public Pizza createPizza(String orderType);
}

相比于抽象方法模式，抽象工厂模式把抽象类中的方法变成了接口，把类类之间的耦合度降的更低。更利于代码的扩展。