Java面向对象（高级）-- 单例(Singleton)设计模式

文章目录

一、单例设计模式
- （1）设计模式概述
- （2）何为单例模式
- （3）实现思路
- （4）单例模式的两种实现方式
- - 1. 饿汉式
  - 2. 懒汉式
  - 3. 饿汉式 vs 懒汉式
- （5）单例模式的优点及应用场景
二、理解main方法的语法
- （1）main()方法的剖析
- （2）与控制台交互
- - 1.举例1
  - - 1.1 方式一、命令行
    - 1.2 方法二、编译器
  - 2.举例2
- （3）笔试题

一、单例设计模式

（1）设计模式概述

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。“套路”

经典的设计模式共有23种。每个设计模式均是特定环境下特定问题的处理方法。

创建型模式：主要用于创建对象，根据不同场景设计不同的设计模式。

简单工厂模式并不是23中经典模式的一种，是其中工厂方法模式的简化版

对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》：《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Gang of Four）"，而这本书也就被称为"四人组（或 GoF）"书。

（2）何为单例模式

单例–单独一个实例（对象）

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例（不需要多个对象），并且该类只提供一个取得其对象实例的方法。

（3）实现思路

如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。

因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法（方法不能是非静态的，因为非静态方法要通过对象去调用，

此时外部无法创建对象来调用方法，只能通过类调用静态方法）以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

（4）单例模式的两种实现方式

1. 饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }

    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

【举例】

场景：假设Bank只有一个实例。

package yuyi04;

public class BankTest {

}

class Bank{ //假设这个银行只有一个实例：中国人民银行


}

①类的构造器私有化 (避免类的外部创建对象)

为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器。

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }
}

②在类的内部创建当前类的实例 (一个就可以了)

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

     //2.在类的内部创建当前类的实例 (一个就可以了)
    private Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化
    
}

③提供私有属性的get方法

类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    
     //2.在类的内部创建当前类的实例 (一个就可以了)
    private Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    
    //3.提供私有属性的get方法
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

使用getXxx()方法获取当前类的实例，必须声明为static的。

通过方法返回当前类的实例，那么这个getInstance方法谁来调呢？

现在只能拿“对象”来调用这个方法，才能拿到getInstance方法来获取此对象。(此时在类外部需要一个对象，但是无法通过构造器来创建，只能通过getInstance方法来获取一个对象，但是这个方法也需要通过对象才能调用，而对象需要通过这个方法来获取，绕进去了…)

要想调用getInstance方法来获取对象，肯定不能拿对象去调用，只能通过类来调用，那就意味着getInstance方法需要静态化。

public static Bank getInstance(){
    return instance;    //在方法里面，将造好的对象返回
}

④属性设置为static

上一步将方法声明为static之后，会发现报错，如下：

这是因为静态方法中，只能调用静态属性或方法。

所以instance也必须静态化，如下：

private static Bank instance=new Bank();

目前整体的Bank类如下：

class Bank{ //假设这个银行只有一个实例：中国人民银行

    //1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    //2.在类的内部创建当前类的实例 (一个就可以了)
    //4.此属性也必须声明为static的
    private static Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    //3.使用getXxx()方法获取当前类的实例，必须声明为static的
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public static Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

④测试

使用当前类的唯一实例。

package yuyi04;

/**
 * ClassName: BankTest
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/17 0017 8:43
 */
public class BankTest {
    public static void main(String[] args) {
        //使用当前类的唯一实例
        Bank bank1=Bank.getInstance();

        //再通过getInstance方法获取另外一个所谓的实例，其实和上面的实例指向同一个
        Bank bank2=Bank.getInstance();

        //测试
        System.out.println(bank1==bank2);
    }
}

class Bank{ //假设这个银行只有一个实例：中国人民银行

    //1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    //2.在类的内部创建当前类的实例 (一个就可以了)
    //4.此属性也必须声明为static的
    private static Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    //3.使用getXxx()方法获取当前类的实例，必须声明为static的
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public static Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

输出结果：

2. 懒汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }
}

【举例】

场景：GirlFriend只能有一个实例。

package yuyi04;

/**
 * ClassName: GirlFriend
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/17 0017 9:24
 */
public class GirlFriendTest {
    public static void main(String[] args) {

    }
}

class GirlFriend{

}

①**类的构造器私有化 **

