黑马程序员技术交流社区

标题: 单例模式问题 [打印本页]
作者: て淡莣了陌生    时间: 2013-4-25 14:44
标题: 单例模式问题
本帖最后由 て淡莣了陌生 于 2013-4-26 08:08 编辑

求单例的一个简单示例(代码实现),谢谢!
作者: 林声荣    时间: 2013-4-25 14:53
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();
　　}
　　}
作者: 袁梦希    时间: 2013-4-25 15:22
如何保证对象唯一性呢？
思想：
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. }
复制代码
希望可以帮到你
作者: 乘鱼飞    时间: 2013-4-25 15:46
整个通俗易懂的，集思广益

单例类：就是单个实例
* 实现单例类的条件：
* （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. }
复制代码
作者: hacket    时间: 2013-4-25 17:05
  1. //懒汉式单例模式
  2. public class MySingleton {

  4.         //设立静态变量
  5.         private static MySingleton mySingleton = null;

  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 {

  4.         //设立静态变量，直接创建实例
  5.         private static MySingleton2 mySingleton = new MySingleton2();

  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


111.png (4.87 KB, 下载次数: 18)

111.png
作者: 吴波    时间: 2013-4-25 17:19
单例设计模式：解决一个类在内存只中存在一个对象。
        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;
                }
        }



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2