设计模式_工厂设计模式

工厂模式的定义：

Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂模式通用类图：

1.提取出来一个抽象产品类

 1 package cn.rocker.designpattern.factory;
 2 
 3 /**
 4  * @author rocker
 5  * @version V1.0
 6  * @Description:    抽象产品类
 7  * @date 2018/5/6 17:09
 8  */
 9 public abstract class Product {
10     //产品类的公共方法
11     public void method1(){
12         //业务处理逻辑
13     }
14 
15     //抽象方法
16     public abstract void method2();
17 }

2.根据不同需求，实现不同的产品类

 1 package cn.rocker.designpattern.factory;
 2 
 3 /**
 4  * @author rocker
 5  * @version V1.0
 6  * @Description:    产品实现类1
 7  * @date 2018/5/6 17:11
 8  */
 9 public class ConcreteProduct1 extends Product{
10     @Override
11     public void method2() {
12         //业务逻辑处理
13         System.out.println("ConcreteProduct1 is made...");
14     }
15 }

 1 package cn.rocker.designpattern.factory;
 2 
 3 /**
 4  * @author rocker
 5  * @version V1.0
 6  * @Description:    产品实现类2
 7  * @date 2018/5/6 17:12
 8  */
 9 public class ConcreteProduct2 extends Product{
10     @Override
11     public void method2() {
12         //业务处理逻辑
13         System.out.println("ConcreteProduct2 is made...");
14     }
15 }

3.提取出来一个工厂的抽象类

 1 package cn.rocker.designpattern.factory;
 2 
 3 /**
 4  * @author rocker
 5  * @version V1.0
 6  * @Description:    　创建一个产品对象，其实如参数类型可以自行设置
 7  *                    通常为String、Enum、Class等，当然也可以为空
 8  * @date 2018/5/6 17:13
 9  */
10 public abstract class Creator {
11     public abstract <T extends Product> T createProduct(Class<T> c);
12 }

4.根据抽象类，在实现类中，实现具体的生产方法

 1 package cn.rocker.designpattern.factory;
 2 
 3 /**
 4  * @author rocker
 5  * @version V1.0
 6  * @Description:    具体如何生产一个产品的对象，是由具体的工厂类实现的
 7  * @date 2018/5/6 17:33
 8  */
 9 public class ConcreteCreator extends Creator{
10     @Override
11     public <T extends Product> T createProduct(Class<T> c) {
12         Product product = null;
13         try {
14             product = (Product) Class.forName(c.getName()).newInstance();
15         } catch (InstantiationException e) {
16             e.printStackTrace();
17         } catch (IllegalAccessException e) {
18             e.printStackTrace();
19         } catch (ClassNotFoundException e) {
20             e.printStackTrace();
21         }
22         return (T)product;
23     }
24 }

5.在客户端通过操作工厂类，获取具体的产品类

 1 package cn.rocker.designpattern.factory;
 2 
 3 
 4 import org.junit.Test;
 5 
 6 /**
 7  * @author rocker
 8  * @version V1.0
 9  * @Description:    用工厂生产产品
10  * @date 2018/5/6 17:36
11  */
12 public class Client {
13     @Test
14     public void test(){
15         //创建工厂
16         Creator creator = new ConcreteCreator();
17 
18         //生产ConcreteProduct1
19         ConcreteProduct1 product1 = creator.createProduct(ConcreteProduct1.class);
20         product1.method2();
21 
22         //生产ConcreteProduct2
23         ConcreteProduct2 product2 = creator.createProduct(ConcreteProduct2.class);
24         product2.method2();
25     }
26 }