小弟有个问题想请教一下,什么叫做单例模式呀?

[usb00fa]

今天看视频时的时候,张孝祥老师提到了"单例"这个词语,他也没有解释,我是新手,有些不懂,请教各位高手一下,不甚感激,谢谢各位了

[allvictory]

只能生成一个对象的类

[justlearn]

一个类只有一个实例

[火龙果被占用了]

不管获得多少次，获得单例类的对象都是同一个。

[zyus1987]

[Quote=引用 10 楼 luomf 的回复:]
单例模式的实现都是固定的，这个并不难，但最重要的是你要知道什么时候需要用单例？

除非有明确的需求要用单例，或者在使用单例之前一定要好好考虑一下是否一定需要使用单例模式？

因为，使用单例模式，系统运行后，整个系统就只有此一个单例，若很多个请求都要用到此单例，系统将不堪重负，就像让同一个人总是做相同的事情会提高效率，但要让同一个人做相同的事情数量很多的话效率能高吗？这个时候你可以考虑使用工……
[/Quote]
LZ上正解~！

[ltai701]

同意四楼

[qingdaojie]

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
　　 //在自己内部定义自己一个实例，是不是很奇怪？
　　 //注意这是private 只供内部调用
　　 private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　 public static Singleton getInstance() {
　　　　 return instance; 　　
　　 }
}
第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些

[hh161151]

这个一般可以提高程序效率，在需要的时候不需要每次实例化一个对象了

[z277768776]

还是简单点好

public class A{
 public static void main(){
  B b = B.getB();
  println( b.getID()+"" );
  B b2 = B.getB();
  println( b2.getID()+"" );
  C c1 = C.getC(1);
  println( c1.getID()+"" );
  C c2 = C.getC(2);
  println( c2.getID()+"" );
  C c3 = C.getC(100)+"" );
  println( c3.getID()+"" );
  D d = D.getD();
 }
 static void println(String s){System.out.println(s);}
}

class B{
 final private int ID;
 private B( int i ){ ID=i; }//将构造器隐藏 外界无法调用 于是就无法创建B的实例
 private static B onlyb = new B( 0 );
                //静态域在类中当然是只构造一次的 这仅仅是巧妙利用了static的特性
 public static B getB(){ return onlyb; }//由这个public方法返回那唯一的静态实例
 public int getID(){ return ID; } //仅仅是个返回ID的功能性方法；
}

//当然 方法还有其他的
class C {
 private final int ID;
 private C( int i ){ ID=i; }
 static C c1 =new C(1);
 static C c2 =new C(2);
 static C c3 =new C(3);
 public static C getC( int i ) { //你愿意的话 也可以一个方法专门返回一个实例
  swich i{
    case 1 : return c1;
    case 2 : return c2;
    default : return c3;
   }
 }
  public int getID(){return ID;}
}//这种大概用处不大 

class D {
 private final int ID;
 private static boolean have = fualse;
 private static onlyd;
 private D(int i){ ID=i; }
 public static D getD(){
  if(have!=fualse){onlyd=new D(0); have=ture; }
  return onlyd;
 }
 public int getID(){return ID;}
}这个方式是用在某种特殊场合，比如内部类 不允许有static域，只好使用这样的方法；

后两种自己写的。
以上没有实践经验 请专家批判。

[z277768776]

[Quote=引用 8 楼 keeya0416 的回复:]
Java code

class LazySingleTest {

private static LazySingleTest st = null;

private LazySingleTest() {

}
//懒汉式
public synchronized static LazySingleTest getInstance……
[/Quote]

还是这个强

[木木水夕]

一个对象是也！！！！！！！！！！！！！

[sky123123]

[Quote=引用 4 楼 sbfivwsll 的回复:]

打个比方，你家里只有你一个儿子，每个你们村上有个什么事叫你们每家人出一个小孩时，都只能是叫你出去，因为你家没有第二个儿子。
在java中，单例一是每次获取都是同一个对象。
class Test
{
private Test()
{/*构造私有。*/
}
private static Test test=new Test();
public static Test getTest(……
[/Quote]


这比方太儿恰当咯。 O(∩_∩)O~

[ACE777999]

hao

[keeya0416]

class LazySingleTest {

	private static LazySingleTest st = null;

	private LazySingleTest() {

	}
        //懒汉式
	public synchronized static LazySingleTest getInstance() {
		if (st == null) {
			st = new LazySingleTest();
		}
		return st;
	}
}


public class SingleTest {

	private static SingleTest st = new SingleTest();

	private SingleTest() {

	}
        //饿汉式
	public static SingleTest getInstance() {
		return st;
	}
}

[x_pengcheng]

自己实现一下，楼上正解。

[luomf]

单例模式的实现都是固定的，这个并不难，但最重要的是你要知道什么时候需要用单例？

除非有明确的需求要用单例，或者在使用单例之前一定要好好考虑一下是否一定需要使用单例模式？

因为，使用单例模式，系统运行后，整个系统就只有此一个单例，若很多个请求都要用到此单例，系统将不堪重负，就像让同一个人总是做相同的事情会提高效率，但要让同一个人做相同的事情数量很多的话效率能高吗？这个时候你可以考虑使用工厂模式，最好采用spring注入的方式。

[铑枪--突廆孒]

打个比方，你家里只有你一个儿子，每个你们村上有个什么事叫你们每家人出一个小孩时，都只能是叫你出去，因为你家没有第二个儿子。
在java中，单例一是每次获取都是同一个对象。
class Test
{
private Test()
{/*构造私有。*/
}
private static Test test=new Test();
public static Test getTest()
{
return test;/*这里每次返回的对象都是同一个对象。*/
}
}

或
class Test
{
private Test()
{/*构造私有。*/
}
private static Test test;
public static Test getTest()
{
if(test==null)
{
test=new Test();
}
return test;/*这里每次返回的对象都是同一个对象。*/
}

不过第二种方法不建议使用，可能会涉及到同步的问题。如果N个人同时操作该方法，有可能N个人都会去new这个Test()对象。虽然这样的概率很小很小，但是我们要明白：小概率事件<>不可能发生事件。
}

[duyu1025]

楼上正解，