02-Java常用关键字理解(基础)

注:源码系列文章主要是对某付费专栏的总结记录。如有侵权,请联系删除。

1 static

1.1 静态变量

  • 静态变量:又称为类变量,也就是说这个变量属于类,类所有的实例都共享静态变量,可以直接通过类名来访问它。静态变量在内存中只存在一份;
  • 实例变量:每创建一个实例就会产生一个实例变量,它与该实例共生共死。
public class StaticExample {
    // 静态变量
    public static int ID = 1;
    // 实例变量
    private String name;

    public StaticExample() {
        this.name = "李雷";
    }

    // TEST
    public static void main(String[] args) {
        // 静态变量直接通过类名访问
        System.out.println(StaticExample.ID);

        // 实例变量
        StaticExample example = new StaticExample();
        System.out.println(example.name);
    }
}

1.2 静态方法

静态方法在类加载的时候就存在了,它不依赖于任何实例,所有静态方法必须有实现,也就是说它不能是抽象方法。

静态方法只能调用同样被 static 修饰的方法或属性,不能调用普通方法,我们常用的 util 类里面的各种方法,我们比较喜欢用 static 修饰方法,好处就是调用特别方便。

static 方法内部的变量在执行时是没有线程安全问题的。方法执行时,数据运行在栈里面,栈的数据每个线程都是隔离开的,所以不会有线程安全的问题,所以 util 类的各个 static 方法,我们是可以放心使用的。

public static void print(String... args) {
    for (String arg : args) {
        System.out.print(arg + " ");
    }
}

1.3 静态代码块

静态代码块在类初始化时只运行一次。

public class A {

    static {
        System.out.println("static code block");
    }

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

执行结果:

static code block

1.4 静态内部类

略。

1.5 静态导包

在使用静态变量和方法时,不用在指明 ClassName,从而简化代码,但可读性大大降低。

import com.alibaba.fastjson.JSON;
import com.google.common.base.Splitter;

import java.util.List;

public class A {

    public static void main(String[] args) {
        // 不用指明 ClassName
        System.out.println(StaticExample.ID);

        // 非静态需要导包, 也就是指明 ClassName
        Splitter splitter = Splitter.on(",");
        List list = splitter.trimResults().omitEmptyStrings().splitToList("a,b,c,d");
        System.out.println(JSON.toJSONString(list));
    }
}

1.6 执行顺序

静态变量和静态代码块优先于实例变量和普通代码块执行,静态变量和静态代码块的初始化顺序取决于它们在代码中的顺序。如下:

静态变量/静态代码块 -> 实例变量/普通代码块 -> 构造函数

存在继承情况下,初始化顺序为:

  1. 父类(静态变量、静态代码块)
  2. 子类(静态变量、静态代码块)
  3. 父类(实例变量、普通代码块)
  4. 父类(构造函数)
  5. 子类(实例变量、普通代码块)
  6. 子类(构造函数)

static 修饰的方法,在类初始化的时候并不会初始化,只有当自己被调用时,才会被执行。

2 final

2.1 数据

声明数据为 final,可以是编译时常量,也可以是在运行时被初始化后不能被改变的常量。

  • 对于基本类型,final 使数值不变;
  • 对于引用类型,final 使引用不变,也就不能引用其它对象,但是被引用的对象本身是可以修改的。
public class FinalExample {

    int a;

    public static void main(String[] args) {
        // 基本类型
        final int b = 100;
        // 改变基本类型
        // b = 200; // Cannot assign a value to final variable 'b'

        // 引用类型
        final FinalExample example = new FinalExample();
        System.out.println(example.a);
        example.a = 1;
        System.out.println(example.a);
    }
}

一般用于以下三种场景:

  1. 被 final 修饰的类,表明该类是无法继承的;
  2. 被 final 修饰的方法,表明该方法是无法覆盖的;
  3. 被 final 修饰的变量,说明该变量在声明的时候,就必须初始化完成,而且以后也不能修改其内存地址。

第 3 点需要注意,我们说的是无法修改其内存地址,并没有说无法修改其值。因为对于 List、Map、自定义Object 这些类来说,被 final 修饰后,是可以修改其内部值的,但却无法修改其初始化时的内存地址。如:String 被 final 修饰;String 存储数据的 char 数组被 final 修饰;上面的 FinalExample 等。

3 try、catch、finally

这三个关键字常用于捕获异常的一整套流程,try 用来确定代码范围,catch 捕获可能发生的异常,finally 用来执行一定要执行的代码块(如 IO流的关闭)。除了这些地方我们还需要清楚的知道,每个地方如果发生异常会怎么办。如:

public static void main(String[] args) {
    try {
        log.info("try run.");

        if(true) {
            throw new RuntimeException("try exception");
        }
    } catch (Exception e) {
        log.info("catch run: " + e.getMessage());

        if(true) {
            throw new RuntimeException("catch exception");
        }
    } finally {
        log.info("finally run.");
    }
}

总结:

