专栏首页Spring Cloud设计原理Java 设计模式 工厂模式

Java 设计模式 工厂模式

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://louluan.blog.csdn.net/article/details/19021805

话题引入:

对象的创建和生成 

        在我们需要创建一个对象时,可以通过各种方式。

         最直接的方式莫过于new 了。另外也可以通过Class对象的newInstance(),以及 Constructor.newInstance(Class<?> ... args);进行创建。

1 public  class ClassName{
 2   // The defintions of this class goes there.
 3 }
 4 
 5 // 通过new 创建
 6 ClassName  instance = new ClassName();
 7 
 8 
 9 // 通过newInstance创建
10 ClassName  Instance = Class.forName("...ClassName").newInstance();
11 ClassName Instance = ClassName.class.getDeclaredConstructor(Class<?> ... args);
12 
13 //通过已经存在的对象的clone()方法
14 
15 ClassName newInstance = oldInstance.clone();
16 
17 // 通过序列化创建,原理是将当前存在某个对象序列化编程字节码。然后在另外一个地方读取,并构建成对象。
18 
19 // 略

           另外,当我们进行创建对象的时候,尤其是有用父类引用子类对象的时候,我们都要明确我们确定使用哪个子类的定义和实例化的方式,着无疑加重了开发者的负担:要使用一个东西,还必须要充分了解一个东西,这样是不是很烦呢???

            比如说,一个人写了一个类,并且规定了类的很多实例化时的规则,当另一个开发者想使用它的时候,还要去阅读相应的文档………………

            这时候我们会抱怨:什么乱七八糟的东西都要我看,都要懂,真烦; 在开发的过程中,我们总希望把我们的注意力放在关键的部分,即业务部分。我们只希望需要哪一个对象的时候,能够很方便的提供给我就行了。嗯,要有一个工厂

就好了,专门造这些东西,造好直接给我就行了。

1.简单工厂模式(Simple Factory Pattern)

           举个例子吧,我现在想要一个 iPhone 品牌 的手机 ,现有一个生产手机的的工厂,我们要告诉工厂,“我要一个iPhone” 品牌的手机“。

1 public class Client {
2     public static void main(String[] args) {
3     
4         PhoneFactory foxconn = new Foxconn();
5         Phone iPhone = foxconn.produce("iPhone");
6         Phone blackBerry= foxconn.produce("BlackBerry");    7 }
1 //Phone 抽象类
 2 class Phone{
 3        //...
 4        
 5        // 打电话
 6        public abstract void call(String cardNo);
 7         // 上网
 8        public abstract void browse();
 9        // 玩游戏
10      public absctract void playGames();
11 
12 }
13 
14 // 手机工厂抽象类
15 interface PhoneFactory {
16                  public absctract Phone produce(String brand);
17 }
18 
19 //iPhone 类
20 public class IPhone implements Phone {
21 
22     @Override
23     public void playGames() {
24         System.out.println("Using iphone playing games, so good.");
25     }
26 
27     @Override
28     public void browse() {
29         System.out.println("Surfing Internet.");
30     }
31 
32     @Override
33     public void call(String number) {
34         System.out.println("Hello,"+number);
35     }
36 }
37 
38 
39 // BlackBerry l类
40 public class BlackBerry implements Phone{
41 
42     @Override
43     public void call(String number) {
44 
45         System.out.println("BlackBerry is calling "+number);
46     }
47 
48     @Override
49     public void playGames() {
50         System.out.println("Playing push box...");
51     }
52 
53     @Override
54     public void browse() {
55 
56         System.out.println("Browsing the Internet Page.");
57         
58     }
59 
60 }
61 
62 
63 // 工厂实现类 
64 public class Foxconn implements PhoneFactory{
65     @Override 
66     public Phone produce(String brand)
67     {
68         
69         if(brand=="iPhone")
70         {
71             return new IPhone();
72         }
73         else if (brand ==  "BlackBerry")
74         {
75             return new BlackBerry();
76         }
77         else
78         {
79             System.out.println("My factory can't produce it.");
80         }        
81         return null;
82     }
83 }

       上面的创建的工厂,这就是所谓的 简单工厂模式Simple Factory Pattern)。

2. 工厂方法模式(Factory Method Pattern)

       随着科技的进步,以后出现了另一款很牛的手机,叫xPhone,我想要一个,这时,着个工厂已经不能满足我了:因为这个工厂不能生产此手机!

       想让他给我生产这一款手机,他们工厂就要进行大整改,在 他们的produce(String brand)内部进行修改代码,以支持我的功能。

1 public class Foxconn  implements PhoneFactory {
 2     @Override 
 3     public Phone produce(String brand)
 4     {
 5         
 6         if(brand=="iPhone")
 7         {
 8             return new IPhone();
 9         }
10         else if (brand ==  "BlackBerry")
11         {
12             return new BlackBerry();
13         }
14         else if (brand == "xPhone")
15         {
16             return new XPhone();
17         }
18         else
19         {
20             System.out.println("My factory can't produce it.");
21         }
22         return null;
23     }
24     
25 }

           每次小的需求就令他们做这么大的整改,呵呵,等着倒闭吧。

           这里,工厂把所有的实现都放在了一起,可以这么理解,工厂就一个大杂烩,一个作坊;如果我们把这个大杂烩分开,分清每个部门,是功能细化,生产IPhone 的是IPhone部,生产BlackBerry 的是BlackBerry部,他们部门互不影响,如果要新生产一款手机 xPhone, 则可以在不影响当前其他部门的情况下,新增一个 xPhone部门专门负责 。

           我们开发出来的东西,要力争在结构上作尽量小的整改,增加其拓展性。当前的这个工厂,我们把所有的处理和逻辑全部交给了produce() 方法,所以每次有新的需求都要进行更改,破坏其结构,所以,我们尝试把这个方法的功能分开,工厂变为下面的结构:

