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 的特性:
- 保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。(实现可见性)
- 禁止进行指令重排序。(实现有序性)
- volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。
transient
transient 关键字我们常用来修饰类变量,意思是当前变量无需进行序列化。在序列化时,就会忽略该变量,这些在序列化工具底层就已经对 transient 进行了支持。
default
default 关键字一般会用在接口的方法上,意思是对于该接口,子类是无需强制实现的,但自己必须有默认实现。