设计模式，是指解决某一类问题最行之有效的方法。
1、单例设计模式
单例设计模式，解决一个类在内存中只有一个对象。


想要保证对象唯一。
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本来中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现？
1、将构造方法私有化。
2、在类中创建一个本类对象
3、提供一个方法可以获取到该类对象。

单例设计模式有两种方式，饿汉式和懒汉式。

1. //饿汉式，类加载时就进行创建单例对象

复制代码

建议使用饿汉式。

1. //懒汉式，延迟加载，线程不安全

复制代码

为了解决线程安全问题，使用双重判断并加锁

1. class Single{
   
2.         int num;
   
3.         private static Single s=null;
   
4.         private Single(){}
   
5.         public static Single getInstance(){
   
6.                 if(s==null)
   
7.                         synchronized(Single.class){
   
8.                                 if(s==null)
   
9.                                         return s=new Single();
   
10.                         }
    
11.                 return s;
    
12.         }
    
13.         public void setNum(int num){
    
14.                 this.num=num;
    
15.         }
    
16.         public int getNum(){
    
17.                 return num;
    
18.         }
    
19. }
    
20. 
    
21. public class Sunday{
    
22.         public static void main(String[] args){
    
23.                 Single ss=Single.getInstance();
    
24.                 Single s=Single.getInstance();
    
25.                 ss.setNum(10);
    
26.                 System.out.println(s.getNum());
    
27.         }
    
28. }

复制代码

饿汉式

1. class Single{
   
2.         int num;
   
3.         private Single(){}
   
4.         private static Single s=new Single();
   
5.         public static Single getInstance(){
   
6.                 return s;
   
7.         }
   
8.         public void setNum(int num){
   
9.                 this.num=num;
   
10.         }
    
11.         public int getNum(){
    
12.                 return num;
    
13.         }
    
14. }
    
15. public class Sunday{
    
16.         public static void main(String[] args){
    
17.                 Single ss=Single.getInstance();
    
18.                 Single s=Single.getInstance();
    
19.                 ss.setNum(10);
    
20.                 System.out.println(s.getNum());
    
21.         }
    
22. }

复制代码

wisely 发表于 2014-7-21 22:31
饿汉式

懒汉式

1. class Single{
   
2.         int num;
   
3.         private static Single s=null;
   
4.         private Single(){}
   
5.         public static Single getInstance(){
   
6.                 if(s==null)
   
7.                         return s=new Single();
   
8.                 return s;
   
9.         }
   
10.         public void setNum(int num){
    
11.                 this.num=num;
    
12.         }
    
13.         public int getNum(){
    
14.                 return num;
    
15.         }
    
16. }
    
17. 
    
18. public class Sunday{
    
19.         public static void main(String[] args){
    
20.                 Single ss=Single.getInstance();
    
21.                 Single s=Single.getInstance();
    
22.                 ss.setNum(10);
    
23.                 System.out.println(s.getNum());
    
24.         }
    
25. }

复制代码

好,定时来看看!!

class Single{
        int num;
        private static Single s=null;
        private Single(){}
        public static Single getInstance(){
                if(s==null)
                        return s=new Single();
                return s;
        }
        public void setNum(int num){
                this.num=num;
        }
        public int getNum(){
                return num;
        }
}

public class Sunday{
        public static void main(String[] args){
                Single ss=Single.getInstance();
                Single s=Single.getInstance();
                ss.setNum(10);
                System.out.println(s.getNum());
        }
}

好整理，我还没看到那块

wisely 发表于 2014-7-21 22:31
饿汉式

2、模板设计模式
模板设计模式，在定义功能时，功能的一部分是确定的(如下面的getTime中除runcode外的部分)，但有一部分功能是不确定的(如runcode)，而确定的部分在使用不确定的部分，那么这时就要将不确定的部分暴露出去，由该类的子类去完成。

1. 
   
2. abstract class GetTime{
   
3.         public final void getTime(){    //加final，此方法不希望被复写
   
4.                 long start=System.currentTimeMillis();
   
5.                 runcode();
   
6.                 long end=System.currentTimeMillis();
   
7.                 System.out.println("运行时间为"+(end-start)+"毫秒");
   
8.         }
   
9.         public abstract void runcode();
   
10. }
    
11. 
    
12. class SubTime extends GetTime{
    
13.         public void runcode(){
    
14.                 for(int i=0;i<1000;i++){
    
15.                         System.out.print(i);
    
16.                 }
    
17.         }
    
18. }
    
19. 
    
20. public class Sunday{
    
21.         public static void main(String[] args){
    
22.                 SubTime gt=new SubTime();
    
23.                 gt.getTime();
    
24.         }
    
25. }

复制代码

注意：runcode()方法不一定必须是抽象的。

说是32种，有的总结了

357016138 发表于 2014-7-22 18:35
说是32种，有的总结了

可能是23种，慢慢搞吧

学习了，呵呵

357016138 发表于 2014-7-22 18:35
说是32种，有的总结了

23吧好像