JAVA设计模式：单例设计

1.单例设计Singleton的引出

单例设计，从名字上首先可以看出单---即只有一个，例---只的是实例化对象；那么单例也就是说一个类，只产生了一个实例化对象。但是我们都知道，一个类要产生实例化对象很容易，只需要通过new关键字，new出来就可以了，怎么可能一个类只产生一个实例化对象呢，其实试想想，实例化对象的产生有一条必经之路，那就是构造方法。

什么是构造方法，构造方法是类进行实例化对象的必经之路，只有通过构造方法，才能为类的成员进行初始化，并开辟相应的堆空间进行存储。那么接着上面的来说，一个类要只产生一个实例化对象，那就必须控制这个构造方法，如何做？如果我们将这个构造方法用private关键字修饰起来，也就说构造方法私有化，那么在这个类的外部就无法来new出实例化对象了，那就产生了一个类只有一个实例化对象了。具体代码如何实现呢，看下面代码：

 1 package com.huawei.madejin.demo;
 2 
 3 class Singleton
 4 {
 5     private Singleton INSTANCE = new Singleton(); //产生了一个私有化的实例对象 
 6     private Singleton(){}  //构造方法进行了私有化
 7     
 8     
 9     
10     public void print()
11     {
12         System.out.println("Hello World");
13     }
14     
15 }
16 public class SingletonTest {
17 
18     /**
19      * @param args
20      */
21     public static void main(String[] args) {
22         // TODO Auto-generated method stub
23 
24     }
25 
26 }

上面可以看出，产生了一个私有化的实例化对象，但在外部如何去访问这个，或者说获得这个对象呢，显然，如果用普通的方法或者属性，是不行的，因为对于普通方法而言，需要通过实例化对象点方法的形式去访问，但外部是没有这个实例化对象的，那么怎么办？这个时候，就应该想到static的方法，是属于类的方法，不需要实例化对象的时候也可以访问的，即在类中加上static的方法，类中加上static方法之后，静态的方法只能访问静态的属性而不能去访问非静态的属性，所以private Singleton INSTANCE = new Singleton();也应该加上static；既然static已经加上了，那么为了使其更加完整，只有一个实例对象，并且不允许在其内部发生改变，则加上final;就更加完美了，于是形成了单例设计的完整模式。如下所示：

 1 package com.huawei.madejin.demo;
 2 
 3 class Singleton
 4 {
 5     private final static Singleton INSTANCE = new Singleton();
 6     private Singleton(){}
 7     
 8     public static Singleton getInstance()
 9     {
10         return INSTANCE;
11     }
12     
13     public void print()
14     {
15         System.out.println("Hello World");
16     }
17     
18 }
19 public class SingletonTest {
20 
21     /**
22      * @param args
23      */
24     public static void main(String[] args) {
25         // TODO Auto-generated method stub
26         Singleton s = Singleton.getInstance();
27         s.print();
28     }
29 
30 }

然后，在上述单例设计模式的基础上，我们在想想，上述的INSTANCE这个实例化对象，无论你在SingletonTest类中用不用，这个实例化对象都存在，那么如果我需要节省一下空间，让其用的时候，我在产生不是更好，于是产生了改进：

 1 package com.huawei.madejin.demo;
 2 
 3 class Singleton
 4 {
 5     //private final static Singleton INSTANCE = new Singleton();
 6     private static Singleton INSTANCE = null;
 7     private Singleton(){}
 8     
 9     public static Singleton getInstance()
10     {
11         if(INSTANCE == null)
12         {
13             INSTANCE = new Singleton();;
14         }
15         return INSTANCE;
16     }
17     
18     public void print()
19     {
20         System.out.println("Hello World");
21     }
22     
23 }
24 public class SingletonTest {
25 
26     /**
27      * @param args
28      */
29     public static void main(String[] args) {
30         // TODO Auto-generated method stub
31         Singleton s = Singleton.getInstance();
32         s.print();
33     }
34 
35 }

这样就产生了单例设计模式的两种形式：一种就是第一种，称为恶汉方式的单例设计模式，第二种被称为懒汉方式的设计模式。实际开发中，根据情况都可以使用，其实质差不多。

发散思维：

 1 package com.huawei.madejin.demo;
 2 
 3 class Color
 4 {
 5     private String title;
 6     
 7     private final static Color RED = new Color("red");
 8     private final static Color BLUE = new Color("blue");
 9     private final static Color GREEN = new Color("green");
10     
11     public static Color getColor(int i)
12     {
13         switch(i)
14         {
15            default:
16            case 0 :
17                return RED;
18            case 1:
19                return BLUE;
20            case 2:
21                return GREEN;
22         }
23     }
24     private Color(String title){
25         this.title = title;
26     }
27     
28     public String toString(){
29         return this.title;
30     }
31 }
32 
33 public class MultitonTest {
34 
35     /**
36      * @param args
37      */
38     public static void main(String[] args) {
39         // TODO Auto-generated method stub
40         Color c= Color.getColor(1);
41         System.out.println(c.toString());
42     }
43 
44 }