java基础之单例设计模式

单例设计模式可以防止外类随意造对象，保证了安全性，实现方法如下有两种

/**
 * 实现单例设计模式
 * 1.在类中将构造方法私有化
 * 2.创建对象将其设为静态私有化
 * 3.为外部提供一个静态的可访问的方法
 *
 * 两种实现方式:
 * 1.饿汉式(生命周期长，效率高)(直接创建对象)
 * 2.懒汉式(生命周期短，效率低，占用内存少，尽量使用这个方式)(使用时创建对象)
 */

先用饿汉式设计看看，饿汉式顾名思义就是直接在本类造对象，给外部提供getInstance方法，外部对象访问这个方法，再将本类刚才创建的对象返回，接着就可以在外类使用接受的对象来访问本类的方法了

public class test {
    public static void main(String[] args) {
        //饿汉式设计
        person1 s1=person1.getInstance();
        s1.print1();
        s1.print2();
}


//饿汉式设计
class  person1{
    private person1(){}
    private static person1 s1=new person1();   //直接造对象
    static person1 getInstance(){
        return s1;                       //返回这个s1对象，外类再用这个对象来调用方法
    }
    public void print1(){
        System.out.println("方法1调用了");
    }
    public void print2(){
        System.out.println("方法2调用了");
    }
}

懒汉式设计就是用时再创建对象，可以节省内存

public class test {
    public static void main(String[] args) {
        //饿汉式设计
       /* person1 s1=person1.getInstance();
        s1.print1();
        s1.print2();*/
        //懒汉式设计
        person2 s2=person2.getInstance();
        s2.print3();s2.print4();
    }
}
//懒汉式设计
class  person2{
    private person2(){}
    private static person2 s2;       //先不初始化对象，等别人调用这个方法，再判断是否为空，再创建对象
    static person2 getInstance(){
        if(s2==null){
            s2=new person2();
        }
        return s2;                       //返回这个s1对象，外类再用这个对象来调用方法
    }
    public void print3(){
        System.out.println("方法3调用了");
    }
    public void print4(){
        System.out.println("方法4调用了");
    }
}

源码如下

package javaLei;
/**
 * 实现单例设计模式
 * 1.在类中将构造方法私有化
 * 2.创建对象将其设为静态私有化
 * 3.为外部提供一个静态的可访问的方法
 *
 * 两种实现方式:
 * 1.饿汉式(生命周期长，效率高)(直接创建对象)
 * 2.懒汉式(生命周期短，效率低，占用内存少，尽量使用这个方式)(使用时创建对象)
 */
public class test {
    public static void main(String[] args) {
        //饿汉式设计
        person1 s1=person1.getInstance();
        s1.print1();
        s1.print2();
        //懒汉式设计
        person2 s2=person2.getInstance();
        s2.print3();s2.print4();
    }

//饿汉式设计
class  person1{
    private person1(){}
    private static person1 s1=new person1();   //直接造对象
    static person1 getInstance(){
        return s1;                       //返回这个s1对象，外类再用这个对象来调用方法
    }
    public void print1(){
        System.out.println("方法1调用了");
    }
    public void print2(){
        System.out.println("方法2调用了");
    }
}
//懒汉式设计
class  person2{
    private person2(){}
    private static person2 s2;       //先不初始化对象，等别人调用这个方法，再判断是否为空，再创建对象
    static person2 getInstance(){
        if(s2==null){
            s2=new person2();
        }
        return s2;                       //返回这个s1对象，外类再用这个对象来调用方法
    }
    public void print3(){
        System.out.println("方法3调用了");
    }
    public void print4(){
        System.out.println("方法4调用了");
    }
}

 在后续的学习中，会发现懒汉式设计更受欢迎，可以节省内存(毕竟内存还蛮贵的)，大家设计也还是当这个懒汉吧，当然这样的设计也是最low的，后续学习了多线程还有一种设计方法