一、单例设计模式
- 什么是设计模式:
- 1)静态方法和属性的经典使用
- 2)设计模式时在大量的实践中总结和理论后优选的代码结构,编程风格,以及解决问题的思考方式。
设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索。
- 什么是单例模式:
- 1)就是采用一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法
- 2)单例模式有两种方法:
- 1,饿汉式
- 2,懒汉式
一、1、饿汉式
- 为什么叫饿汉式呢
- 因为其对象在类加载的时候就创建了
- 弊端:可能造成创建了对象,但是没有使用
- 因为其对象在类加载的时候就创建了
- 步骤:
- 1)将构造器私有化===》防止直接new对象
- 2)在类的内部创建对象 -----》(该对象是静态的)
- 3)向外暴露一个静态的公共方法(用来调用在内部创建的对象)
类加载的时候,对象就被创建了(会导致创建了对象,但是却没有使用到的问题)
public class single01 {
public static void main(String[] args) {
// 类加载的时候对象就创建了
System.out.println(GirlFriend.n1);
System.out.println("===========================");
// 通过方法可以获取
GirlFriend instance1 = GirlFriend.getInstance();
System.out.println(instance1);
System.out.println("===========================");
GirlFriend instance2 = GirlFriend.getInstance();
System.out.println(instance2);
System.out.println(instance1==instance2);//true
}
}
//有一个类,GirlFriend
//只能有一个女朋友
class GirlFriend{
public static int n1=200;
private String name;
// 如何保障我们只能创建一个GirlFriend对象
// 步骤:【单例模式-饿汉式】
// 1. 将构造器私有化
private GirlFriend(String name){
System.out.println("构造器被调用");
this.name=name;
}
// 2.在类的内部直接创建对象(该对象是静态的)
// 为了能够在静态方法中,返回gf对象,需要将其设置为static
private static GirlFriend gf=new GirlFriend("小红");
// 3.提供一个公共的static方法,返回gf对象
public static GirlFriend getInstance(){
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}
运行结果:
构造器被调用
200
===========================
GirlFriend{name='小红'}
===========================
GirlFriend{name='小红'}
true
一、2、懒汉式
- 为什么叫懒汉式
- 因为其对象如果你没有使用就不会创建,只有使用的时候才会创建
- 步骤:
- 1.将构造器私有化
- 2.定义一个static静态属性对象
- 3.提供一个public的static方法,可以返回一个对象
- 懒汉式只有当用户使用这个方法的时候,才创建对象,后面再调用的时候,会返回上次创建的对象
public class single02 {
public static void main(String[] args) {
System.out.println(Cat.n1);
System.out.println("=====================");
Cat instance1 = Cat.getInstance();
System.out.println(instance1);
System.out.println("=====================");
Cat instance2 = Cat.getInstance();
System.out.println(instance2);
}
}
//希望在程序运行过程中只能创建一个Cat对象
//使用单例模式
class Cat{
public static int n1=100;
private String name;
// 步骤:
// 1.将构造器私有化
private Cat(String name) {
System.out.println("构造器被调用");
this.name = name;
}
// 2.定义一个static静态属性对象
private static Cat cat;//默认为null;
// 3.提供一个public的static方法,可以返回一个对象
public static Cat getInstance(){
if (cat==null){//如果没有创建cat对象
cat=new Cat("小白");
}
return cat;
}
// 懒汉式只有当用户使用这个方法的时候,才创建对象,后面再调用的时候,会返回上次创建的对象
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
运行结果:
100
=====================
构造器被调用
Cat{name='小白'}
=====================
Cat{name='小白'}
一、3、饿汉式VS懒汉式
- 二者主要的区别在于创建对象的时机不同:饿汉式是在类加载的时候就创建了对象实例,而懒汉式是在使用的时候才会创建对象实例。
- 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
当多个线程同时执行getInstance方法,并且同时进行 if (catnull)判断–》就可能出现一瞬间的时间点,有三个线程全部执行cat=new Cat(“小白”);,这样单例模式就被破坏了==(以后才能解决这问题)
public static Cat getInstance(){
if (cat==null){//如果没有创建cat对象
cat=new Cat("小白");
}
return cat;
}
- 饿汉式存在资源浪费资源的可能,如果程序员因为使用某个静态属性或者其他的事情,使类加载类,导致创建一个对象,但是却没有使用,那么饿汉式创建的对象就浪费了。懒汉式是使用的时候才会创建的,就不存在这个问题。
- 在javaSE标准类中,java.lang.Runtime就是经典的单例模式。