Java基础之关键字

【写在前面】
本文功能性地介绍了Java中常用的关键字，关于这些关键字的实现原理，后续会有相应文章详细说明；

一、关于关键字

关键字一词我们都不陌生，现实生活中有意无意间都有所接触，比如我们每个人的身份证号，就是一个关键字。在计算机世界，关键字应用的也极为广泛，在搜索引擎中，我们通过关键字搜索到我们想要的东西；在数据库中，主键(primary key)也是关键字，用来唯一地标识表中的某一条记录......。而在Java中，关键字则是由编程语言定义的词，具体定义如下:
Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。（转自百度百科）

二、Java常用关键字

1、boolean/true/false/byte/char/short/int/long/float/double

之所以把这10个关键字放在一起，是因为这些关键字是Java基本数据类型或基本类型的值。具体细节将在后续博文《Java基础之数据类型》中讲解。

boolean是布尔类型，即真实世界中的是非，所以它的取值有两个，也就是关键字true和false；

public class BooleanTest {
    public static void main(String[] args) {
        boolean sunday = true;
        if (sunday == true) {
            System.out.println("今天是晴天");
        }
    }
}
复制代码

byte是字节类型，占用1个字节大小存储空间，所以它可以表示-128~127之间的数；

public class ByteTest {
    public static void main(String[] args) {
        byte b1 = 125;
      //byte b2 = 1024; //编译报错
    }
}
复制代码

char是字符类型，用来表示字符，由于Java使用Unicode编码方式，所以它占用2个字节大小存储空间；

public class CharTest {
    public static void main(String[] args) {
        char c1 = 'a'; //c1表示一个字符
    }
}
复制代码

short是短整型，占用2个字节，可以用来表示-32768~32767之间的整数；
int是整型，占用4个字节，可以用来表示-2³²~2³²-1之间的整数；
long是长整型，占用8个字节，可以用来表示-2⁶⁴~2⁶⁴-1之间的整数；
float是浮点类型，占用4个字节，可以用来表示3.4e-45~1.4e38之间的浮点数；
double是双精度类型，占用8个字节，可以用来表示4.9e-324~1.8e308之间的浮点数；

2、if/else/switch/case

之所以将这4个关键字放在一起，是因为它们都是Java中的判断结构，其中if...else可配套使用，switch...case可配套使用。代码如下:

public class JudgeTest {
    //两种判断选择结构demo
    public static void test(int flag) {
        //demo1
        if (flag == 1) {
            System.out.println("success");
        }else {
            System.out.println("fail");
        }
        
        //demo2
        switch(flag) {
            case 1: 
                System.out.println("success"); 
                break;
            default:
                System.out.println("fail");
        }
    }
}
复制代码

3、for/do/while

这三个关键字可以实现Java中3种不同的循环结构,代码如下：

public class RollTest {
    //3种循环结构demo
    public static void test(int n) {
        int sum1 = 0;
        int sum2 = 0;
        int sum3 = 0;
        //demo1
        for(int i = 0; i <= n; i ++) {
            sum1 += i;
        }
        
        //demo2
        int j = 0;
        do {
            sum2 += j++;
        }while(j <= n);
        
        //demo3
        int k = 0;
        while(k <= n) {
            sum3 += k++;
        }
    }
}
复制代码

其中，do...while结构中的循环体至少执行一次。

4、continue/break

循环控制结构。

continue用于跳过循环中的一个迭代，回到循环起始处，进行下一次循环操作；
break用于跳出当前循环体，不再执行剩余的代码。

public class RollControlTest() {
    //循环控制演示demo
    public static void test() {
        for (int i = 0; i <= 2; i ++) {
            for (int j = 0; j <=2; j ++) {
                if (j == 1) {
                    continue; //跳过此次迭代，不执行下一条语句，而是回到j++,执行j=2时的流程
                }
                System.out.println("我是傻子");
            }
        }
            
        for (int m = 0; m <= 2; m ++) {
            for (int n = 0; n <=2; n ++) {
                if (n == 1) {
                    break; //跳出当前循环体，不执行后续循环流程，而是回到m++
                }
                System.out.println("我是傻子");
            }
        }
    }
}
复制代码