class GirlFriend{
    //1.类的构造器私有化 
    private GirlFriend(){

    }
}

②声明当前类的实例，作为一个属性出现。

这时候并没有创建这个对象。

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    //2.声明当前类的实例，作为一个属性出现
    //和刚才一样，外边不能造对象了，里边就得造。里面造和上一种方法的区别就在于这里只是做了一个声明。
    private GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null
}

③通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建。

通过get方法去调用的时候，发现没有实例化，就帮忙造一下。

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    
    //2.声明当前类的实例，作为一个属性出现
    //和刚才一样，外边不能造对象了，里边就得造。里面造和上一种方法的区别就在于这里只是做了一个声明。
    private GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null

    
    //3.通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建
    /*public GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
            return instance;    //创建好实例之后返回即可
        }else{  //若之前已经创建好对象了，直接return就好
            return instance;
        }
    }*/

    public GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
        }
        //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
        return instance;
    }
}

这里优化一下，如下：

④静态化属性和方法

和饿汉式一样，getInstance方法需要通过类来调用，所以这里也需要加上static。如下：

public static GirlFriend getInstance(){
    if(instance==null){ //若此时没有实例化，就实例化一下
        instance=new GirlFriend();
    }
    //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
    return instance;
}

然后静态方法里面只能调静态的，所以instance也要加上static。如下：

private static GirlFriend instance=null;

现在整体的GirlFriend如下：

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    //2.声明当前类的实例，作为一个属性出现
    //4.此属性也必须声明为static的
    private static GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null


    //3.通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建
    public static GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
        }
        //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
        return instance;
    }
}

3. 饿汉式 vs 懒汉式

饿汉式：

特点：立即加载，即在使用类的时候已经将对象创建完毕。
优点：实现起来简单；没有多线程安全问题。
缺点：当类被加载的时候，会初始化static的实例，静态变量被创建并分配内存空间，从这以后，这个static的实例便一直占着这块内存，直到类被卸载时，静态变量被摧毁，并释放所占有的内存。因此在某些特定条件下会耗费内存。

懒汉式：

特点：延迟加载，即在调用静态方法时实例才被创建。
优点：实现起来比较简单；当类被加载的时候，static的实例未被创建并分配内存空间，当静态方法第一次被调用时，初始化实例变量，并分配内存，因此在某些特定条件下会节约内存。
缺点：在多线程环境中，这种实现方法是完全错误的，线程不安全，根本不能保证单例的唯一性。
- 说明：在多线程章节，会将懒汉式改造成线程安全的模式。

【举例】

还是拿上面两个例子作比较，如下：（这里过滤掉属性了，针对当前创建的实例没有任何属性，它不属于单例模式的核心问题，这里就过滤掉了）

“饿汉式”一上来就把对象创建好了（立即加载），静态声明的变量随着类的加载而加载，比较早得出现在内存当中，需要用得时候直接拿来用；同样随着类的消亡而消亡，其实并不会轻易卸载类，类都加载到方法区内，GC回收方法区的频率非常低，此时试图卸载一个类也非常困难，因为这个类可能会在任意地方被使用（包括被类的加载器所引用，类的加载器不消亡它也不会消亡，同样静态变量也消除不了，所以在内存中占用时间就会很长）。

“懒汉式”一上来没有创建，当需要的时候才创建（延时加载）。

从内存节省的角度来说，“懒汉式”比较好，“饿汉式”实例的生命周期有点长。

之前说过的“内存泄露”-- 本身是个垃圾，但是GC还没有帮我们回收。在一定程度上来说，有的变量也谈不上泄露，但是它的生命周期特别长，使用的时间又特别短，多余的时间不想要（可以回收掉），但是它是静态的，导致生命周期很长却没有办法回收，一定程度上也可以认为是泄露（生命周期过长，超出了使用的范围）。

【对比两种模式】（特点、优缺点）

特点
- 饿汉式：“立即加载”，随着类的加载，当前的唯一实例就创建了。
- 懒汉式：“延迟加载”，在需要使用的时候，进行创建。
优缺点
- 饿汉式：（优点）写法简单，由于内存中较早加载，使用更方便、更快。是线程安全的。（缺点）内存中占用时间较长。
- 懒汉式：（缺点）线程不安全（有可能会创建好几次对象，放到多线程章节时解决）（优点）在需要的时候进行创建，节省内存空间。

