1.Java 中的关键字是指什么？有哪些关键字？

（1）Java 关键字是对 Java 编译器有特殊含义的字符串，是编译器和程序员的一个约定，程序员利用关键字来告诉编译器其声明的变量类型、类、方法特性等信息。

（2）Java语言共定义了如下所示的关键字：

分类	关键字
访问控制	private、protected、public
类，方法和变量修饰符	abstract、class、extends、final、implements、interface、native、new、static、strictfp、synchronized、transient、volatile、enum
程序控制	break、continue、return、do、while、if、else、for、instanceof、switch、case、default、assert
错误处理	try、catch、throw、throws、finally
包相关	import、package
基本类型	boolean、byte、char、double、float、int、long、short
变量引用	super、this、void
保留字	goto、const

（3）注意事项：

• 所有的关键字均是小写的，并且在 IDE 中会以特殊的颜色显示；
• 在所有关键字中，default 这一关键字较为特殊，它既属于程序控制，也属于类，方法和变量修饰符，还属于访问控制；
  • 在程序控制中，当在 switch 中匹配不到任何情况时，可以使用 default 来编写默认匹配的情况；
  • 在类，方法和变量修饰符中，从 JDK8 开始引入了默认方法，可以使用 default 关键字来定义一个方法的默认实现；
  • 在访问控制中，如果一个方法前没有任何修饰符，则默认会有一个修饰符 default，但是加上这个修饰符反而会报错。

2.instanceof 关键字的作用是什么？

instanceof 严格来说是 Java 中的一个双目运算符，用来测试一个对象是否为一个类的实例，具体用法如下：

boolean result = obj instanceof Class

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回 false。此外，编译器会检查 obj 是否能转换成右边的 class 类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。见下面的示例：

class A {
    
}

class AA extends A {
    
}

class AAA extends AA {
    
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        AA aa = new AA();
        AAA aaa = new AAA();
        System.out.println(a instanceof A);     //true
        System.out.println(a instanceof AA);    //false
        System.out.println(aa instanceof AAA);  //false
        System.out.println(aaa instanceof A);   //true
        
        int i = 0;
        System.out.println(i instanceof Integer);	//编译不通过，i 必须是引用类型，不能是基本类型
        System.out.println(i instanceof Object);	//编译不通过
        
        //在 JavaSE 规范中，对 instanceof 运算符的规定是：如果 obj 为 null，那么将返回 false
        System.out.println(null instanceof Object);		//false
    }
}

3.访问修饰符 public、private、protected、以及不写（default）时的区别？

作用域	当前类	同包	子类	外部包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

类的成员不写访问修饰时默认为 default。默认对于同一个包中的其他类相当于公开 (public)，对于不是同一个包中的其他类相当于私有 (private)。受保护 (protected) 对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

4.Java 中有没有 goto 关键字?

（1）goto 是 Java 中的保留字，在 Java 8 中没有使用。但是其实 goto 是 C 语言中的，goto 语句通常与条件语句配合使用，可用来实现条件转移， 构成循环，跳出循环体等功能。而在结构化程序语言中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。但是在 Java 语言中，goto 只是作为了保留字，还没有使用，因为 Java 追求简单，方便。

5.在 Java 中，如何跳出当前的多重嵌套循环？

在要跳出的循环前加一个标记如 A，然后用 “break A” 可以跳出多重循环。Java 支持带标签的 break 和 continue 语句，作用有点类似于 C 和 C++中的 goto，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它可能会造成程序流程的混乱。例子如下：

class Test {
    public static void main(String[] args) {
        A: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(j + " ");
                if (j == 5) {
                    break A;
                }
            }
        }
    }
}

结果如下：

0 1 2 3 4 5 

6.switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上？

在 Java 5 以前，switch(expr)中，expr 只能是 byte、short、char、int。从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型，从 Java 7 开始，expr 还可以是字符串 (String)，但是长整型 (long) 在目前所有的版本中都是不可以的。

7.final 关键字在 Java 中的用法有哪些？

