JAVA设计模式：单例设计

1.单例设计Singleton的引出

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

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

 package com.huawei.madejin.demo;

 class Singleton
 {
     private Singleton INSTANCE = new Singleton(); //产生了一个私有化的实例对象
     private Singleton(){}  //构造方法进行了私有化

     public void print()
     {
         System.out.println("Hello World");
     }

 }
 public class SingletonTest {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub

     }

 }

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

 package com.huawei.madejin.demo;

 class Singleton
 {
     private final static Singleton INSTANCE = new Singleton();
     private Singleton(){}

     public static Singleton getInstance()
     {
         return INSTANCE;
     }

     public void print()
     {
         System.out.println("Hello World");
     }

 }
 public class SingletonTest {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Singleton s = Singleton.getInstance();
         s.print();
     }

 }

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

 package com.huawei.madejin.demo;

 class Singleton
 {
     //private final static Singleton INSTANCE = new Singleton();
     private static Singleton INSTANCE = null;
     private Singleton(){}

     public static Singleton getInstance()
     {
         if(INSTANCE == null)
         {
             INSTANCE = new Singleton();;
         }
         return INSTANCE;
     }

     public void print()
     {
         System.out.println("Hello World");
     }

 }
 public class SingletonTest {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Singleton s = Singleton.getInstance();
         s.print();
     }

 }

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

发散思维：

 package com.huawei.madejin.demo;

 class Color
 {
     private String title;

     private final static Color RED = new Color("red");
     private final static Color BLUE = new Color("blue");
     private final static Color GREEN = new Color("green");

     public static Color getColor(int i)
     {
         switch(i)
         {
            default:
            case 0 :
                return RED;
            case 1:
                return BLUE;
            case 2:
                return GREEN;
         }
     }
     private Color(String title){
         this.title = title;
     }

     public String toString(){
         return this.title;
     }
 }

 public class MultitonTest {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Color c= Color.getColor(1);
         System.out.println(c.toString());
     }

 }

上述这段代码，为多例设计模式，因为不常用，这里就不讲了.......；(～ o ～)~zZ，准备吃饭了。。。。。