（5）单例模式的优点及应用场景

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

举例：

Java中有一个类叫Runtime（运行时环境），单例设计模式–饿汉式，如下：

应用场景

Windows的Task Manager (任务管理器)就是很典型的单例模式。
Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
Application 也是单例的典型应用。
应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只
能有一个实例去操作，否则内容不好追加。
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

二、理解main方法的语法

（1）main()方法的剖析

public static void main(String args[]){
    
}

理解1：看做是一个普通的静态方法。

理解2：看做是程序的入口，格式是固定的。

解释：

public–此方法权限很大，在整个项目中都能看得到。

static–静态的，随着类的加载而加载。main方法是程序的入口，不能说一上来就造一个本类的对象，若是造对象才能掉方法，但是造对象的方法也得在程序入口里面做，卡死了。所以这个时候方法不能拿对象去调，只能拿类去调，所以只能是static的。

void–这个方法执行完也不需要返回，也没有可以返回的结构了，已经是最基础的方法了。

main–这个方法比较特别，是程序的入口，所以写成main表示入口的意思。

由于JVM需要调用类的main()方法，所以该方法的访问权限必须是public，又因为JVM在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。

【举例】

package yuyi04;

/**
 * ClassName: MainTest
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/18 0018 20:55
 */
public class MainTest {
    public static void main(String[] args) {    //程序的入口
        //造一个String类型的数组
        String[] arr=new String[]{"AA","BB","CC"};

        //通过Main类来调用此类中的静态方法main()
        Main.main(arr);
    }
}

class Main{
    public static void main(String[] args) {    //看作是普通的静态方法
        //把参数对应的数组遍历一下
        System.out.println("Main的main()的调用");
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

输出结果：

（2）与控制台交互

可以发现，main方法带了一个形参String args[]，到目前为止好像没有用过它，有啥用呢？

💬如何从键盘获取数据？

方式1：使用Scanner（传的是各种类型）

方式2：使用main()的形参进行传值。（只能传递String类型）

1.举例1

先写一段代码。

【MainDemo.java】

package yuyi04;

/**
 * ClassName: MainDemo
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 7:38
 */
public class MainDemo {
    public static void main(String[] args) {    //当我们调用main方法时，传递了一个String数组
        for (int i = 0; i < args.length; i++) { //遍历打印
            System.out.println("hello:"+args[i]);
        }
    }
}

1.1 方式一、命令行

先将文件【MainDemo.java】复制到一个文件夹中，比如D盘：

命令行的时候没有包的概念，记得将第一行导包注释掉，如下：

记得将文件的字符集改为“ANSI”，因为黑窗口的字符集默认GBK，如下：

改为ANSI，才不会乱码：

执行文件：

由于代码没有输入任何数据，所以args.length是0，就没有任何执行效果啦。

那如何传呢？

在写完类名的时候，再写一个空格，后边就可以输入数据了，第一个要加双引号，后边可以不用，中间用空格隔开，注意一定要是英文格式下。比如：java MainDemo "Tom" Jarry 89 true，回车之后便可输出，如下：

相当于args数组的长度是4，依次遍历了它的元素。（从控制台获取String类型的数据）

在代码层面，可以把89转化为int类型，把true转化为boolean类型。（讲包装类的时候再说这个问题）

1.2 方法二、编译器

上面演示了命令行的方式，那么在idea编译器中如何体现传值呢？

先配置一下。

“运行”–>“编辑配置”：

可以看到如下信息：

找到这个地方，点击它：

然后输入“MainDemo”，选中这个文件：

现在就可以在这个地方输入了：

比如：（中间用空格隔开）

回到编译器中再次Run，可以发现刚才的数据输出了：

其实还有其他的方法，这里做了解就好，不必追究。

2.举例2

代码部分：

public class CommandPara {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

//运行程序CommandPara.java
java CommandPara "Tom" "Jerry" "Shkstart"

IDEA工具：

（1）配置运行参数

（2）运行程序

输出：

//输出结果
args[0] = Tom
args[1] = Jerry
args[2] = Shkstart

（3）笔试题

如下：

//此处，Something类的文件名叫OtherThing.java
class Something {
    public static void main(String[] something_to_do) {        
        System.out.println("Do something ...");
    }
}


//上述程序是否可以正常编译、运行？	可以