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，准备吃饭了。。。。。