（1）被 final 修饰的类不能够被继承，所有的方法不可以被重写，但其内的非 final 变量可以被修改；
（2）被 final 修饰的成员变量必须要初始化，赋初值后不能再重新赋值（可以调用对象方法修改属性值），对基本类型来说是其值不可变；
（3）对引用变量来说其引用不可变，即不能再指向其他的对象，但对象中的内容可以变化；
（4）被 final 修饰的方法不能重写，但 JVM 会尝试将其内联，以提高运行效率；

8.static 关键字的用法有哪些？

（1）static 修饰变量
① 被 static 修饰的成员变量属于类，不属于某个对象（多个对象访问或修改 static 修饰的成员变量时，其中一个对象将 static 成员变量进行了修改，其他的对象的 static 成员变量值跟着改变），多个对象共享同一个 static 成员变量；
② 被 static 修饰的成员，可以通过类名直接访问；
③ 在静态方法中，不能访问非静态的内容（变量），不能使用 this/super；非静态中，可以访问静态中的变量；

（2）static 修饰方法
① static 修饰的方法被称之为静态方法，也叫类方法；
② 加 static 的方法，可以通过类名直接访问，也可以通过对象名访问，且不能再内部写this，因为直接用类名.方法的时候，没有当前对象。而不加 static 只能通过对象名访问；
③ 加了 static 的方法，不能在内部访问非 static 的属性和行为，因为在静态方法的内部无法确定非 static 的内容属于那个对象，它是通过类名调用。

（3）static 修饰代码块
① 静态代码块在非静态代码块之前执行（静态代码块—>非静态代码块—>构造方法）。
② 静态代码块只在第一次 new 执行一次，之后不再执行，而非静态代码块在每 new 一次就执行一次。非静态代码块可在普通方法中定义（不过作用不大）；而静态代码块不行。

（4）static 修饰类
① static 有一种特殊用法是修饰内部类（普通类是不允许声明为静态的，只有内部类才可以），被 static 修饰的内部类可以直接作为一个普通类来使用，而不需实例一个外部类；
② 当一个内部类没有使用 static 修饰的时候，不能直接使用内部类创建对象，需要先使用外部类对象+ . + new内部类对象。

9.this 和 super 这两个关键字有什么区别？

（1）this：

• 可以近似看作对象内部指代自身的引用，但不能将 super 与 this 赋给另一个对象变量；
• 解决成员变量和局部变量同名问题；
• 可以调用成员变量、成员方法，但是不能调用局部变量；
• this() 可以调用本类的构造器，但只限构造方法中使用，且必须是第一条语句；
• 在普通方法中可以省略 this，但在静态方法当中不允许出现 this 关键字；

（2）super：

• 代表对当前对象的直接父类对象的引用；
• 可以调用父类的非 private 成员变量和方法；
• super() 可以调用父类的构造方法，只限构造方法中使用，且必须是第一条语句；

class Demo {
    public Demo () {
        System.out.println("init Demo without arg...");
    }
    
    public Demo (int a) {
        System.out.println("init Demo with an arg...");
    }
}

public class SubDemo extends Demo{
    
    public SubDemo() {
        super(1);
        System.out.println("init SubDemo without arg...");
    }
    
    public SubDemo(int a) {
        //调用本类的无参构造方法，但注意不能在无参构造方法的第一行调用 this(1)，否则会出现构造方法循环调用
        this();
        System.out.println("init SubDemo with an arg...");
    }
    
    public SubDemo(int a, int b) {
        super();
        System.out.println("init SubDemo with two args...");
    }
    
    public static void main(String[] args) {
        SubDemo demo1 = new SubDemo(3);
        SubDemo demo2 = new SubDemo(3, 4);
    }
}

init Demo with an arg...
init SubDemo without arg...
init SubDemo with an arg...
init Demo without arg...
init SubDemo with two args...

10.throw 和 throws 的区别是什么？

