标签：return Factory static Transportation Logger 设计模式 public

什么是工厂模式？

工厂模式（Factory Pattern）在实际开发中非常常见，它可以由用户决定创建对象的类型。

因为工厂模式，我们无需向客户暴露我们的代码逻辑，只需要开放接口给客户，由客户指定要创建的对象的类型，便可以动态生成符合需求的类别对象。

什么场合用工厂模式？

需要根据实际情况才能决定创建何种类别对象的场景。

听起来挺悬乎的，其实很容易理解。

假设，你要从广州到深圳，你就需要交通工具。

选择可就多了，有大巴，有火车，有高铁，有动车，未来还有地铁和城轨。

你在不同时刻有不同的选择。

比较，你是土豪，你还可以坐飞机。

你不想转车，可能直接大巴。

你要便宜点，你可以坐火车。

干净舒适时，你可以选择高铁。

下面，实例讲解。

工厂模式的实现手段

交通工具可以是一个抽奖类，也可以是一个接口。

所以，我们定义一个接口代表交通工具，之后把大巴、火车、飞机实现这个接口，UML 图如下。

我们再编写工厂类。

我们通过 TransportationFactory 这个类中的 getTransportation() 方法就可以创建类了。

下面是 Java 代码示意：

 

Transportation.java

 

[plain] view plaincopy  

1. public interface Transportation {  
2. void move(String dst);  
3. }  

再实现 Bus、Train、Plane

Bus.java

[plain] view plaincopy  

1. public class  Bus  implements Transportation{  
2.   
3. @Override  
4. public void move(String dst) {  
5. // TODO Auto-generated method stub  
6. System.out.println("Take a bus to "+dst);  
7. }  
8. }  

Train.java

[plain] view plaincopy  

1. public class  Train  implements Transportation{  
2.   
3. @Override  
4. public void move(String dst) {  
5. // TODO Auto-generated method stub  
6. System.out.println("Take a train to "+dst);  
7. }  
8. }  

Plane.java

[plain] view plaincopy  

1. public class  Plane  implements Transportation{  
2.   
3. @Override  
4. public void move(String dst) {  
5. // TODO Auto-generated method stub  
6. System.out.println("Take a plane to "+dst);  
7. }  
8. }  

然后，我们实现工厂类

Transportation.java

[plain] view plaincopy  

1. public class TranportationFactory {  
2.   
3. public Transportation getTransportation(String type){  
4. if(type == null){  
5. return null;  
6. }  
7. if(type.equalsIgnoreCase("TRAIN")){  
8. return new Train();  
9. } else if(type.equalsIgnoreCase("BUS")){  
10. return new Bus();  
11. } else if(type.equalsIgnoreCase("PLANE")){  
12. return new Plane();  
13. }  
14. return null;  
15. }  
16.   
17. }  

可以看到，工厂类根据 type 的不同，选择创建不同的类别对象。

最后，编写测试代码。
FactoryDemo.java

[plain] view plaincopy  

1. public class FactoryDemo {  
2.   
3. public static void main(String[] args) {  
4.   
5. TranportationFactory factory = new TranportationFactory();  
6.   
7. //Transportation transportation = factory.getTransportation("bus");  
8. Transportation transportation = factory.getTransportation("train");  
9. // Transportation transportation = factory.getTransportation("plane");  
10.   
11. transportation.move("深圳");  
12. }  
13.   
14. }  

最终，打印结果如下：

Take a train to 深圳

我们可以看到，通过简单的例子，我们掌握了工厂模式的基础方法，下面通过实际的源码例子加深理解。

Android 源码中的工厂模式

 

xref: /packages/apps/Camera2/src/com/android/camera/debug/Logger.java

 

[plain] view plaincopy  

1. public interface Logger {  
2.   
3. ......  
4.   
5. /** 
6. * Provides a Logger instance from a given Log tag. 
7. */  
8. public interface Factory {  
9. public Logger create(Tag tag);  
10. }  
11. }  

这是 Android 系统应用相机的一份代码，主要是记录 Log 的，但它是一个接口，说明这个应用中有不同的 Logger，并且里面还有一个接口 Factory，通过传入 Tag 可以生成不同的 Logger。

经查询 Logger 有 2 种实现类，TagLogger 和 NoOpLogger,它们的代码在 Loggers.java 中。

因为篇幅所限，这里只讨论 TagLogger。

xref: /packages/apps/Camera2/src/com/android/camera/debug/Loggers.java

[plain] view plaincopy  

1. public class Loggers {  
2.   
3. /** 
4. * This creates a factory that will use the standard android static log 
5. * methods. 
6. */  
7. public static Logger.Factory tagFactory() {  
8. return TagLoggerFactory.instance();  
9. }  
10.   
11. /** 
12. * Creates a logger factory which always returns the given logger. 
13. */  
14. public static Logger.Factory factoryFor(final Logger logger) {  
15. return new Logger.Factory() {  
16. @Override  
17. public Logger create(Tag tag) {  
18. return logger;  
19. }  
20. };  
21. }  
22.   
23. /** 
24. * Creates loggers that use tag objects to write to standard android log 
25. * output. 
26. */  
27. private static class TagLoggerFactory implements Logger.Factory {  
28. private static class Singleton {  
29. private static final TagLoggerFactory INSTANCE = new TagLoggerFactory();  
30. }  
31.   
32. public static TagLoggerFactory instance() {  
33. return Singleton.INSTANCE;  
34. }  
35.   
36. @Override  
37. public Logger create(Tag tag) {  
38. return new TagLogger(tag);  
39. }  
40. }  
41.   
42. /** 
43. * TagLogger logger writes to the standard static log output with the given 
44. * tag object. 
45. */  
46. private static class TagLogger implements Logger {  
47. private final Log.Tag mTag;  
48.   
49. public TagLogger(Log.Tag tag) {  
50. mTag = tag;  
51. }  
52. ...  
53.   
54. }  
55. }  

很惊喜的是，这个例子也可以用来解释单例模式。

TagLogger.Factory 中的 create 方法可以创建 TaggLogger。

所以，从入口方法

factoryFor()就可以决定不同的 Factory,不同的 Factory 就创建了不同的 Logger。

 

这显然是工厂模式。

标签：return,Factory,static,Transportation,Logger,设计模式,public
来源： https://www.cnblogs.com/cuimian/p/13940786.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。