  1. finally 先执行后,再抛出 catch 的异常;
  2. 最终捕获的异常是 catch 的异常,try 抛出来的异常已经被 catch 吃掉了,所以当我们遇见 catch 也有可能抛出异常时,可以先打印出 try 的异常信息,这样 try 的异常在日志中就会有所体现。

4 volatile

volatile 的意思是可见的,常用来修饰某个共享变量,意思是当共享变量的值被改变后,会及时通知到其它线程上,其它线程就能知道当前共享变量的值已经被修改了。

在多核 CPU 下,为了提高效率,线程在拿值时,是直接和 CPU 缓存交互的,而不是内存。主要是因为 CPU 缓存执行速度更快,比如线程要拿值 C,会直接从 CPU 缓存中拿,CPU 缓存中没有,才会从内存中拿,所以线程读的操作永远都是拿 CPU 缓存的值。

这个时候会产生一个问题,CPU 缓存中的值和内存中的值可能并不是时刻都同步,导致线程计算的值可能不是最新的,共享变量的值有可能已经被其它线程所修改了,但此时修改的是机器内存的值,CPU 缓存的值还是老的,导致计算会出现问题。

这时候有个机制,就是内存会主动通知 CPU 缓存。当前共享变量的值已经失效了,你需要重新来拉取一份,CPU 缓存就会重新从内存中拿取一份最新的值。

volatile 关键字就会触发这种机制,加了 volatile 关键字的变量,就会被识别成共享变量,内存中的值一旦被修改后,就会通知各个 CPU 缓存,使 CPU 缓存中的值也对应被修改,从而保证线程从 CPU 缓存中拿去出来的值是最新的。

-

从图中看到,线程 1 和线程 2 一开始都读取了 C 值,CPU 1 和 CPU 2 缓存中也都有了 C 值,然后线程 1 把 C 值修改了,这时候内存中 C 值和 CPU 2 缓存中的 C 值就不等了,内存这是发现 C 值被 volatile 关键字修饰,发现其实共享变量,就会使 CPU 2 缓存中的 C 值状态置为无效,CPU 2 会从内存中重新拉取一份最新的 C 值到缓存,。这时候线程 2 再来读取缓存中的 C 值,读取的已经是内存中最新的值了。

5 transient

transient 关键字用来修饰类变量,意思是当前变量是无需进行序列化的。在序列化时,会忽略该变量。如:ArrayList 对内部存储数据 elementData 使用 transient 修饰 transient Object[] elementData,因为 elementData 数组并不会存储满,所以无需全部序列化,这里重写了 writeObjectreadObject

6 default

default 关键字一般会用在接口的方法上,意思是对于该方法,子类是无需强制实现的,但自己必须有默认的实现,如:

public interface DefaultExample {

    default void print() {
        System.out.println("default method");
    }
}

7 面试题

7.1 如何证明 static 静态变量和类实例无关?

答:从三个方面就可以看出静态变量和类无关。

  1. 我们不需要初始化类就可以直接使用静态变量;
  2. 我们在类中执行 main 方法,即使不写初始化类的代码,静态变量也会自动初始化;
  3. 静态变量只会初始化一次,初始化完成之后,不管我们再 new 多少个类出来,静态变量都不会再初始化了。

不仅仅是静态变量,静态方法块也和类无关。

7.2 常常看见变量和方法被 static 和 final 两个关键字同时修饰,为什么这么做?

答:这么做有两个目的:

  1. 变量和方法于类无关,可以直接使用,使用比较方便;
  2. 强调变量内存地址不可变,方法不可以被继承覆写,强调了方法内部的稳定性。

7.3 catch 中发生了未知异常,finally 还会执行么?

答:会的。catch 发生了异常,finally 还会执行的,并且 finally 执行完之后,才会抛出 catch 中的异常。

捕获 catch 会吃掉 try 中抛出的异常,为了避免这种情况,在一些可以预见的 catch 中会发生异常的地方,先把 try 抛出的异常打印出来,这样从日志中就可以看到完成的异常信息了。

7.4 vilatile 关键字的作用和原理

答:参考上文。

------------------------------------- END -------------------------------------

你可能感兴趣的:(02-Java常用关键字理解(基础))