一、简单工厂模式

1.1 简单工厂模式概述

        简单工厂模式又叫做静态工厂方法模式。

• 目的：定义一个用于创建对象的接口。
• 实质：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。

• 简单工厂模式基本实现流程：
• 1.具体产品类：将需要创建的各种不同产品对象的相关代码封装到具体产品类中；
• 2.抽象产品类：将具体产品类公共的代码进行抽象和提取后封装在一个抽象产品类中；
• 3.工厂类：提供一个工厂类用于创建各种产品，在工厂中提供一个创建产品的工厂方法，该方法可以根据所传入参数的不同创建不同的具体产品对象。
• 4.客户端：指需调用工厂类的工厂方法并传入相应的参数即可得到一个产品对象。

        创建对象与适用对象

• Java语言创建对象的几种方式：
  • 1.用new关键字直接创建对象；
  • 2.通过反射机制创建对象；
  • 3.通过克隆方法创建对象；
  • 4.通过工厂类创建对象。

• 将对象的创建与使用分离的其他好处：
  • 1.防止用来实例化一个类的数据和代码在多个类中到处都是，可以将有关创建的知识搬移到一个工厂类中，解决代码重复、创建蔓延的问题；
  • 2.构造函数的名字都与类名相同，从构造函数和参数列表中大家很难里哦阿姐不同构造函数所构造的产品的差异->将对象的创建过程封装在工厂类中，可以提供一系列名字完全不同的工厂方法，每一个工厂方法对应一个构造函数，客户端可以以一种更加可读、易懂的方式来创建对象。
• 何时不需要工厂？
  • 1.无须为系统中的每一个类都配备一个工厂类；
  • 2.如果一个类很简单，而且不存在太多变化，其构造过程也很简单，此时就无须为其提供工厂类，直接在使用之前实例化即可；
  • 3.否则会导致工厂泛滥，增加系统的复杂度。

        简单工厂模式的简化：将抽象产品类和工厂类合并，将静态工厂方法移至抽象产品类中。

• 简单工厂模式的优缺点：
  • 优点：
    • 1.实现了对象创建和使用的分离
    • 2.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可
    • 3.通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性
  • 缺点：
    • 1.工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响
    • 2.增加系统中类的个数（引入了新的工厂类），增加了系统的复杂度和理解难度
    • 3.系统扩展困难，一旦添加新产品不得不修改工厂逻辑
    • 4.由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构，工厂类不能得到很好地扩展
• 适用环境
  • 1.工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂
  • 2.客户端只知道传入工厂类的参数，对于如何创建对象并不关心

 1.2 代码实现

        简单工厂模式包含3个角色：

• 工厂角色
• 抽象产品角色
• 具体产品角色

        1.2.1 抽象产品角色(Pizza：将具体行为抽象出来)

package factory.simple.pizzaFactory;
//抽象产品
import java.util.ArrayList;

public abstract class Pizza {
	String name;
	String dough;//面团
	String sauce;//酱料
	ArrayList toppings=new ArrayList();//佐料
	public void prepare(){
		System.out.println("preparing "+ name); 
		System.out.println("Tossing dough... "); 
		System.out.println("adding sauce... "); 
		for (int i=0;i<toppings.size();i++)
			System.out.println(" "+toppings.get(i));
	}
	public  void bake(){
		System.out.println("Bake for 25minutes at 350"); }
	public  void cut(){
		System.out.println("cutting the pizza"); }
	public  void box(){
	   System.out.println("place pizza in officical Pizza box");}
	public String getName(){
	   return name;
   }
}

        1.2.2 工厂角色(SimpleFactory：产生Pizza)

package factory.simple.pizzaFactory;
//工厂角色
public class SimpleFactory {
	 
	public Pizza createPizza(String type) {
		Pizza pizza = null;
 
		if (type.equals("cheese")) {
			pizza = new CheesePizza();
		} else if (type.equals("pepperoni")) {
			pizza = new PepperoniPizza();
		} else if (type.equals("Greek")) {
			pizza = new GreekPizza();
		} else if (type.equals("clam")) {
			pizza = new ClamPizza();
		} else if (type.equals("veggie")) {
			pizza = new VeggiePizza();
		}
		return pizza;
	}
}

        1.2.3 具体产品角色(CheesePizza、ClamPizza、GreekPizza、PepperoniPizza、VeggiePizza)

