设计模式（二）：工厂模式

一.工厂模式的定义：　　　　

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

　　　　由产品工厂（接口）规定规范，由产品子类进行实现，当增加产品时，只需要扩展一个新的类去实现这个接口，并由客户端向上转型调用。

 

二.例子类图表示

 

 fruitFactory:定义了一个水果工厂的接口，并提供一些公共的方法体，供子类实现自己的内容。

fruit：定义了一个方法，使子类实现一个方法设置水果名。

waterlemonFactory、orangeFactory：属于fruitFactory接口的实现类，用于实现各自的功能。

orange、waterlemon：属于fruit的实现类。

 

三.基本代码演示

interface：

 1 package com.cllover.factory;
 2 
 3 /*
 4 * 水果的规范
 5 * */
 6 public interface fruit {
 7 
 8     //定义水果的名字   
 9     public void name();
10 }

fruit

 1 package com.cllover.factory;
 2 
 3 /*
 4 * 食品工厂：定义生产的水果的规范
 5 * */
 6 public interface fruitFactory {
 7 
 8     //什么味道
 9     public void teste();
10     //什么颜色
11     public void color();
12     //上交什么水沟工厂
13     public fruit upSubfruit();
14 }

fruitFactory

 

 implements fruitFactory：

 1 package com.cllover.factory;
 2 
 3 /*
 4 * 收到规范后并在自己的工厂进行生产
 5 * */
 6 public class OrangeFactory implements fruitFactory {
 7 
 8 
 9 
10     @Override
11     public void teste() {
12         System.out.println("OrangeFactory:-->我尝起来酸甜可口。。。");
13     }
14 
15     @Override
16     public void color() {
17         System.out.println("OrangeFactory:-->我以橙色没主。。。");
18     }
19 
20     @Override
21     public fruit upSubfruit() {
22         System.out.println("OrangeFactory:-->orange生产完成上交工厂");
23         return new Orange();
24     }
25 
26 
27 
28 }

OrangeFactory

 1 package com.cllover.factory;
 2 
 3 /*
 4 *   遵从工厂的决定生产自己的产品
 5 * */
 6 public class WatermelonFactory implements fruitFactory {
 7 
 8     @Override
 9     public void teste() {
10         System.out.println("WatermelonFactory:-->我吃起来非常甜。。。");
11     }
12 
13     @Override
14     public void color() {
15         System.out.println("WatermelonFactory:-->我的颜色很复杂。。。");
16     }
17 
18     @Override
19     public fruit upSubfruit() {
20         System.out.println( "WatermelonFactory:-->Watermelon生产完成上交工厂");
21         return new Watermelon();
22     }
23 
24 }

WatermelonFactory

 

implements fruit:

1 package com.cllover.factory;
2 
3 public class Orange implements fruit {
4     @Override
5     public void name() {
6 
7         System.out.println("Orange:-->我是橘子。。。");
8     }
9 }

Orange

1 package com.cllover.factory;
2 
3 public class Watermelon implements fruit {
4     @Override
5     public void name() {
6         System.out.println("Watermelon:-->我是西瓜。。。");
7     }
8 }

Watermelon

 

client客户端调用：

 1 package com.cllover.factory;
 2 
 3 import com.sun.org.apache.xpath.internal.operations.Or;
 4 
 5 public class customerClient {
 6     public static void main(String[] args) {
 7 
 8 
 9         //向上转型
10         fruitFactory factory = new OrangeFactory();
11         //调用upSubfruit（）
12         fruit OrangeFruit = factory.upSubfruit();
13         //输出名字
14         OrangeFruit.name();
15         //输出味道
16         factory.teste();
17         //输出色彩
18         factory.color();
19         System.out.println("customerClient:-->我将购买产品并。。。");
20 
21 
22     }
23 }

customerClient

 

 

四.优缺点

对于一个新产品的发布，无需更改其他工厂的代码。只需要新建2个类并去实现去fruitFactory/fruit接口即可。

但是对于一个产品需要增加、改变、删除新的功能来说，需要添加、并且修改和删除在接口中的方法。与此同时，各实现类并会进行相应的添加、修改、删除方法进行实现。也就是说，每当接口中方法出现变动时，变会修改不少代码，

对于不需要经常变化的功能来讲，工厂方法模式具有相应的好处。