设计模式——工厂方法模式

简单工厂模式

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。

缺点：每次增加一个新的具体产品类（比如新加一个排球类），都得修改工程类的方法增加一个判断，不符合开闭原则（对扩展开放，对修改封闭）

 1 package com.shamgod.factorypattern;
 2 /**
 3  * 简单工厂demo
 4  * @author lct
 5  *
 6  */
 7 public class SimpleFactory {
 8 
 9     public static void main(String[] args) {
10         //创建一个工厂类对象
11         BallFactory ballFactory = new BallFactory();
12         //根据传入的类型创建相应的球对象
13         Ball ball = ballFactory.createBall("basketball");
14         ball.info();//我是一个篮球！
15     }
16 }
17 /*
18  * 工厂类
19  */
20 class BallFactory{
21     /*
22      * 根据不同的传入类型生产不同的球
23      */
24     public Ball createBall(String type) {
25         if ("basketball".equals(type)) {
26             return new BasketBall();
27         }else if ("football".equals(type)) {
28             return new FootBall();
29         }
30         return null;
31     }
32     
33     
34 }
35 /*
36  * 球接口
37  */
38 interface Ball{
39     void info();
40 }
41 /*
42  * 具体的篮球类
43  */
44 class BasketBall implements Ball{
45 
46     @Override
47     public void info() {
48         // TODO Auto-generated method stub
49         System.out.println("我是一个篮球！");
50     }
51 }
52 /*
53  * 具体的足球类
54  */
55 class FootBall implements Ball{
56 
57     @Override
58     public void info() {
59         // TODO Auto-generated method stub
60         System.out.println("我是一个足球！");
61     }
62     
63 }

工厂方法模式：

工厂模式解决了简单工厂中的增加一个产品类要修改工厂类代码的问题。每次新增新的产品，只需要扩展新的产品的工厂类，实现工厂接口就行。

要点：

1）定义创建对象的接口，封装了对象的创建。

2）使得具体化类的工作延迟到了子类中。

 1 package com.shamgod.factorypattern;
 2 /**
 3  * 工厂方法模式
 4  * @author lct
 5  *
 6  */
 7 public class FactoryMethodPattern {
 8     
 9     public static void main(String[] args) {
10         
11         //创建一个篮球工厂
12         Factory basketballFactory = new BasketBallFactory();
13         //篮球工厂生产篮球
14         Ball basketball = basketballFactory.produce();
15         basketball.info();//我是一个篮球
16     }
17 }
18 /*
19  * 抽象的球接口
20  */
21 interface Ball{
22     void info();
23 }
24 /*
25  * 具体的产品类：篮球产品类
26  */
27 class BasketBall implements Ball{
28 
29     @Override
30     public void info() {
31         // TODO Auto-generated method stub
32         System.out.println("我是一个篮球");
33     }
34     
35 }
36 /*
37  * 具体的产品类：足球类
38  */
39 class FootBall implements Ball{
40 
41     @Override
42     public void info() {
43         // TODO Auto-generated method stub
44         System.out.println("我是一个足球");
45     }
46     
47 }
48 /*
49  * 抽象工厂接口
50  */
51 interface Factory{
52     Ball produce();
53 }
54 /*
55  * 具体的实现工厂：篮球工厂
56  */
57 class BasketBallFactory implements Factory{
58 
59     @Override
60     public Ball produce() {
61         // TODO Auto-generated method stub
62         return new BasketBall();
63     }
64     
65 }
66 /*
67  * 具体的实现工厂：足球工厂
68  */
69 class FootBallFactory implements Factory{
70 
71     @Override
72     public Ball produce() {
73         // TODO Auto-generated method stub
74         return new FootBall();
75     }
76     
77 }

设计模式——工厂方法模式

推荐阅读