java设计模式_single(单例设计模式)

 1 public class SingleDemo1 {
 2     public static void main(String[] args) {
 3         Single s1 = Single.getInstance();//main函数中有了一个s1引用，获取到了Single对象的地址，指向Single对象
 4     }
 5 }
 6 class Single{
 7     private Single(){}//将构造函数私有化，不让其他程序建立对象
 8 
 9     private static Single s = new Single();//下面的静态方法访问到该对象所以要将该对象也修饰为静态
10     
11     //调用用类名调用，（方法的调用只有两种方式：对象调用和类名调用，这里没对象只能用类名调用，所以要静态）
12     public static Single getInstance(){
13         return s;
14     }
15 }

public class SingleDemo {
    public static void main(String[] args) {
        Singleton1 s = Singleton1.getInstance();
        s.print();
    }
}
/*
          把该类设计成单例设计模式：
              饿汉式
 */
class Singleton1{
    //构造函数私有化
    private Singleton1(){
    
    }
    
    //定义一个本类对象并实例化
    private static Singleton1 s = new Singleton1();
    
    public static Singleton1 getInstance(){
        return s;
    }
    
    public void print(){
        System.out.println("饿汉式——单例设计模式");
    }
}

 1 public class SingleDemo1 {
 2     public static void main(String[] args) {
 3         //Test t1 = new Test();
 4         //Test t2 = new Test();
 5         Test t1 = Test.getInctance();
 6         Test t2 = Test.getInctance();
 7         t1.setNum(10);
 8         t2.setNum(20);
 9         System.out.println(t1.getNum());
10         System.out.println(t2.getNum());//两个打印结果都是20，因为内存中只有一个对象
11     }
12 }
13 class Test{
14     private int num;
15     private static Test t = new Test();
16     private Test(){}
17     public static Test getInctance(){
18         return t;
19     }
20     public void setNum(int num){
21         this.num = num;
22     }
23     public int getNum(){
24         return num;
25     }
26 }

public class SingleDemo {
    public static void main(String[] args) {
        Singleton2 s = Singleton2.getInstance();
        s.print();
    }
}
//懒汉式
class Singleton2{
    private static Singleton2 s = null;
    private Singleton2(){}
    
    public static Singleton2 getInstance(){
        if(s==null){
            s = new Singleton2();
        }
        return s;
    }
    public void print(){
        System.out.println("懒汉式——单例设计模式");
    }
}

 1 public class SingleDemo2 {
 2     public static void main(String[] args) {
 3 
 4     }
 5 
 6 }
 7 class Single{
 8     private static Single s = null;
 9     private Single(){}
10     //synchronized（同步）只要有一个程序进去其他程序就不能进来了，但是这样程序的效率的降低了，执行前需要先判断
11     public static synchronized Single getInstance(){
12         //减少判断锁的次数
13         if (s==null){
14             //最终的解决方案，减少判断的次数，上面那个函数就不用同步了
15             synchronized(Single.class){
16                 if (s==null)
17                     s = new Single();
18             }
19         }
20         return s;
21     }
22 }