请举例说明一下，谢谢了:)

单例设计模式就是说这个类只能有一个对象，这就需要把构造函数私有化，然后自身创建一个对象，再向外提供一个方法，让其他类可以访问到这个对象，因为不能创建对象调用这个方法，所以这个方法要静态修饰，通过类名调用。
就我所知的单例设计模式有两种：饿汉式和懒汉式。
//饿汉式
  
class Single
{
        private static Single s = new Single();
        private Single(){}
        public static Single getInstance()
        {
                return s;
        }
}
*/
//懒汉式
class Single
{
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
        {
                if(s == null)
                {
                        synchronized(Single.class)
                        {
                                if(s==null)
                                        s = new Single();
                        }
                }
                return s;
               
        }
}
现在说说为什么要用单例设计模式，就是说有些类不能创建多个实例，只能有一个，比方说张老师视频里的两个例子中，银行取号机还有交通灯控制器，这些东西只能有一个，多的话就会出错，也没必要，所以我认为单例模式的用处有两点，1，保证对象唯一。2，节省内存。

单例模式是为了保证一个类在内存中只有一个对象.
1.在单例模式中构造方法是私有的，这样就保证了其他类无法创建本类对象。
2.为了让其他类可以访问本类对象，在本类中添加了一个公共方法（getInstance()），并将此方法设为静态的，通过这个方法其他类可以使用本类对象，而不需要创建。
应用场景：比如读取配置文件的对象，只需要一个，对数据库进行增删改的对象也应保证只有一个，还有游戏中起中央控制器作用的类，也应只有一个
单例模式的两种形态：饿汉式和懒汉式(见图片)

以我的理解，单例是为了保证一个类它的对象只有一个，而其它的程序需要调用的也是一个相同的对象，这个有点类似于公共变量，大家都去调用它。例如：咱们定义了一个类用于统计访问网站的人数，所以我们会把这个类定义为一个单例的模式，这样我们无论谁每访问一次网站，调用的都是这个类的同一个对象，这个单例就会进行加一的操作，这样就达到了统计初步统计网站访问人数的目的。但是如果我们不用单例模式，每个人每进去一次都创建一个新的对象，那么当你离开的后，你刚才创建的对象就消失了，那么就达不到统计网站访问人数的目的了。

1.如果一个类始终只能创建一个实例，则这个类被称为单例类（单态类）。

2.应用场景：在一些场景中，当要求不允许自由创建该类的对象，而只允许创建一个对象时，为了避免其他类自由创建该类的实例，我们将该类的构造器使用private修饰，从而将该类所有的构造器隐藏起来。

3.随之我们提供一个public方法作为该类的访问点，用于创建该类的对象，并使用static方法修饰（因为调用该方法前不存在对象，只能使用类来调用）。

4.单例类必须缓存已经创建的对象，否则该类无法知道是否曾经创建该对象，也就无法保证只创建一个对象。因此需要创建一个成员变量来保存已经创建的对象，并且变量需要被创建对象的静态方法访问，故该变量以static修饰。

1. //饿汉式
   
2. public class Singleton {
   
3.    
   
4.     private static Singleton sing;
   
5. 
   
6.     private Singleton() {
   
7.         
   
8.     }
   
9.    
   
10.     public static Singleton      
    
11.     getInstance() {
    
12.         if (sing == null) {
    
13. //加锁防止程序在此处停止，创造多个对象
    
14.         synchronized(Singleton.class) {
    
15.             if(sing == null){
    
16.             sing = new Singleton();
    
17.             }
    
18.         }
    
19.         return sing;
    
20.     }
    
21. }

复制代码

例如在银行调度系统中，我们有一个管理取号器得机器，只有一个就行了，所以采用单例。学习程序就和牛的反刍一样，时不时的拿出来回味下，用到的时候自然就体会到了，这样笼统的说没意思。单例直接用枚举实现最简单。

1. package com.tan.dao;
   
2. 
   
3. import com.tan.dao.impl.BookDaoImpl;
   
4. import com.tan.dao.impl.UserInfoDaoImpl;
   
5. 
   
6. public class FactoryDao {
   
7. 
   
8.         private static FactoryDao instance =new FactoryDao();
   
9.         private FactoryDao(){}
   
10.                  
    
11.         public static FactoryDao getInstance() {
    
12.                
    
13.                 return instance;
    
14.         }
    
15. 
    
16.         public UserInfoDao getUserInfoDao() {
    
17.        
    
18.                 return new UserInfoDaoImpl();
    
19.         }
    
20. 
    
21.         public BookDao getBookDao() {
    
22.                
    
23.                 return new BookDaoImpl();
    
24.         }
    
25. 
    
26. }
    

复制代码

这个是项目中的一个简单dao工厂类。
如果现在需要在业务逻辑层中像调用 BookDao的实现类来操作数据库的话：

BookDao dao=FactoryDao.getInstance().getBookDao();
是不是一目了然。 没有用到项目中，是不能感受到单例模式的好处的

郑小杰 发表于 2012-8-18 09:41
单例设计模式就是说这个类只能有一个对象，这就需要把构造函数私有化，然后自身创建一个对象，再向外提供一 ...

:)谢了，能不能具体给个实用的例子