单例设计模式

对所有的Java开发者而言,所有项目中最为常见的三个设计模式:工厂设计模式、代理设计模式、单例设计模式。

单例设计模式:

如果一个类中定义有普通方法,那么这些普通方法一定要通过本类的实例化对象你才可以调用。

传统调用:

class Single{
public void print(){
System.out.println("单身");
}
}
class TestDemo{
public static void main(String arg[]){
Single single = new Single();
single.print();
}
}


运行结果:单身

        在本程序中Single是一个普通的类,由于本类并没有进行任何构造方法的定义,所以这个类中会自动生成一个无参的、什么都不做的的构造方法,正是因为如此,我们可以在外部进行无参构造的调用。

但现在相对Single 类做一个修改:

class Single{
private Single(){}
public void print(){
System.out.println("单身");
}
}
class TestDemo{
public static void main(String arg[]){
Single single= null;
single = new Single();
single.print();
}
}

运行结果:java: Single() 在 com.hellojava.类与方法.JiChengTest.Single 中是 private 访问控制

       如果构造方法被私有化了,那么类的外部将无法进行该构造方法的调用,那也就意味着这个类无法进行新的实例化对象的生成。于是我们需要在Single 类中通过一些新设计,让外部可以获取本类实例。

1、使用 private 进行私有化的结构中只允许在本类之中进行访问,所以此时Single 类中的无参构造方法只有Single 类自己调用,那就要找到一种结构既可以在内部调用Single 类构造,又可以不受到Single 类实例化对象的限制,那么自然可以想到 static 方法。

 

class Single{
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
return new Single();
}
}
class TestDemo{
public static void main(String arg[]){
Single single=Single.getInstance();
single.print();
}
}

运行结果:单身

以上的操作的确实现外部获取Single 类实例化对象的需求,但是这种实现有些荒唐,因为如果此时不在构造方法上加private,也可以实现功能。

2、构造方法的主要功能是获取一个类实例化对象,每调用一次构造方法都可以获取一个新的实例化对象,如果想限制一个类中实例化对象的产生,那么最好的控制就是将构造方法隐藏,
那么此时就需要进行程序结构的修改,让一个类中只能维持一个实例化对象;

3、类的构造方法被私有化后,就只能够在类中进行对象的实例化操作;

class Single{
private static final Single INSTANCE = new Single();
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
return INSTANCE;
}
}
class TestDemo{
public static void main(String arg[]){
Single instanceA = Single.getInstance();
Single instanceB = Single.getInstance();
Single instanceC = Single.getInstance();
Single instanceD = Single.getInstance();
}
}
   以上就实现了一个最核心的单例设计模式,不管外部调用getInstance()方法,那么在整个系统内部只维持了唯一一个Single 类的实例。
对于单例设计模式,实际分为两种:饿汉式单例、懒汉式单例。上面就属于饿汉式单例,之所以称为饿汉,主要原因是Single 里面会始终维持一个 INSTANCE 的实例化对象,并不关心这个对象是否被使用。
而懒汉式单例设计的最大特点在于:第一次使用的时候才会进行实例化,而不使用不进行实例化。
懒汉式单例范例:

class Single{
    private  static Single INSTANCE;
private Single(){}
public void print(){
System.out.println("单身");
}
public static Single getInstance(){
if (INSTANCE == null){
INSTANCE = new Single();
}
return INSTANCE;
}
}
class TestDemo{
public static void main(String arg[]){
Single INSTANCE = Single.getInstance();
INSTANCE.print();
}
}


运行结果:单身
饿汉式的单例实现要比懒汉式的单例实现更简单。

单例模式
例--实例--对象
本类只有一个对象
当一个类只能有一个对象时,我们将这个类定义为单例模式
步骤:
01:将构造方法私有化
02:定义一个自己的对象引用,然后new一个对象
03:写一个public static方法,提供调用对象的入口

//懒汉式和饿汉式的区别
01:懒汉式只有在第一次调用的时候才new 对象 饿汉式 直接new一个对象
02:懒汉式省内存 饿汉式费内存
03:懒汉式有线程安全问题 饿汉式不存在


上一篇:Arduino GY85 I2C测试


下一篇:Java基础面试总结