单态设计模式都是在什么情况下使用?  对这一块不是很清楚.

楼主说的是单例设计模式吗？单态模式好像没听说过吧，单例模式就是类中只能创建一个实例对象，保持内存对象的唯一性。如果类中对象就一个，不在创建其他对象，可以使用单例模式。
大致步骤：1.私有化函数，防止其他类创建该类对象
               2..创建私有静态本类对象(只创建一个实例对象)
               3.定义一个共有的静态方法，返回该对象，对外提供访问
单例两种模式：

饿汉：类一加载是就创建实例
public Single{
              private Single(){}
              private static Single s=new Single();
             public static Single getInstance(){
return s;
}
}
   懒汉模式：延迟加载，调用该类的时候才创建对象。适用于用于多线程，但有安全问题，怎么办？同步函数比较低效，可使用同步代码块，多重判断提高效率。
public class Single
{
  private Single(){}//私有构造函数，防止外部创建实例对象
       
        private static Single s=null;//2.创建对象

        public static Single getInstance(){ //3.提供方法
           if(s==null){  //双重判断提高效率
              synchronized(Single.class){  //静态对象锁不再是this,而是 类.class
              if(s==null)
               
                  s=new Single();
                }
                  return s;
        }
}
记住一句话管用：静态优先对象存在，静态加载到内存，对象还未产生，但有类的字节码对象.class

大漠孤烟 发表于 2014-5-23 00:15
楼主说的是单例设计模式吗？单态模式好像没听说过吧，单例模式就是类中只能创建一个实例对象，保持内存对象 ...

单态即单例设计模式，称谓不同，其实就是一个

单列设计模式：解决一个类在内存只存在一个对象，


想要保住对象唯一。
1，为了避免其他程序过多建立该类对象，先控制禁止其他程序建立该类对象。
2，还为了让其它程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现呢？
1，将构造函数私有化。private
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该类对象。

对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，加上这三步就行。

饿汉式。开发一般用这种
Single类一进内存，就已经创建好了对象。
class Single
{
        private static Single s = new Single();
        private Single(){}
        public static Single getInstance()
        {
                return s;
        }
}

对象时方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstanc方法时，才建立对象。
class Single
{
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
        {
                /*
                if(s == null)
                        s = new Single();
                else
                        return s;
                */
       
                if(s == null)
                {
                        synchronized(Single.class)
                        {
                                if(s == null)
                                        s = new Single();
                        }
                }
                reruen s;
        }
       
}
记录原则：定义单例，建议使用俄汉式

单例设计模式就是解决一个类在内存中只存在一个对象，要想保证对象的唯一性。
1、为了避免其他程序过多的建立该类对象，先禁止其他程序建立该对象。
2、还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么用代码实现呢？
1、将构造函数私有化。
2、在类中创建一个本类对象。
3、提供一个方法可以获取到该类对象。
代码：
饿汉式：

class single
{
     private  single(){}
     private static single s  =new single();
     public static single getInstance()
     {
          return s;
     }
}

懒汉式：
class single
{
     private  single(){}
     private static single s  =null；
     public static single getInstance()
     {
          if(s==null)
          {
               return s=new single();   
           }
               return s;
      }                 
}