饿汉式 懒汉式 有点不明白  求高手讲解
两者特点是什么
区分是什么
作用如何

懒汉式和饿汉式都是讲单例设计模式的时候涉及的内容：
饿汉式是先初始化对象，饿汉式类一进内存，就创建对象，设计一般建议饿汉式；而懒汉式，延迟加载，调用相应方法时，才建立对象，下面举个例子说明：
Eg: class SimpleDemo//单例设计模式
{
        public static void main(String[] args)
        {
                Student s1=Student.getInstance();
                Student s2=Student.getInstance();
                s1.setAge(20);
                s1.setName("HuangQin");
                System.out.println(s2.getAge()+";"+s2.getName());
        }
}
class Student
{
        private String name;
        private int age;
        public void setAge(int age)
        {
                this.age=age;
        }
        public int getAge()
        {
                return age;
        }
        public void setName(String name)
        {
                this.name=name;
        }
        public String getName()
        {
                return name;
        }
        private Student(){}
        public static Student s=new Student();//先初始化对象，称为：饿汉式----类一进内存，就创建对象
        public static Student getInstance()
        {
                return s;
        }
}
/* class Student
{
        private static Student s=null;//懒汉式，延迟加载，调用getInstance方法时，才建立对象
        private Student(){}
        public static Student getInstance()
        {
                if(s==null)
                        s=new Studente();
                        return s;
        }
       
}
*/

class  Single
{
        private int num;
        public void setNum(int num)
        {
        this.num=num;
        }
        public int getNum()
        {
        return num;
        }
       
        //单例设计模式方法的两种方式，一般用饿汉式

        /*这个先初始化对象
        称为：饿汉式

        Single类一进内存，就已经创建好了对象。*/
         private Single(){}//1         

        private static Single s=new Single();//2

        public static Single getInstance()
        {
        return s;
        }//3


        /*对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。
        Single类进内存，对象还没有存在，只有被调用了getInstance方法时，才建立对象。
        */
        private Sinle(){}
        private static Single s=null;
        public static Single getInstance()
        {
                if(s==null)
                {
                        synchronized(Single.class)//面试用
                        {
                                if(s==null)
                                        s=new Single();
                        }
                }
        return s;
        }


       
}

不用上代码了，上了更难记
你记住 饿汉式就像饿汉饥不择食，一加载就创建对象，
懒汉式 就像懒汉不紧不慢，等需要了在创建对象
因为早晚都要创建，所以就用饿汉式，记住饿汉式就行了
懒汉式可能造成安全的隐患，可能多线程同时生成多个对象

谢谢各位

public class Person
{
        private String name;
        public void setName(String name)
        {
                this.name = name;
        }
        public String getName()
        {
                return name;
        }
/*
以下属于懒汉式。
       
        private Person(){}//私有的默认构造函数，保证外界无法直接实例化。
        public static Person p = null;
       
        synchronized public static Person getInstance()//静态工厂方法，返回此类的唯一实例。
        {
                if (p == null)
                {
                        p = new Person();
                }
                return p;
        }
*/
/*
以下属于恶汉式。
*/
        private Person(){}
        public static Person p = new Person();
        public static Person getInstance()
        {
                return p;
        }

        public static void main(String [] args)
        {
                Person p = Person.getInstance();
                p.setName("lisi");
                System.out.println(p.getName());
        }
}

十分怀疑楼主是真的不懂还是装的。我觉得不管是老毕还是张孝祥都已经讲的很清楚明白了，lz又来这么一个泛泛而问，哎。