单例设计模式

举报
Java的学习之路 发表于 2022/03/24 10:46:28 2022/03/24
【摘要】 设计模式概念1.设计模式是静态方法和属性的经典使用2.设计模式是大量时间中总结和理论化后优选的代码结构、编程风格、以及解决问题的思考方式3.我们可以这样理解,设计模式就像是一个棋谱,遇到不同的棋局,我们就用不同的棋谱,免去我们自己的思考。 单例设计模式 单例模式的概念单例就是单个实例1.类的单例设计模式,就是采取一定的方法,保证在整个的软件系统中,对应某一个类来说,它只能存在一个对象实例,...

设计模式概念

1.设计模式是静态方法和属性的经典使用
2.设计模式是大量时间中总结和理论化后优选的代码结构、编程风格、以及解决问题的思考方式
3.我们可以这样理解,设计模式就像是一个棋谱,遇到不同的棋局,我们就用不同的棋谱,免去我们自己的思考。

单例设计模式

单例模式的概念

单例就是单个实例
1.类的单例设计模式,就是采取一定的方法,保证在整个的软件系统中,对应某一个类来说,它只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法

比如说在软件开发中,有一个类是核心类,它很耗费资源,而且我们只需要一个,这个时候,就可以单例设计模式

2.单例模式有两种方式: 饿汉式 和 懒汉式

饿汉式

只要类加载,就会创建对象
我们可能还没有用到这个对象,但是这个时候对象已经创建好了(饿汉式)
比如说我们调用一个静态属性,这个时候类就会加载,静态属性的初始化就会被执行,但是此时我们还没有用到这个实例,就有可能导致对象创建,但是我们没有用,就会导致资源的浪费

步骤:
1.构造器私有化,防止直接new对象 (构造器如果不私有化,那么我们就可以new多个对象,构造器私有化,可以保证我们只能创建一个对象,因为私有的方法只能在本类中调用)
2.类的内部创建对象(静态的)

3.向外暴露静态的公共方法,来获取这个实例

思考:为什么内部创建的对象要是静态的呢?

就算这个对象不是静态的,我们也可以保证这个类只能有一个对象,但是main方法是静态的,静态方法只能调用静态方法和静态属性,如果说这个对象不是静态的,那么获取这个对象的方法就不能是静态的’,如果想要在main方法中调用这个方法来获取实例,是不行的,我们就需要在外面创建对象,然后才可以调用这个方法,这样就矛盾了,所以说内部创建的对象必须是静态的

 
public class SingleInstance {
    public static void main(String[] args) {
        GirlFriend g1 = GirlFriend.getInstance();
        GirlFriend g2 = GirlFriend.getInstance();
        System.out.println(g1);
        System.out.println(g2);
        System.out.println(g1 == g2);

    }
}
//饿汉式
class GirlFriend{
    //保证这个类只有一个对象
    //所以要保证不能随意创建对象,因此构造器要私有化
    //在类的内部创建好对象
    private static GirlFriend girlFriend=new GirlFriend("lucy");
    private String name;
    private GirlFriend(){

    }
    private GirlFriend(String name){
        this.name=name;
    }

    public static GirlFriend getInstance(){
        return girlFriend;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

输出结果:

GirlFriend{name='lucy'}
GirlFriend{name='lucy'}
true

这样可以说明,g1和g2其实是同一个对象

懒汉式

我们在使用这个实例的时候,才会创建这个实例

步骤:
1.构造器私有化,防止直接new对象 (构造器如果不私有化,那么我们就可以new多个对象,构造器私有化,可以保证我们只能创建一个对象,因为私有的方法只能在本类中调用)
2.定义一个静态属性对象

3.向外暴露静态的公共方法,可以返回一个对象,如果对象还没有创建,我们就创建一个对象,否则,直接返回一个对象

 
public class SingleInstance1 {
    public static void main(String[] args) {
        Cat cat=Cat.getInstance();
        Cat cat1=Cat.getInstance();
        System.out.println(cat);
        System.out.println(cat1);
    }
}

class Cat{

    private String name;
    private static Cat instance;
    private Cat(){}
    private Cat(String name){this.name=name;}

    public static Cat getInstance(){
        if (instance == null){
            instance=new Cat("小猫");
        }
        return instance;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}


运行结果

Cat{name='小猫'}
Cat{name='小猫'}
true

两者的区别

1.二者主要的区别在于创建对象的时机不同;饿汉式是在类加载就创建了对象实例,而懒汉式是在使用的时候才创建的
2.饿汉式不存在线程安全问题,懒汉式存在线程安全问题
3.饿汉式在类加载的时候就创建了,存在浪费资源的可能,因为如果我们一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用的时候创建,就不会存在这个问题
4.javase中,Java.lang.Runtime就算经典的单例模式,饿汉式

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。