Java 单例模式，

Java 单例模式，

原文：http://blog.csdn.net/realrealrealrealreal/article/details/40800669

java当中单例模式用得非常的多，那么今天我就讲一讲具体的单例模式把！

废话不多说！直接贴代码：

1.先看第一种单例模式，也是最简单的了：

   很简单，这么想，就是穷屌丝和高富帅的区别，高富帅，一生下来就什么 都有了。

  

[java] view plaincopy

1. package com.lamp.demo;  
2.   
3. /** 
4.  * 单例模式设计思想【这种效率好【因为没加锁】】 
5.  *  
6.  * @author fei 
7.  * @打个比方，高富帅和穷屌丝的区别 
8.  */  
9. public class Singleton2 {  
10.     private static Singleton2 instance = new Singleton2();  
11.   
12.     private Singleton2() {  
13.   
14.     }  
15.   
16.     public static Singleton2 getInstance() {  
17.         return instance;  
18.     }  
19.   
20.     // 加成员方法  
21. }  

2.第二种单例模式，是加了同步代码块的，但是失去了效率：

[java] view plaincopy

1. package com.lamp.demo;  
2.   
3. /** 
4.  * 单例设计模式  线程安全的 
5.  *  
6.  * @author fei 
7.  *  
8.  */  
9. public class Singleton {  
10.     private static Singleton instance;  
11.   
12.     private Singleton() {  
13.   
14.     }  
15.   
16.     // 为了线程安全，加了一把锁，但是失去了效率  
17.     public synchronized static Singleton getSingleton() {  
18.         if (instance == null) {  
19.             instance = new Singleton();  
20.         }  
21.         return instance;  
22.   
23.     }  
24.   
25.     public void sayHello(String string) {  
26.         System.out.println("Hello " + string);  
27.     }  
28.   
29. }  

3.第三种，据说是最牛的！在android中，运用的非常广泛哦，比如一个listview加载一个baseadapter，那么就需要用到这种设计模式。可以有效的提高app的性能。

[java] view plaincopy

1. package com.lamp.demo;  
2.   
3. /** 
4.  * 最牛逼的单例模式 设计者----Bob Lee----【google】 
5.  *  
6.  * @author fei 
7.  * 利用了类的加载机制【】 
8.  */  
9. public class Foo {  
10.       
11.     static class Holder {  
12.         static Foo instance = new Foo();  
13.     }  
14.   
15.     public static Foo getSingleton() {  
16.         return Holder.instance;  
17.     }  
18.   
19.     private Foo() {  
20.         System.out.println("实例化");  
21.     }  
22.   
23.     public static void main(String[] args) {  
24.         Foo foo = Foo.getSingleton();  
25.     }  
26.   
27. }  

那么我们来看一下，安卓中的具体运用把

[java] view plaincopy

1. package com.soul.listview;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.view.View;  
6. import android.view.ViewGroup;  
7. import android.widget.BaseAdapter;  
8. import android.widget.ImageView;  
9. import android.widget.ListView;  
10. import android.widget.TextView;  
11.   
12. //通过适配器加载其他布局组件的listView,并优化性能之  
13. public class MainActivity5 extends Activity {  
14.     private ListView lv;  
15.   
16.     @Override  
17.     protected void onCreate(Bundle savedInstanceState) {  
18.         // TODO Auto-generated method stub  
19.         super.onCreate(savedInstanceState);  
20.         setContentView(R.layout.main5);  
21.   
22.         lv = (ListView) findViewById(R.id.listView1);  
23.         // 通过适配器连接数据组件  
24.         lv.setAdapter(new MyAadapter());  
25.     }  
26.   
27.     // 定义数据  
28.     private int[] images = { R.drawable.ic_launcher, R.drawable.ic_launcher };  
29.     private String[] names = { "小花", "小黄" };  
30.   
31.     // 自定义适配器  
32.     class MyAadapter extends BaseAdapter {  
33.   
34.         // 1.获取列表项的总数  
35.         @Override  
36.         public int getCount() {  
37.             return names.length;  
38.         }  
39.   
40.         // 2.获取每一个列表项【根据位置】  
41.         @Override  
42.         public Object getItem(int position) {  
43.             return names[position];  
44.         }  
45.   
46.         // 3.获取每一个列表项的id【根据位置】  
47.         @Override  
48.         public long getItemId(int position) {  
49.             return position;  
50.         }  
51.   
52.         // 4.返回一个view布局【关键方法哦】  
53.         // 不适合调用大数据的布局组件，【因为你在不停滑动的时候会不停的去调用，创建N个对象出来】  
54.         // 你可以打印出view地址来看看，发现每一个地址都不一样【虽然有垃圾回收机制，但是回收哪有这么快嘛。所以内存会溢出的】  
55.         // 所以我们应该优化它哦。2次优化步骤：  
56.         // a.重复使用convertView  
57.         // b.使用ViewHolder提高在容器中查找组件的效率  
58.         @Override  
59.         public View getView(int position, View convertView, ViewGroup parent) {  
60.             // 打印看看到底是什么  
61.             System.out.println("position=" + position);  
62.             System.out.println("convertView=" + convertView);  
63.             System.out.println("---------------");  
64.             // 4.1.创建一个view通过填充器填充布局  
65.             // View view = getLayoutInflater().inflate(R.layout.main5_item,  
66.             // null);  
67.             // a.开始优化咯。用a方法[把创建的View直接换成convertView【第一次生成的时候是null】]  
68.             if (convertView == null) {  
69.                 convertView = getLayoutInflater().inflate(R.layout.main5_item,  
70.                         null);  
71.                 // b-2.第一次通过convertView找到布局组件，存在保持器中  
72.                 ViewHolder vh = new ViewHolder();  
73.                 vh.iv = (ImageView) convertView.findViewById(R.id.imageView1);  
74.                 vh.tv = (TextView) convertView.findViewById(R.id.textView1);  
75.                 // b-4.赋值  
76.                 vh.iv.setImageResource(images[position]);  
77.                 vh.tv.setText(names[position]);  
78.                 // b-3.然后把这个保持器存起来，存放在一个标签当中。  
79.                 convertView.setTag(vh);  
80.             } else {  
81.                 // b-4.只要第一次找到之后，我们就可以直接从convertView中的标签中拿出布局组件来.然后就可以填充资源了  
82.                 ViewHolder vh = (ViewHolder) convertView.getTag();  
83.                 vh.iv.setImageResource(images[position]);  
84.                 vh.tv.setText(names[position]);  
85.             }  
86.             System.out.println(convertView);  
87.             // 4.2.得到自定义的布局组件  
88.             // ImageView iv = (ImageView) convertView  
89.             // .findViewById(R.id.imageView1);  
90.             // TextView tv = (TextView)  
91.             // convertView.findViewById(R.id.textView1);  
92.             // 4.3.开始填充资源  
93.             // iv.setImageResource(images[position]);  
94.             // tv.setText(names[position]);  
95.   
96.             return convertView;  
97.         }  
98.     }  
99.   
100.     // b-1.自定义一个ViewHolder类把这2个组件hold住。存起来  
101.     // 然后开始利用这个类  
102.     // 使用静态内部类效率又更高点哦  
103.     static class ViewHolder {  
104.         ImageView iv;  
105.         TextView tv;  
106.     }  
107.   
108. }