Java 常用关键字理解

最新推荐文章于 2022-09-21 13:59:16 发布

章全蛋

最新推荐文章于 2022-09-21 13:59:16 发布

阅读量234

点赞数

分类专栏：面经

本文链接：https://blog.csdn.net/qq_41049126/article/details/118029912

版权

面经专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Java 常用关键字理解

Java 中的关键字很多，大约有 50+，在命名上我们不能和这些关键字冲突，编译会报错，每个关键字都代表着不同场景下的不同含义。

static

意思是静态的、全局的，一旦被修饰，说明被修饰的东西在一定范围内是共享的，谁都可以访问，这时候需要注意并发读写的问题。

修饰的对象

static 只能修饰类变量、方法和代码块

修饰类变量

当 static 修饰类变量时，如果该变量时 public 的话，表示该变量任何类都可以直接访问，而且无需初始化类，直接使用 类名.变量 这种形式访问即可。

这个好我们要非常注意的一点就是线程安全的问题了，因为当多个线程同时对共享变量进行读写时，很有可能会出现并发问题，如我们定义了

public static List<String> list = new ArrayList();

这个 list 如果同时被多个线程访问的话，就有线程安全的问题，这时候一般有两种解决方法：

把线程不安全的 ArrayList 换成线程安全的 CopyOnWriteArrayList；
每次访问时，手动加锁。

修饰方法

当 static 修饰方法时，代表该方法和当前类是无关的，任意类都可以直接访问（如果权限是 public 的话）

有一点需要注意的是，该方法内部职能调用同样被 static 修饰的方法，不能调用普通方法，我们常用的 util 类里面的各种方法，我们比较喜欢用 static 修饰方法，好处就是调用特别方便。

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

修饰方法块

当 static 修饰方法块时，我们叫做静态块，静态块常常用于在类启动之前，初始化一些值，比如

public static List<String> list = new ArrayList();
// 进行一些初始化的工作
static {
    list.add("aaa");
}

这段代码演示了静态代码块做一些初始化的工作，但需要注意的是，静态代码块只能调用同样被 static 修饰的变量，并且 static 变量需要写在静态代码块的前面，不然编译会报错

初始化时机

对于被 static 修饰的类变量、方法块、代码块的初始化时机如下：

public class StaticParentTest {

    public static List<String> PARENT_LIST = new ArrayList<String>(){{
        System.out.println("父类静态变量初始化");
    }};

    static {
        System.out.println("父类静态代码块初始化");
    }

    public StaticParentTest() {
        System.out.println("父类构造器初始化");
    }

    public static void test(){
        System.out.println("父类静态方法被调用");
    }
}

public class StaticChildTest extends StaticParentTest{
    
    public static List<String>  CHILD_LIST = new ArrayList<String>(){{
        System.out.println("子类静态变量初始化");
    }};
    
    static {
        System.out.println("子类静态代码块初始化");
    }

    public StaticChildTest() {
        System.out.println("子类构造器初始化");
    }

    public static void test(){
        System.out.println("子类静态方法被调用");
    }

    public static void main(String[] args) {
        System.out.println("main 方法执行");
        new StaticChildTest();
    }
}

输出如下

父类静态变量初始化
父类静态代码块初始化
子类静态变量初始化
子类静态代码块初始化
main 方法执行
父类构造器初始化
子类构造器初始化

从结果中，我们可以看出两点

父类的静态变量和静态代码块比子类优先初始化；
静态变量和静态代码块比类构造器优先初始化。

final

final 的意思是不变的，一般来说用于以下三种场景：

被 final 修饰的类，表明该类是无法继承的；
被 final 修饰的方法，表明该方法是无法重写的；
被 final 修饰的变量，说明该变量在声明的时候，就必须初始化完成，而且以后也不能修改其内存地址。

第三点注意下，我们说的是无法修改其内存地址，并没有说无法修改其值。因为对于 List、Map 这些结合类来说，被 final 修饰后，是可以修改其内部值的，但却无法修改其初始化时的内存地址。

try 、catch、finally

这三个关键字常用于我们捕捉异常的一整套流程，try 用来确定代码执行的范围，catch 捕捉可能发生的异常，finally 用来执行一定要执行的代码块。

public class TryCatchFinallyTest {
    public static void main(String[] args) {
        try {
            System.out.println("try is run");
            if (true){
                throw new RuntimeException("exception...");
            }
        }catch (Exception e){
            System.out.println("catch exception");
            if (true){
                throw new RuntimeException("exception2...");
            }
        }finally {
            System.out.println("finally is run");
        }
    }
}

try is run
catch exception
finally is run
Exception in thread "main" java.lang.RuntimeException: exception2...
	at com.study.interview.TryCatchFinallyTest.main(TryCatchFinallyTest.java:13)

这个代码演示了在 try、catch 中都遇到了异常，代码执行的顺序为 try -> catch -> finally ，可以看到两点：

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

volatile

我们在说原理之前，先说下基础知识。就是在多核 CPU 下，为了提高效率，线程在拿值时，是直接和 CPU 缓存打交道的，而不是内存。主要是因为 CPU 缓存执行速度更快，比如线程要拿值 C，会直接从 CPU 缓存中拿，CPU 缓存中没有，就会从内存中拿，所以线程读的操作永远都是拿CPU 缓存的值。

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

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

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

volatile 的特性：