设计模式——工厂模式（实例讲解）

对于Java设计模式中的工厂模式而言，针对类别可分为简单工厂模式，工厂方法模式。而对应抽象的话分为工厂方法模式，抽象工厂模式。
工厂模式其实就是，将类的实例化以及方法隐藏起来，通过new一个对象，实现用户需求。
这里通过一个例子对应列举简单工厂模式：

我们现在有一个订单，要求各种蛋糕，客户根据需求订购蛋糕，商家接收蛋糕订单，对应生产蛋糕。

1.首先创建产品（Cake）
父类:

public abstract class Cake {
	protected String name;

	public abstract void prepare();

	public void bake() {
		System.out.println(name + " baking...");
	}

	public void cut() {
		System.out.println(name + " cuting...");
	}

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

}

1.1列举一例产品：

public class cheeseCake extends Cake {
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.out.print("cheeseCake is preparing ");
	}

}

2.将订单产品类实现（即是将用户所需的东西传送到工厂）

public class OrderCake {

	Cake cake;
	SingleFactory singleFactory;

	public OrderCake(SingleFactory singleFactory) {
		setFactory(singleFactory);
	}

	public void setFactory(SingleFactory singleFactory) {
		String type = "";
		this.singleFactory = singleFactory;
		do {

			type = getOrder();
			cake = this.singleFactory.creatCake(type);
			if (cake != null) {
				cake.bake();
				cake.cut();
			} else {
				System.out.print("订购失败");
				break;

			}

		} while (true);
	}

	@SuppressWarnings("resource")
	public String getOrder() {

		return new Scanner(System.in).nextLine();
	}

3.产品的制作，工厂实现

public class SingleFactory {

	public Cake creatCake(String orderType) {
		Cake cake = null;
		System.out.println("使用简单工厂模式");
		if (orderType.equals("cheese")) {
			cake = new cheeseCake();
			cake.setName(orderType);
		} else if (orderType.equals("piper")) {
			cake = new piperCake();
			cake.setName(orderType);
		}
		return cake;
	}
}

4.商店（实现需求，需求传送工厂）

public class store {

	public static void main(String[] args) {
		new OrderCake(new SingleFactory());
	}
}

对应当我们需求增加，例如我们的cake也有分区域，对应其实是增加产品需求。
例如 蛋糕的一些属性增加，比如北京的蛋糕或者伦敦的蛋糕。
这样一来为了避免耦合性，以及在源代码的基础上去修改，就需要搭建另一种框架，可以选择性抽象，，例如工厂抽象，或者方法抽象。
这里以方法抽象举例：

1.对应蛋糕的例子：
要对蛋糕类的方向抽象，具体实现交给子类

public abstract class cake {
	protected String name;

	public abstract void prepare();

	public void bake() {
		System.out.println(name + " baking...");
	}

	public void cut() {
		System.out.println(name + " cuting...");
	}

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

1.1列举一个子类：

public class LDchesscake extends cake{

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.err.println("伦敦奶酪");
	}
        
}

2.订单的生成（分区域北京以及伦敦 就对应也要抽象orderstore）

public abstract class  ordercake {
         abstract cake creatcake(String orderType);
         
         public ordercake() {
        	 cake cake1=null;
        	 String orderType;
        	 do {
        		 orderType=getType();
        		 cake1=creatcake(orderType);
        		 cake1.prepare();
        		 cake1.bake();
        		 cake1.cut();
        	 }while(true);
        	 
        	 
         }
         public String  getType() {
        	 String orderString=null;
        	 Scanner scanner=new Scanner(System.in);
        	 orderString=scanner.nextLine();
        	 return orderString;
         }
}

3.商店实现；
对应需要什么蛋糕 ，new 那个类。。。

public class store {
	public static void main(String[] args) {
		new BJordercake();
	}
}

例子就这样了。。。。其实就是针对你发现这个类中的属性属于同级，可与其他一块并行，导致了区分度，这时候你可以将该方法抽象化，具体实现交给子类。。