package factory.simple.pizzaFactory;
//具体产品类
public class CheesePizza extends Pizza {
	public void prepare(){
		   System.out.println("Cheese比萨原材料正在准备中....");
	   }
	   public void bake(){
		   System.out.println("Cheese比萨正在焙烤中....");
	   }
	   public void cut(){
		   System.out.println("Cheese比萨，切块中....");
	   }
	   public void box(){
		   System.out.println("Cheese比萨，正在打包....");
	   }

}

package factory.simple.pizzaFactory;
//具体产品类
public class ClamPizza extends Pizza {
	public void prepare(){
		   System.out.println("Clam比萨原材料正在准备中....");
	   }
	   public void bake(){
		   System.out.println("Clam比萨正在焙烤中....");
	   }
	   public void cut(){
		   System.out.println("Clam比萨，切块中....");
	   }
	   public void box(){
		   System.out.println("Clam比萨，正在打包....");
	   }

}

package factory.simple.pizzaFactory;
//具体产品类
public class GreekPizza extends Pizza {

	public void prepare(){
		   System.out.println("Greek比萨原材料正在准备中....");
	   }
	   public void bake(){
		   System.out.println("Greek比萨正在焙烤中....");
	   }
	   public void cut(){
		   System.out.println("Greek比萨，切块中....");
	   }
	   public void box(){
		   System.out.println("Greek比萨，正在打包....");
	   }

}

package factory.simple.pizzaFactory;
//具体产品类
public class PepperoniPizza extends Pizza {
	public void prepare(){
		   System.out.println("Pepperoni比萨原材料正在准备中....");
	   }
	   public void bake(){
		   System.out.println("Pepperoni比萨正在焙烤中....");
	   }
	   public void cut(){
		   System.out.println("Pepperoni比萨，切块中....");
	   }
	   public void box(){
		   System.out.println("Pepperoni比萨，正在打包....");
	   }

}

package factory.simple.pizzaFactory;
//具体产品类
public class VeggiePizza extends Pizza {
	public void prepare(){
		   System.out.println("Veggie比萨原材料正在准备中....");
	   }
	   public void bake(){
		   System.out.println("Veggie比萨正在焙烤中....");
	   }
	   public void cut(){
		   System.out.println("Veggie比萨，切块中....");
	   }
	   public void box(){
		   System.out.println("Veggie比萨，正在打包....");
	   }
}

        1.2.4 客户端类（PizzaStore：产生Pizza）

package factory.simple.pizzaFactory;
//客户端，取得Pizza
public class PizzaStore {
	SimpleFactory  sf;
	public PizzaStore(SimpleFactory sf) {
		super();
		this.sf = sf;
	}
	Pizza orderPizza(String name){  
		   Pizza pizza=sf.createPizza(name);	  	  
		   pizza.prepare();
		   pizza.bake();
		   pizza.cut();
		   pizza.box();
		   return pizza;
	   }
	
}

        1.2.5 main方法实现简单工厂模式(Test)

package factory.simple.pizzaFactory;
import factory.simple.pizzaFactory.PizzaStore;
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SimpleFactory sf=new SimpleFactory();//创建一个披萨工厂
		PizzaStore store=new PizzaStore(sf);//产生披萨制作商店
		store.orderPizza("cheese");//点餐
	}
}

        1.2.6 UML图 

1.3 代码结构

二、工厂方法模式

2.1 工厂方法模式概述

        工厂方法模式的定义-意图：一个用于创建对象的接口，让子类“决定”实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。“决定”并不是模式允许子类本身再运行时做决定，而是指再编写创建者类时，不需要知道实际创建的产品时哪一个。(类创建型模式)

        工厂方法模式简称工厂模式、虚拟构造器模式、多态工厂模式。其中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象。目的是：将产品类的实例化操作延迟到工厂类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

• 工厂方法模式优缺点：
  • 优点：
    • 1.工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节；
    • 2.能够让工厂自主确定创建这个对象的细节则完全封装在具体工厂内部。3.在系统中加入新产品时，完全符合开闭原则。
  • 缺点：
    • 1.系统中类的个数将成为对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销；
    • 2.增加了系统的抽象性和理解难度。
• 适用环境：
  • 1.客户端不知道它所需要的对象的类(客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体产品对象由具体工厂类创建。)
  • 2.抽象工厂类通过其子类来指定创建哪个对象。

2.2 代码实现

        工厂方法模式包含四个角色：

• 抽象产品(Product)：定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口；
• 具体产品类(Concreteproduct)：具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应；
• 抽象工厂类(Factory)：声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口；(类似工厂总部)
• 具体工厂类(Concretefactory)：抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。(类似各个子工厂)

        2.2.1 抽象产品类(Pizza)

