求单例的一个简单示例(代码实现),谢谢!

7.单例设计模式：解决一个类在内存中只存在一个对象。
　　保证对象唯一的方式：
　　1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该对象；
　　2、为了让其他程序可以访问的到该类对象，只好在本类中自定义一个对象；
　　3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式；
　　以上三步的代码的实现：
　　将该类的构造函数私有化；
　　在该类中创建一个本类对象；
　　提供一个方法可以获取到该对象；
　　如：class Single{                //饿汉式（一般开发都用，安全）
　　private Single(){};
　　private static Single s = new Single();
　　public static Single getInstance(){
　　return s;
　　}
　　}       
　　
                        Class Single{                //懒汉式（不安全，当多个用户使用时，出现线程问题）
        private static Single  s = null;
        privarte Single(){};
        public static Single getInstance(){
                        if(s == null)  //线程问题
                                s= new Single();
                        return s;
        }
　　
　　
　　class SingleDemo{
　　Public static void main(String args[]){
　　Single ss = Single.getInstance();
　　}
　　}

如何保证对象唯一性呢？
思想：
1，不让其他程序创建该类对象。
2，在本类中创建一个本类对象。
3，对外提供方法，让其他程序获取这个对象。
步骤：
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；
2，就在类中创建一个本类的对象；
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）
代码体现：
1，私有化构造函数；
2，创建私有并静态的本类对象；
3，定义公有并静态的方法，返回该对象。
---------------------------------------------

1. //饿汉式
   
2. class Single{
   
3. private Single(){} //私有化构造函数。
   
4. 　　private static Single s = new Single(); //创建私有并静态的本类对象。
   
5. public static Single getInstance(){ //定义公有并静态的方法，返回该对象。
   
6. return s;
   
7. }
   
8. }
   

复制代码

---------------------------------------------

1. //懒汉式:延迟加载方式。
   
2. class Single2{
   
3. private Single2(){}
   
4. 　　private static Single2 s = null;
   
5. public static Single2 getInstance(){
   
6. if(s==null)
   
7. s = new Single2();
   
8. return s;
   
9. }
   
10. }

复制代码

希望可以帮到你

整个通俗易懂的，集思广益

单例类：就是单个实例
* 实现单例类的条件：
* （1）构造器私有，不允许外界访问
* （2）暴露一个方法，由该方法返回实例
* （3）使用一个静态属性来缓存已有的实例，
* 每次获取实例之前，判断是否已经存在缓存过的实例

1. class Singleton
   
2. {
   
3.         private Singleton(){};//私有的构造器
   
4.         private static Singleton st;//定义一个可以缓存实例的属性
   
5.         public static Singleton getInstance()//提供给外部访问的方法
   
6.         {
   
7.                 if(st==null)//判断实例是否存在
   
8.                 {
   
9.                         st=new Singleton();//不存在的话让st缓存，这样就不会存在多个实例
   
10.                 }
    
11.                 return st;
    
12.         }
    
13. }
    
14. public class SingletonTest {
    
15.         public static void main(String[] args) {
    
16.                 Singleton s1=Singleton.getInstance();
    
17.                 Singleton s2=Singleton.getInstance();
    
18.                 System.out.println(s1==s2);//true
    
19.         }
    
20. }

复制代码

1. //懒汉式单例模式
   
2. public class MySingleton {
   
3. 
   
4.         //设立静态变量
   
5.         private static MySingleton mySingleton = null;
   
6. 
   
7.         private MySingleton(){
   
8.                 //私有化构造函数
   
9.                 System.out.println("-->懒汉式单例模式开始调用构造函数");
   
10.         }
    
11.        
    
12.         //开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
    
13.         public static MySingleton getInstance(){
    
14.                 System.out.println("-->懒汉式单例模式开始调用公有方法返回实例");
    
15.                 if(mySingleton == null){
    
16.                         System.out.println("-->懒汉式构造函数的实例当前并没有被创建");
    
17.                         mySingleton = new MySingleton();
    
18.                 }else{
    
19.                         System.out.println("-->懒汉式构造函数的实例已经被创建");
    
20.                 }
    
21.                 System.out.println("-->方法调用结束，返回单例");
    
22.                 return mySingleton;
    
23.         }
    
24. }

复制代码

1. //饿汉式单例模式
   
2. public class MySingleton2 {
   
3. 
   
4.         //设立静态变量，直接创建实例
   
5.         private static MySingleton2 mySingleton = new MySingleton2();
   
6. 
   
7.         private MySingleton2(){
   
8.                 //私有化构造函数
   
9.                 System.out.println("-->饿汉式单例模式开始调用构造函数");
   
10.         }
    
11.        
    
12.         //开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
    
13.         public static MySingleton2 getInstance(){
    
14.                 System.out.println("-->饿汉式单例模式开始调用公有方法返回实例");
    
15.                 return mySingleton;
    
16.         }
    
17. }

复制代码

参考：http://blog.csdn.net/lanzhizhuxia/article/details/7920556

单例设计模式：解决一个类在内存只中存在一个对象。
        class Student//先初始化，称为饿汉式
        {
                private static Student s=new Student();
                private Student(){}
                public static Student getStudent()
                {
                        return s;
                }
        }
        class Student//被调用时，才初始化，也叫对象的延时加载，称为懒汉式
        {
                private static Student s=null;
                private Student(){}
                public static Student getStudent()
                {
                        if(s==null)
                        {
                                synchronized(Student.class)
                                {
                                        if(s==null)
                                                s=new Student();
                                }
                        }
                        return s;
                }
        }