5、private/protected/public

Java中用于访问权限控制的关键字。

private一般称之为“私有的”，被其修饰的字段或方法只能在本类内部被访问；
protected一般称之为“保护访问权限”，被其修饰的字段或方法能在本类内部或子类中被访问；
public一般称之为“公有的”，被其修饰的字段或方法不仅可以跨类使用，而且还可以跨包使用。
关于访问权限控制，除了以上3个关键字，Java中还有“默认访问权限”，即不加任何访问修饰符，拥有默认访问权限的字段或方法能被和该字段或方法所在类在同一个包中的其它类访问。

6、try/catch/finally

这三个关键字正好是一个完整的Java异常处理机制。

try用于监听可能会出现异常的语句块；
catch用于捕捉try语句块中抛出的异常；
finally语句块中语句几乎必定是被执行的，试想如果在try{}中打开了文件，而在处理文件时出现了异常，若不在finally中关闭文件，会带来不必要的资源消耗。

public class ExceptionTest {
    public static void test() {
        try {
            //打开文件
            //处理逻辑
        }catch (Exception e) {
            //异常处理逻辑
        }finally {
            //关闭文件
        }
    }
}
复制代码

7、throw/throws

这两个关键字用于抛出异常，不同点在于:

throw用在方法体内部，用于抛出一个具体的异常对象(throw new 异常类型)，作用类似于return；
throws用在方法声明上，表示该方法不处理异常，而是将异常交给调用者来处理

public class ThrowTest {
    public static void test() throws NullPointerException{ //将异常交给调用者处理
        throw new NullPointerException(); //抛出具体的异常类型
    }
    
    public static void main(String[] args) {
        try {
            test();
        }catch(NullPointerException e){   //调用者处理异常
            //处理异常
        }
    }
}
复制代码

8、extentds/implements

extends用于子类继承父类，implements用于子类实现接口

public class A extends B implements I1, I2 {
    //Java仅支持单继承，每个类至多有1个父类
    //Java支持多实现，每个类可以实现0或多个接口
}
复制代码

9、static

静态成员变量，也即类成员变量

public class StaticTest {
    public static int a = 1; //静态字段
    public static void test() { //静态方法
        
    }
}
复制代码

10、default

据我目前所知，default关键字的使用场景有二：

用在switch语句块中，当所有case都不匹配时，执行default语句块中的语句；
用在接口中，在jdk1.7之前，接口中的方法都只能是抽象方法，即被abstract修饰。在jdk1.8及以后，接口中可以有default方法，default方法有方法实现，这样多个类在实现该接口时，该方法就不需要被多次实现，减少了代码冗余。
```
public interface I {
    public default void test() {
        //
    }
}
复制代码
```

11、synchronized/volatile

synchronized是一个用于线程同步的关键字，当某个方法被synchronized修饰时，该方法在同一时刻只能被一个线程访问，其他线程只能等待，从而保证了线程安全性；
volatile关键字保证了内存的可见性，当某个线程修改了被volatile修饰的共享变量时，其他线程能够及时知道

12、final

final关键字表义为不变的，可用来

修饰基本类型，该变量恒定不变
修饰引用类型，该引用恒定不变，无法关联其它对象
修饰方法，该方法不能被重写
修饰类，该类不能被继承

13、abstract

abstract关键字表示抽象的，可用来

修饰方法，抽象方法没有实现，只有方法声明，当类被继承时实现该方法

修饰类，抽象类，不能实例化对象

public abstract class C {
    //抽象类中可以有抽象方法，也可以没有
    //抽象方法，只有声明，没有实现
    public abstract void test();
}
复制代码

14、new

new关键字用于创建一个对象

public class C {
    public static void main(String[] args) {
        //创建对象
        C c = new C();
    }
}
复制代码