单例模式

/*
 * 怎么可以保证这个类只能产生一个对象？
 * 
 * 思路：
 * 1.问题是其他程序都可以通过NEW创建该类的对象。无法控制数量
 * 所以，不让其他程序new就ok了
 * 2.那第一步的问题也产生了，那其他程序不就没有对象了吗？
 * 干脆，在奔雷中自己new一个本类对象，这样的好处是，不让别的程序new,自己new,可以试想数量控制
 * 3.对外提供让其他程序获取该对象的方式，就ok
 * 
 * */

/*
 *  步骤：
 *  1.不让其他程序new该类对象怎么处理？
 *  可以将类中的构造函数私有化。
 *  2.在本类中new一个对象。
 *  3.定义一个方法返回该对象
 *  
 */


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){
 *                s=new Single();
 *            }else{
 *                return s;
 *            }
 *        }
 *    }
 * 
 * 
 */



class SingleDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
//        Single s1= Single.s;
//        Single s2= Single.s;
        
//        Single s1= Single.getInstance();
//        Single s2= Single.getInstance();
//        
//        System.out.println(s1==s2);
        
        
        SuperMan man =SuperMan.getInstance();
        man.getName();
        System.out.println(man.getName());
//        SuperMan man1 =SuperMan.getInstance();
//        man1.setName("bb");
//        man1.getName();
    }

}


//单例模式应用


class SuperMan{
    
    private String name;

    //创建一个本类对象
    private static SuperMan man= new SuperMan("fuck");
    
    //构造函数私有化
    private SuperMan(String name){
        
        this.name=name;
    }
    
    //定义一个方法返回对象，让其他程序调用
    public static SuperMan getInstance(){
        
        return man;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
}