Java 基础面试题——关键字与标识符

绝地灬酷狼 2023-10-07 23:49 128阅读 0赞

#### 目录 ####

*  1.Java 中的关键字是指什么？有哪些关键字？
 *  2.谈谈 Java 中的标识符。
 *  3.访问修饰符 public、private、protected、以及不写（default）时的区别？
 *  4.Java 中有没有 goto 关键字?
 *  5.在 Java 中，如何跳出当前的多重嵌套循环？
 *  6.switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上？
 *  7.final 关键字在 Java 中的用法有哪些？
 *  8.static 关键字的用法有哪些？
 *  9.this 和 super 这两个关键字有什么区别？
 *  10.throw 和 throws 的区别是什么？
 *  11.return 与 finally 的执行顺序对返回值有什么影响？
 *  12.什么时候用 assert？如何使用 assert？
 *  13.instanceof 关键字的作用是什么？
 *  14.final、finally、finalize() 之间有什么区别？

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

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

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

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

（3）注意事项：

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

## 2.谈谈 Java 中的标识符。 ##

<table> 
 <thead> 
  <tr> 
   <th>标识符的含义</th> 
   <th>指在程序中，我们自己定义的内容，例如类的名字，方法名称以及变量名称等等，都是标识符。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>命名规则（硬性要求）</td> 
   <td>标识符只能包含<strong>英文字母，0-9的数字，$ 以及 _，但标识符不能以数字开头</strong>，并且不能是关键字。</td> 
  </tr> 
  <tr> 
   <td>命名规范（非硬性要求）</td> 
   <td><strong>类名规范</strong>：首字符大写，后面每个单词首字母大写（大驼峰式）。 <strong>变量名规范</strong>：首字母小写，后面每个单词首字母大写（小驼峰式）。 <strong>方法名规范</strong>：同变量名。</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <thead> 
  <tr> 
   <th>作用域</th> 
   <th>当前类</th> 
   <th>同包</th> 
   <th>子类</th> 
   <th>外部包</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
 </tbody> 
</table>

类的成员不写访问修饰时默认为 **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();
            }
        }
    }

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

![在这里插入图片描述][7695d431a76145b4ba2d26660cabd2ac.png]  
![在这里插入图片描述][b5721d4012a140caa77d2f69cb58646b.png]  
![在这里插入图片描述][839b867f870d44f7a73fc2aa56dd5fc9.png]

## 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

结果如下：

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

## 13.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
        }
    }

## 14.final、finally、finalize() 之间有什么区别？ ##

（1）在 Java 中，`final` 和 `finally` 是两个完全不同的关键字，`finalize()` 是 `Object` 类中的一个方法，它们具有不同的作用和用途。

*  `final` 关键字：`final` 关键字可以用于修饰类、方法和变量，具有以下几个特点：
    
     *  **修饰类**：`final` 修饰的类不能被继承，即为最终类。
     *  **修饰方法**：`final` 修饰的方法不能被子类重写，即为最终方法。
     *  **修饰变量**：`final` 修饰的变量被称为常量，其值不能被修改，即为最终变量。
 *  `finally` 块：`finally` 块是一个异常处理代码块，用于在 `try-catch` 结构中无论是否发生异常都会执行一些必要的清理操作。`finally` 块中的代码在返回之前总是会被执行，即使有 `return` 语句或异常被捕获并处理，并且在 `catch` 块之后执行。

try {
        
        // 可能会抛出异常的代码块
    } catch (Exception e) {
        
        // 异常处理
    } finally {
        
        // 清理操作
    }

*  `finalize()` 方法：`finalize()` 是 `java.lang.Object` 类中的一个方法，在垃圾回收器回收一个对象之前被调用。**该方法可以被子类重写以释放对象占用的资源或执行一些清理操作**。但是，在现代 Java 编程中，推荐使用显式的资源清理方式，如 `try-with-resources` 语句块或手动释放资源方法。

protected void finalize() throws Throwable {
        
        try {
        
            // 资源清理操作
        } finally {
        
            super.finalize();
        }
    }

（2）总结起来，`final` 是一个关键字，用于修饰类、方法和变量，分别表示最终类、最终方法和常量。`finalize()` 是一个方法，用于在对象被回收前进行资源清理。`finally` 是一个代码块，用于在异常处理中无论是否发生异常都会执行清理操作。它们是 Java 中不同的特性，用于不同的目的。

[7695d431a76145b4ba2d26660cabd2ac.png]: https://img-blog.csdnimg.cn/7695d431a76145b4ba2d26660cabd2ac.png
[b5721d4012a140caa77d2f69cb58646b.png]: https://img-blog.csdnimg.cn/b5721d4012a140caa77d2f69cb58646b.png
[839b867f870d44f7a73fc2aa56dd5fc9.png]: https://img-blog.csdnimg.cn/839b867f870d44f7a73fc2aa56dd5fc9.png