Java 基础进阶篇（一）——— static 静态关键字与单例模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了Java 基础进阶篇（一）——— static 静态关键字与单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、static 静态关键字

static：代表静态的意思，可以修饰成员变量，可以修饰成员方法。

static 修饰方法之后称为静态方法（类方法），修饰成员变量之后称为静态成员变量（类变量）。

static 修饰后的成员变量，可以被类的所有对象共享 (访问、修改)。

1.1 静态成员变量与实例成员变量

	静态成员变量	实例成员变量
概述	有 static 修饰，属于类，与类一起优先被加载，内存中只有一份，可以被共享访问。	无 static 修饰，属于对象，每个对象中都存在一份实例成员变量。
场景	如果信息要被共享，只需要一份就用，如：系统在线人数。	属于每个对象，且每个对象的该信息不同时，如:nameage,money…
访问规则

注意： 同一个类中，访问静态成员可以省略类名不写。

1.2 静态成员方法与实例成员方法

	静态成员方法	实例成员方法
概述	有 static 修饰，属于类，与类一起优先被加载一次，可以被共享访问。	无 static 修饰，属于对象，必须用对象触发访问。
场景	如果该方法是以执行一个通用功能为目的，或者需要方便访问。	如表示对象自己的行为的，且方法中需要直接访问实例成员。
访问规则

注意： 同一个类中，访问静态成员方法可以省略类名不写。

1.3 static 访问注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
另外，静态方法中是不可以出现 this 关键字的。

Java 基础进阶篇（一）——— static 静态关键字与单例模式

public class Test {
    // 静态成员
    public static int onlineNumber = 10;
    // 实例成员
    private String name = "heima";

    /**
     * 静态方法
     */
    public static void fun1(){
        // 静态成员方法可以访问 静态成员
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);
        // System.out.println(name); // 报错
        
        // 静态成员方法不可以直接访问实例成员
        Test test = new Test();
        System.out.println(test.name); // 间接访问
		// System.out.println(this); // 报错
    }

    /**
     * 实例方法
     */
    public void fun2(){
        // 实例方法可以访问 实例成员
        System.out.println(this.name);
        System.out.println(name);

        // 实例方法可以访问 静态成员
        System.out.println(Test.onlineNumber);
        System.out.println(this.onlineNumber); // 不推荐
    }
}

1.4 内存使用情况

访问静态成员变量：与类一起优先加载。
访问静态成员方法：与类一起优先加载。

二、工具类

工具类里面都是静态方法，可以完成一个共用功能。

好处： 一次编写，处处可调，提高代码的复用，提高开发的效率。
注意：建议把工具类的构造器私有化，因为工具类无需对外创建对象，它的方法都是静态方法，直接用类名访问即可。

三、代码块

类的 5 大成分：成员变量、成员方法、构造器、代码块、内部类。

	静态代码块 ★	实例代码块
格式	`static {…}`	`{…}`
特点	属于类，与类一起优先加载，自动触发执行一次。	属于对象的，每次调用构造器构建对象前都会执行一次，再执行构造器。
作用	可以用于在程序启动时，进行静态资源的初始化操作。	可以用于初始化实例资源。

四、单例模式

单例模式： 可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如：任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

4.1 饿汉单例

特点： 拿对象时，对象已经存在。
实现： ① 构造器私有 ② 定义静态成员变量存储一个对象。

/**
 * 使用 饿汉单例实现单例类
 */
public class SingleInstance {

    /**
     * 2. 饿汉单例是在获取对象前，对象已经提前准备好了一个
     *    这个对象只能是一个，所以定义静态成员变量记住。
     *    属于类，只被加载一次
     */
    public static SingleInstance instance = new SingleInstance();


    /**
     * 1. 必须把构造器私有化
     */
    private SingleInstance(){
    }
}

4.2 懒汉单例

特点： 要拿对象的时候，才开始创建一个对象。
实现： ① 构造器私有 ② 定义静态成员变量，暂时不存对象。

/**
 * 使用 懒汉单例实现单例类
 * 在真正需要该对象的时候，才去创建一个对象（延迟加载对象）
 */
public class SingleInstance2 {

    /**
     * 2. 定义一个静态的成员变量负责存储一个对象
     *    只加载一次，只有一份
     *    如果设置为 public 那么其他类可通过 SingleInstance2.instance 访问，访问结果是 null
     *    因此最好是私有化，避免挖坑
     */
    private static SingleInstance2 instance;

    /**
     * 3. 提供一个方法，对外返回单例对象
     */
    public static SingleInstance2 getInstance(){
        if(instance == null){
            instance = new SingleInstance2();
            return instance;
        }
        return instance;
    }

    /**
     * 1. 必须把构造器私有化
     */
    private SingleInstance2(){
    }
}