（1）throw
① 表示方法内抛出某种异常对象（只能是一个）；
② 用于程序员自行产生并抛出异常；
③ 位于方法体内部，可以作为单独语句使用；
④ 如果异常对象是非 RuntimeException，则需要在方法申明时加上该异常的抛出，即需要加上 throws 语句或者在方法体内使用 try catch 处理该异常，否则编译报错；
⑤ 执行到 throw 语句则后面的语句块不再执行；

（2）throws
① 方法的定义上使用 throws 表示这个方法可能抛出某些异常（可以有多个）；
② 用于声明在该方法内抛出了异常；
③ 必须跟在方法参数列表的后面，不能单独使用；
④ 需要由方法的调用者进行异常处理；

package test;

import java.io.IOException;

class Solution {
    
    /**
     * 测试 throws 关键字
     * @throws NullPointerException
     */
    public static void testThrows() throws NullPointerException {
        Integer i = null;
        System.out.println(i + 1);
    }
    
    /**
     * 测试 throw 关键字抛出运行时异常
     * @param i
     */
    public static void testThrow(Integer i) {
        if (i == null) {
            //运行时异常不需要在方法上申明
            throw new NullPointerException();
        }
    }
    
    /**
     * 测试 throw 关键字抛出非运行时异常，需要方法体需要加 throws 异常抛出申明
     * @param filePath
     */
    public static void testThrow(String filePath) throws IOException {
        if (filePath == null) {
            //非运行时异常，需要方法体需要加 throws 异常抛出申明
            throw new IOException();
        }
    }
    
    public static void main(String[] args) {
        testThrows();
        
        Integer i = null;
        testThrow(i);
        
        String filePath = null;
        try {
            testThrow(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上述代码中三个方法对应的异常如下：

11.return 与 finally 的执行顺序对返回值有什么影响？

对于 try 和 finally 至少有一个语句块包含 return 语句的情况：
① 正常情况下（例如没有系统退出、出现异常等情况）finally 语句块会执行；
② 如果 finally 语句块中没有 return 语句，则 finally 对 return 语句中变量的重新赋值修改无效；
③ 如果 try 和 finally 语句块中都包含 return 语句，则 return 值会以 finally 语句块中的 return 值为准；

public class Test {
    public static void main(String args[]) {
        try {
            int a = 10 / 0;
            System.out.println(a);
        } catch (Exception e) {
            e.printStackTrace();
            //退出程序，finally 中的代码不会被执行
            System.exit(0);
        } finally {
            System.out.println("finally...");
        }
    }
}

结果如下：

java.lang.ArithmeticException: / by zero
	at test.Test.main(Test.java:8)

public static void main(String[] args) {
    System.out.println(getInt());
}

public static int getInt() {
    int a;
    try {
        a = 200;
        return a;
    } finally {
        System.out.println("finally...");
        a = 300;
    }
}

结果如下：

finally...
200

public static void main(String[] args) {
    System.out.println(getInt());
}

public static int getInt() {
    int a;
    try {
        a = 200;
        return a;
    } finally {
        System.out.println("finally...");
        a = 300;
        return a;
    }
}

结果如下：

finally...
300

12.什么时候用 assert？如何使用 assert？

（1）assertion（断言）在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，assertion 用于保证程序最基本、关键的正确性。assertion 检查通常在开发和测试时开启。
（2）为了提高性能，在软件发布后， assertion 检查通常是关闭的。在实现中，断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true；如果表达式计算为 false，那么系统会报告一个 AssertionError。
（3）断言用于调试目的：

assert(a > 0); // throws an AssertionError if a <= 0

（4）断言有以下两种形式：

assert Expr1; 
assert Expr1 : Expr2;

Expr1 应该总是产生一个布尔值。 Expr2 可以是得出一个值的任意表达式；这个值用于生成显示更多调试信息的字符串消息。这两种表达形式本质是一样的，不同在于第二种方式中，可以指定输出错误的信息。

（5）断言在默认情况下是禁用的。
① 要在编译时启用断言，需使用 source 1.4 标记：

javac -source 1.4 Test.java

② 要在运行时启用断言，可使用 -ea 或者 -enableassertions 标记。
③ 要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
④ 要在系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

（6）可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法 的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以 在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。