单例设计模式

本文阅读 5 分钟
首页 代码,Java 正文

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

单例模式的概念

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

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

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

饿汉式

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

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

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

就算这个对象不是静态的,我们也可以保证这个类只能有一个对象,但是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.定义一个静态属性对象

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() { }
本文为互联网自动采集或经作者授权后发布,本文观点不代表立场,若侵权下架请联系我们删帖处理!文章出自:https://zengyihong.blog.csdn.net/article/details/123027624
-- 展开阅读全文 --
安全面试之XSS(跨站脚本攻击)
« 上一篇 07-24

发表评论

成为第一个评论的人

热门文章

标签TAG

最近回复