应用最广泛的模式-工厂方法模式

1、工厂方法模式的定义：

定义一个用于创建对象的接口，让子类决定实例化哪个类。

 1 /**抽象产品类**/
 2 
 3 public  abstract class Product{
 4 
 5 //产品类的抽象方法
 6 
 7 //由具体的产品类去实现
 8 
 9 public abstract void method();
10 
11 }
 1 /**具体产品类A**/
 2 
 3 public class ConcreteProductA extends Product{
 4 
 5 @Override
 6 
 7 public void method(){
 8 
 9 System.out.println(“我是具体的产品A”);
10 
11 }
12 
13 }
 1 /**具体产品类B**/
 2 
 3 public class ConcreteProductB extends Product{
 4 
 5 @Override
 6 
 7 public void method(){
 8 
 9 System.out.println(“我是具体的产品B”);
10 
11 }
12 
13 }
 1 /**抽象工厂类**/
 2 
 3 public abstract class Factory{
 4 
 5 //抽象工厂方法
 6 
 7 //具体生产什么由子类去实现
 8 
 9 //@return 具体的产品对象
10 
11 public abstract Product createProduct();
12 
13 }
 1 /**具体工厂类**/
 2 
 3 public class ConcreteFactory extends Factory{
 4 
 5 @Override
 6 
 7 public Product createProduct(){
 8 
 9 return new ConcreteProductA();
10 
11 }
12 
13 }
 1 /**客户类**/
 2 
 3 public class Client{
 4 
 5 public static void main(String[] args){
 6 
 7 Factory factory = new ConcreteFactory();
 8 
 9 Product p = factory.createProduct();
10 
11 p.method();
12 
13 }
14 
15 }

 

2、通过反射的方式更简洁地来生产具体产品对象：

 1 /**抽象工厂类**/
 2 
 3 public abstract class Factory{
 4 
 5 //抽象工厂方法
 6 
 7 //具体生产什么由子类去实现
 8 
 9 //@param clz 产品对象类类型
10 
11 //@return 具体的产品对象
12 
13 public abstract <T extends Product> T createProduct(Class<T> clz);
14 
15 }
 1 /**具体工厂类**/
 2 
 3 public class ConcreteFactory extends Factory{
 4 
 5 @Override
 6 
 7 public <T extends Product> T createProduct(Class<T> clz){
 8 
 9 Product p = null;
10 
11 try{
12 
13 p = (Product) Class.forName(clz.getName()).newInstance();
14 
15 }catch(Exception e){
16 
17 e.printStackTrace();
18 
19 }
20 
21 return (T) p;
22 
23 }
24 
25 }
 1 /**客户类**/
 2 
 3 public class Client{
 4 
 5 public static void main(String[] args){
 6 
 7 Factory factory = new ConcreteFactory();
 8 
 9 Product p = factory.createProduct(ConcreteProductB.class);
10 
11 p.method();
12 
13 }
14 
15 }

 

posted @ 2016-06-11 20:34  栗子·无限意志  阅读(287)  评论(0)  编辑  收藏  举报