package factory.factorymethod.pizza;
import java.util.ArrayList;
//抽象产品类：披萨
public abstract class Pizza {
	String name;
	String dough;//面团
	String sauce;//酱料
	//下行代码就是得到不同店的佐料制作方式
	ArrayList toppings=new ArrayList();//佐料
  public void prepare(){
	 System.out.println("preparing "+ name); 
	 System.out.println("Tossing dough... "); 
	 System.out.println("adding sauce... "); 
	//选择不同店的佐料制作方式
	for (int i=0;i<toppings.size();i++)
		System.out.println(" "+toppings.get(i));
	}
   public  void bake(){
	   System.out.println("Bake for 25minutes at 350"); }
   public  void cut(){
	   System.out.println("cutting the pizza"); }
   public  void box(){
	   System.out.println("place pizza in officical Pizza box");}
   public String getName(){
	   return name;
   }
}

        2.2.2 具体产品类(ChicagoCheesePizza、ChicagoPepperoniPizza、NYCheesePizza、NYPepperoniPizza)

package factory.factorymethod.pizza;
//具体产品类：芝加哥cheese披萨
public class ChicagoCheesePizza extends Pizza {
	public ChicagoCheesePizza() {
		name="ChicagoCheesePizza";
		dough="Chicago style 面团";
		sauce="Chicago style 酱汁";
		toppings.add("NYCheesePizzaChicagoCheesePizza");
	}
}

package factory.factorymethod.pizza;
//具体产品类：芝加哥Pepperoni披萨
public class ChicagoPepperoniPizza extends Pizza {
	public ChicagoPepperoniPizza() {
		name="ChicagoPepperoniPizza";
		dough="Chicago style 面团";
		sauce="Chicago style 酱汁";
		toppings.add("Chicago style PepperoniPizza");
	}
 
}

package factory.factorymethod.pizza;
//具体产品类：纽约Cheese披萨
public class NYCheesePizza extends Pizza {
	public NYCheesePizza() {
		name="NYCheesePizza";
		dough="NY style 面团";
		sauce="NY style 酱汁";
		toppings.add("NYCheesePizza");
	}
}

package factory.factorymethod.pizza;
//具体产品类：纽约Pepperoni披萨
public class NYPepperoniPizza extends Pizza {
	public NYPepperoniPizza() {
		name="NYPepperoniPizza";
		dough="NY style 面团";
		sauce="NY style 酱汁";
		toppings.add("NYPepperoniPizza");
	}
}

        2.2.3 抽象工厂类(PizzaStore)

package factory.factorymethod.pizza;
//抽象工厂类：披萨商店(总部)
public abstract class PizzaStore {	
	public final Pizza orderPizza(String name){  
		// 把创建Pizza从工厂中移回来 
		Pizza pizza=createPizza(name);	  	  
		   pizza.prepare();
		   pizza.bake();
		   pizza.cut();
		   pizza.box();
		   return pizza;
	   }
	public abstract Pizza createPizza(String name);
}

        2.2.4 具体工厂类(ChicagoPizzaStore、NYPizzaStore)

package factory.factorymethod.pizza;
//具体工厂类：芝加哥披萨店
public class ChicagoPizzaStore extends PizzaStore {

	@Override
	public Pizza createPizza(String name) {
		 Pizza pizza=null;
		   if(name.equals("cheese"))
			   pizza=new ChicagoCheesePizza();
		   
		   else if(name.equals("pepperoni"))
			   pizza=new ChicagoPepperoniPizza();
		   
		  return pizza;
	}

}

package factory.factorymethod.pizza;
//具体工厂类：纽约披萨店
public class NYPizzaStore extends PizzaStore {
	@Override
	public Pizza createPizza(String name) {
		 Pizza pizza=null;
		   if(name.equals("cheese"))
			   pizza=new NYCheesePizza();		   
		   else if(name.equals("pepperoni"))
			   pizza=new NYPepperoniPizza();	   
		  return pizza;
	}
}

        2.2.5 main方法实现工厂方法模式(Test)

package factory.factorymethod.pizza;

public class Test {
	public static void main(String[] args) {
		NYPizzaStore ns=new NYPizzaStore();
		ns.orderPizza("cheese");
		ChicagoPizzaStore cs=new ChicagoPizzaStore();
		cs.orderPizza("cheese");
	}
}

        2.2.6 UML图

2.3 代码结构