1 // 功能分开和细化,相互之间无影响
 2 public interface  PhoneFactory{
 3     public abstract  Phone produceIPhone();
 4     public abstract  Phone produceBlackBerry();    
 5 }
 6 
 7 public class Foxconn implements PhoneFactory{
 8 
 9     @Override
10     public Phone produceIPhone() {
11         return new IPhone();
12     }
13 
14     @Override
15     public Phone produceBlackBerry() {
16         return new BlackBerry();
17     }
18     
19 }

             现在我们 在现有工厂的基础上,增加一个XPhone部门:

1 // 新增一个部门生产 XPhone
 2 public interface  Phone1Factory extends PhoneFactory {
 3     public abstract  Phone produceXPhone();    
 4 }
 5 
 6 // 工厂实现类
 7 public class Foxconn1 extends Foxconn implements Phone1Factory{
 8 
 9     @Override
10     public Phone produceXPhone(){
11         return new XPhone();
12     }
13     
14 }

              这样,在不破坏以前代码结构的基础上,都当前代码进行扩展。

              也就是说,当有新的要求提出时,我们通过给工厂增加部门的形式给出(即这里的方法),这种拓展性非常好!

             上面的描述便是 工厂方法模式(Factory Method Pattern)。

              工厂方法模式 扩展性非常好,但是拓展性带来了一个新的问题,拓展性增加了我们系统里类的数量和规模,这使我们的系统异常庞大!

只要有新的生产要求提出,都会有新的方法添加。就好比 每让一个工厂给你新类型的产品,就得新建一个新的部门予以支持,这样的代价也是相当大的。

3. 抽象工厂模式

             举个实际的例子,IPhone 现在 5S 刚出来,我现在要工厂给我造出来,那工厂自然提供一个部门给我造,那以后IPhone 的后续还会推出各种新的 款式.....我们发现,IPhone 是一个系列,无论它是几S 终究是IPhone ,我们可以告诉IPhone的部门,我们要几S就够了,这样子 便可以减少我们部门的规模了!

现在我们对 上述的类进行整改:

1 // Phone工厂抽象类
 2 public interface PhoneFactory {
 3     public abstract  Phone produceIPhone(String version);
 4     public abstract  Phone produceBlackBerry(String version);
 5 }
 6 
 7 class Foxconn implements PhoneFactory {
 8 
 9     @Override
10     public Phone produceIPhone(String version) {
11         if(version.equals("4"))
12         {
13                return new IPhone4();
14         }
15         else if(version.equals("4S"))
16         {
17               return new IPhone4S();
18         }
19         else
20         {
21             //........
22         }
23             
24     }
25 
26     @Override
27     public Phone produceBlackBerry(String version) {
28         // TODO Auto-generated method stub
29         return null;
30     }
31 }
32 
33 // Phone工厂抽象类
34 public interface Phone1Factory extends PhoneFactory {
35       public abstract  Phone produceXPhone(String version);
37 }
38 
39 class Foxconn1  extends Foxconn implements  PhoneFactory {
40 
41     @Override
42     public Phone produceXPhone(String version) {
43         if(version.equals("X1"))
44         {
45                return new XPhoneX1();
46         }
47         else if(version.equals("X2"))
48         {
49               return new XPhoneX2();
50         }
51         else
52         {
53             //........
54         }
55             
56     }
57 }

这样的方式便是扩展性和规模和复杂度的一个中和。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java 设计模式 代理模式

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://louluan.blog.c...

    亦山
  • Java 设计模式 适配器模式

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://louluan.blog.c...

    亦山
  • Java 设计模式 装饰者模式

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://louluan.blo...

    亦山
  • RPC编程

    RPC全称Remote Procedure Call,即远程方法调用。它的表现形式是:

    小蜜蜂
  • 强烈推荐:基于Java反射实现一个 Android ORM 框架

    今天给大家推荐一个不错的开源项目代码,作者利用反射机制实现了数据库的 ORM 框架。希望大家读了之后能够从中学习作者的思路和思想。再重复一遍,学习一下作者的思路...

    非著名程序员
  • 基于Java反射实现Android的ORM框架1. 框架设计2. 内部实现的几个重要实现规则3. 代码实现

    导语: Java反射机制是一个很好用的东西。反射机制可以帮我们做那些重复的有规则的事情,所以现在很多的自动生成代码的软件就是运用反射机制来完成的。这里重复造个...

    MelonTeam
  • Collections.synchronizedMap()、ConcurrentHashMap、Hashtable之间的区别

    Tanyboye
  • RxJava小考题 -- Rxjava源码分析(一)

    现在面试很多都会问RxJava的源码,直接讲RxJava的源码,估计大家都不太会看下去,我们先看个小考题,然后再去看相关的源码。

    青蛙要fly
  • 多线程之并发工具类

    在开发过程中经常会碰到一个任务需要开启多个线程,然后将多个线程的执行结果汇总。比如说查询全量数据,考虑数据量的问题,我们基本上会做分页,这时候就需要多次循环调用...

    OPice
  • 桥接模式详解

    桥接(Bridge)模式的定义如下:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。 具体...

    提莫队长

扫码关注云+社区

领取腾讯云代金券