Skip to content
JavaGuideJavaGuide
面试指南
优质专栏
项目精选
书籍精选
旧版链接open in new window
RSS订阅open in new window
关于作者
github icon
      • Java基础常见知识&面试题总结(上)
        • Java基础常见知识&面试题总结(中)
          • Java基础知识&面试题总结(下)
            • 异常
              • Exception 和 Error 有什么区别?
                • Checked Exception 和 Unchecked Exception 有什么区别?
                  • Throwable 类常用方法有哪些?
                    • try-catch-finally 如何使用?
                      • finally 中的代码一定会执行吗?
                        • 如何使用 try-with-resources 代替try-catch-finally?
                          • 异常使用有哪些需要注意的地方?
                          • 泛型
                            • 什么是泛型?有什么作用?
                              • 泛型的使用方式有哪几种?
                                • 项目中哪里用到了泛型?
                                • 反射
                                  • 何为反射?
                                    • 反射机制优缺点
                                      • 反射的应用场景
                                      • 注解
                                        • I/O
                                          • 什么是序列化?什么是反序列化?
                                            • Java 序列化中如果有些字段不想进行序列化,怎么办?
                                              • 获取用键盘输入常用的两种方法
                                                • Java 中 IO 流分为几种?
                                                  • 既然有了字节流,为什么还要有字符流?

                                            Java基础知识&面试题总结(下)

                                            author iconGuidecategory icon
                                            • Java
                                            tag icon
                                            • Java基础
                                            calendar icon2022年1月31日word icon约 4352 字

                                            此页内容
                                            • 异常
                                              • Exception 和 Error 有什么区别?
                                              • Checked Exception 和 Unchecked Exception 有什么区别?
                                              • Throwable 类常用方法有哪些?
                                              • try-catch-finally 如何使用?
                                              • finally 中的代码一定会执行吗?
                                              • 如何使用 try-with-resources 代替try-catch-finally?
                                              • 异常使用有哪些需要注意的地方?
                                            • 泛型
                                              • 什么是泛型?有什么作用?
                                              • 泛型的使用方式有哪几种?
                                              • 项目中哪里用到了泛型?
                                            • 反射
                                              • 何为反射?
                                              • 反射机制优缺点
                                              • 反射的应用场景
                                            • 注解
                                            • I/O
                                              • 什么是序列化?什么是反序列化?
                                              • Java 序列化中如果有些字段不想进行序列化,怎么办?
                                              • 获取用键盘输入常用的两种方法
                                              • Java 中 IO 流分为几种?
                                              • 既然有了字节流,为什么还要有字符流?

                                            # 异常

                                            Java 异常类层次结构图概览 :

                                            types-of-exceptions-in-java

                                            # Exception 和 Error 有什么区别?

                                            在 Java 中,所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类:

                                            • Exception :程序本身可以处理的异常,可以通过 catch 来进行捕获。Exception 又可以分为 Checked Exception (受检查异常,必须处理) 和 Unchecked Exception (不受检查异常,可以不处理)。
                                            • Error :Error 属于程序无法处理的错误 ,我们没办法通过 catch 来进行捕获不建议通过catch捕获 。例如 Java 虚拟机运行错误(Virtual MachineError)、虚拟机内存不够错误(OutOfMemoryError)、类定义错误(NoClassDefFoundError)等 。这些异常发生时,Java 虚拟机(JVM)一般会选择线程终止。

                                            # Checked Exception 和 Unchecked Exception 有什么区别?

                                            Checked Exception 即 受检查异常 ,Java 代码在编译过程中,如果受检查异常没有被 catch或者throws 关键字处理的话,就没办法通过编译。

                                            比如下面这段 IO 操作的代码:

                                            除了RuntimeException及其子类以外,其他的Exception类及其子类都属于受检查异常 。常见的受检查异常有: IO 相关的异常、ClassNotFoundException 、SQLException...。

                                            Unchecked Exception 即 不受检查异常 ,Java 代码在编译过程中 ,我们即使不处理不受检查异常也可以正常通过编译。

                                            RuntimeException 及其子类都统称为非受检查异常,常见的有(建议记下来,日常开发中会经常用到):

                                            • NullPointerException(空指针错误)
                                            • IllegalArgumentException(参数错误比如方法入参类型错误)
                                            • NumberFormatException(字符串转换为数字格式错误,IllegalArgumentException的子类)
                                            • ArrayIndexOutOfBoundsException(数组越界错误)
                                            • ClassCastException(类型转换错误)
                                            • ArithmeticException(算术错误)
                                            • SecurityException (安全错误比如权限不够)
                                            • UnsupportedOperationException(不支持的操作错误比如重复创建同一用户)
                                            • ......

                                            # Throwable 类常用方法有哪些?

                                            • String getMessage(): 返回异常发生时的简要描述
                                            • String toString(): 返回异常发生时的详细信息
                                            • String getLocalizedMessage(): 返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法,可以生成本地化信息。如果子类没有覆盖该方法,则该方法返回的信息与 getMessage()返回的结果相同
                                            • void printStackTrace(): 在控制台上打印 Throwable 对象封装的异常信息

                                            # try-catch-finally 如何使用?

                                            • try块 : 用于捕获异常。其后可接零个或多个 catch 块,如果没有 catch 块,则必须跟一个 finally 块。
                                            • *catch块 : 用于处理 try 捕获到的异常。
                                            • finally 块 : 无论是否捕获或处理异常,finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时,finally 语句块将在方法返回之前被执行。

                                            代码示例:

                                            try {
                                                System.out.println("Try to do something");
                                                throw new RuntimeException("RuntimeException");
                                            } catch (Exception e) {
                                                System.out.println("Catch Exception -> " + e.getMessage());
                                            } finally {
                                                System.out.println("Finally");
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8

                                            输出:

                                            Try to do something
                                            Catch Exception -> RuntimeException
                                            Finally
                                            
                                            1
                                            2
                                            3

                                            注意:不要在 finally 语句块中使用 return! 当 try 语句和 finally 语句中都有 return 语句时,try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中,当执行到 finally 语句中的 return 之后,这个本地变量的值就变为了 finally 语句中的 return 返回值。

                                            jvm 官方文档open in new window中有明确提到:

                                            If the try clause executes a return, the compiled code does the following:

                                            1. Saves the return value (if any) in a local variable.
                                            2. Executes a jsr to the code for the finally clause.
                                            3. Upon return from the finally clause, returns the value saved in the local variable.

                                            代码示例:

                                            public static void main(String[] args) {
                                                System.out.println(f(2));
                                            }
                                            
                                            public static int f(int value) {
                                                try {
                                                    return value * value;
                                                } finally {
                                                    if (value == 2) {
                                                        return 0;
                                                    }
                                                }
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10
                                            11
                                            12
                                            13

                                            输出:

                                            0
                                            
                                            1

                                            # finally 中的代码一定会执行吗?

                                            不一定的!在某些情况下,finally 中的代码不会被执行。

                                            就比如说 finally 之前虚拟机被终止运行的话,finally 中的代码就不会被执行。

                                            try {
                                                System.out.println("Try to do something");
                                                throw new RuntimeException("RuntimeException");
                                            } catch (Exception e) {
                                                System.out.println("Catch Exception -> " + e.getMessage());
                                                // 终止当前正在运行的Java虚拟机
                                                System.exit(1);
                                            } finally {
                                                System.out.println("Finally");
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10

                                            输出:

                                            Try to do something
                                            Catch Exception -> RuntimeException
                                            
                                            1
                                            2

                                            另外,在以下 2 种特殊情况下,finally 块的代码也不会被执行:

                                            1. 程序所在的线程死亡。
                                            2. 关闭 CPU。

                                            相关 issue: https://github.com/Snailclimb/JavaGuide/issues/190open in new window。

                                            🧗🏻 进阶一下:从字节码角度分析try catch finally这个语法糖背后的实现原理。

                                            # 如何使用 try-with-resources 代替try-catch-finally?

                                            1. 适用范围(资源的定义): 任何实现 java.lang.AutoCloseable或者 java.io.Closeable 的对象
                                            2. 关闭资源和 finally 块的执行顺序: 在 try-with-resources 语句中,任何 catch 或 finally 块在声明的资源关闭后运行

                                            《Effective Java》中明确指出:

                                            面对必须要关闭的资源,我们总是应该优先使用 try-with-resources 而不是try-finally。随之产生的代码更简短,更清晰,产生的异常对我们也更有用。try-with-resources语句让我们更容易编写必须要关闭的资源的代码,若采用try-finally则几乎做不到这点。

                                            Java 中类似于InputStream、OutputStream 、Scanner 、PrintWriter等的资源都需要我们调用close()方法来手动关闭,一般情况下我们都是通过try-catch-finally语句来实现这个需求,如下:

                                            //读取文本文件的内容
                                            Scanner scanner = null;
                                            try {
                                                scanner = new Scanner(new File("D://read.txt"));
                                                while (scanner.hasNext()) {
                                                    System.out.println(scanner.nextLine());
                                                }
                                            } catch (FileNotFoundException e) {
                                                e.printStackTrace();
                                            } finally {
                                                if (scanner != null) {
                                                    scanner.close();
                                                }
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10
                                            11
                                            12
                                            13
                                            14

                                            使用 Java 7 之后的 try-with-resources 语句改造上面的代码:

                                            try (Scanner scanner = new Scanner(new File("test.txt"))) {
                                                while (scanner.hasNext()) {
                                                    System.out.println(scanner.nextLine());
                                                }
                                            } catch (FileNotFoundException fnfe) {
                                                fnfe.printStackTrace();
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7

                                            当然多个资源需要关闭的时候,使用 try-with-resources 实现起来也非常简单,如果你还是用try-catch-finally可能会带来很多问题。

                                            通过使用分号分隔,可以在try-with-resources块中声明多个资源。

                                            try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
                                                 BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
                                                int b;
                                                while ((b = bin.read()) != -1) {
                                                    bout.write(b);
                                                }
                                            }
                                            catch (IOException e) {
                                                e.printStackTrace();
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10

                                            # 异常使用有哪些需要注意的地方?

                                            • 不要把异常定义为静态变量,因为这样会导致异常栈信息错乱。每次手动抛出异常,我们都需要手动 new 一个异常对象抛出。
                                            • 抛出的异常信息一定要有意义。
                                            • 建议抛出更加具体的异常比如字符串转换为数字格式错误的时候应该抛出NumberFormatException而不是其父类IllegalArgumentException。
                                            • 使用日志打印异常之后就不要再抛出异常了(两者不要同时存在一段代码逻辑中)。
                                            • ......

                                            # 泛型

                                            # 什么是泛型?有什么作用?

                                            Java 泛型(Generics) 是 JDK 5 中引入的一个新特性。使用泛型参数,可以增强代码的可读性以及稳定性。

                                            编译器可以对泛型参数进行检测,并且通过泛型参数可以指定传入的对象类型。比如 ArrayList<Persion> persons = new ArrayList<Persion>() 这行代码就指明了该 ArrayList 对象只能传入 Persion 对象,如果传入其他类型的对象就会报错。

                                            ArrayList<E> extends AbstractList<E>
                                            
                                            1

                                            并且,原生 List 返回类型是 Object ,需要手动转换类型才能使用,使用泛型后编译器自动转换。

                                            # 泛型的使用方式有哪几种?

                                            泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。

                                            1.泛型类:

                                            //此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
                                            //在实例化泛型类时,必须指定T的具体类型
                                            public class Generic<T>{
                                            
                                                private T key;
                                            
                                                public Generic(T key) {
                                                    this.key = key;
                                                }
                                            
                                                public T getKey(){
                                                    return key;
                                                }
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10
                                            11
                                            12
                                            13
                                            14

                                            如何实例化泛型类:

                                            Generic<Integer> genericInteger = new Generic<Integer>(123456);
                                            
                                            1

                                            2.泛型接口 :

                                            public interface Generator<T> {
                                                public T method();
                                            }
                                            
                                            1
                                            2
                                            3

                                            实现泛型接口,不指定类型:

                                            class GeneratorImpl<T> implements Generator<T>{
                                                @Override
                                                public T method() {
                                                    return null;
                                                }
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6

                                            实现泛型接口,指定类型:

                                            class GeneratorImpl<T> implements Generator<String>{
                                                @Override
                                                public String method() {
                                                    return "hello";
                                                }
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6

                                            3.泛型方法 :

                                               public static < E > void printArray( E[] inputArray )
                                               {
                                                     for ( E element : inputArray ){
                                                        System.out.printf( "%s ", element );
                                                     }
                                                     System.out.println();
                                                }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7

                                            使用:

                                            // 创建不同类型数组: Integer, Double 和 Character
                                            Integer[] intArray = { 1, 2, 3 };
                                            String[] stringArray = { "Hello", "World" };
                                            printArray( intArray  );
                                            printArray( stringArray  );
                                            
                                            1
                                            2
                                            3
                                            4
                                            5

                                            注意: public static < E > void printArray( E[] inputArray ) 一般被称为静态泛型方法;在 java 中泛型只是一个占位符,必须在传递类型后才能使用。类在实例化时才能真正的传递类型参数,由于静态方法的加载先于类的实例化,也就是说类中的泛型还没有传递真正的类型参数,静态的方法的加载就已经完成了,所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的 <E>

                                            # 项目中哪里用到了泛型?

                                            • 自定义接口通用返回结果 CommonResult<T> 通过参数 T 可根据具体的返回类型动态指定结果的数据类型
                                            • 定义 Excel 处理类 ExcelUtil<T> 用于动态指定 Excel 导出的数据类型
                                            • 构建集合工具类(参考 Collections 中的 sort, binarySearch 方法)。
                                            • ......

                                            # 反射

                                            # 何为反射?

                                            如果说大家研究过框架的底层原理或者咱们自己写过框架的话,一定对反射这个概念不陌生。

                                            反射之所以被称为框架的灵魂,主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。通过反射你可以获取任意一个类的所有属性和方法,你还可以调用这些方法和属性。

                                            # 反射机制优缺点

                                            • 优点 : 可以让咱们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利
                                            • 缺点 :让我们在运行时有了分析操作类的能力,这同样也增加了安全问题。比如可以无视泛型参数的安全检查(泛型参数的安全检查发生在编译时)。另外,反射的性能也要稍差点,不过,对于框架来说实际是影响不大的。Java Reflection: Why is it so slow?open in new window

                                            # 反射的应用场景

                                            像咱们平时大部分时候都是在写业务代码,很少会接触到直接使用反射机制的场景。

                                            但是,这并不代表反射没有用。相反,正是因为反射,你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。

                                            这些框架中也大量使用了动态代理,而动态代理的实现也依赖反射。

                                            比如下面是通过 JDK 实现动态代理的示例代码,其中就使用了反射类 Method 来调用指定的方法。

                                            public class DebugInvocationHandler implements InvocationHandler {
                                                /**
                                                 * 代理类中的真实对象
                                                 */
                                                private final Object target;
                                            
                                                public DebugInvocationHandler(Object target) {
                                                    this.target = target;
                                                }
                                            
                                                public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
                                                    System.out.println("before method " + method.getName());
                                                    Object result = method.invoke(target, args);
                                                    System.out.println("after method " + method.getName());
                                                    return result;
                                                }
                                            }
                                            
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9
                                            10
                                            11
                                            12
                                            13
                                            14
                                            15
                                            16
                                            17
                                            18

                                            另外,像 Java 中的一大利器 注解 的实现也用到了反射。

                                            为什么你使用 Spring 的时候 ,一个@Component注解就声明了一个类为 Spring Bean 呢?为什么你通过一个 @Value注解就读取到配置文件中的值呢?究竟是怎么起作用的呢?

                                            这些都是因为你可以基于反射分析类,然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后,就可以做进一步的处理。

                                            # 注解

                                            Annotation (注解) 是 Java5 开始引入的新特性,可以看作是一种特殊的注释,主要用于修饰类、方法或者变量。

                                            注解本质是一个继承了Annotation 的特殊接口:

                                            @Target(ElementType.METHOD)
                                            @Retention(RetentionPolicy.SOURCE)
                                            public @interface Override {
                                            
                                            }
                                            
                                            public interface Override extends Annotation{
                                            
                                            }
                                            
                                            1
                                            2
                                            3
                                            4
                                            5
                                            6
                                            7
                                            8
                                            9

                                            注解只有被解析之后才会生效,常见的解析方法有两种:

                                            • 编译期直接扫描 :编译器在编译 Java 代码的时候扫描对应的注解并处理,比如某个方法使用@Override 注解,编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。
                                            • 运行期通过反射处理 :像框架中自带的注解(比如 Spring 框架的 @Value 、@Component)都是通过反射来进行处理的。

                                            JDK 提供了很多内置的注解(比如 @Override 、@Deprecated),同时,我们还可以自定义注解。

                                            # I/O

                                            # 什么是序列化?什么是反序列化?

                                            如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中,或者在网络传输 Java 对象,这些场景都需要用到序列化。

                                            简单来说:

                                            • 序列化: 将数据结构或对象转换成二进制字节流的过程
                                            • 反序列化:将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

                                            对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。

                                            维基百科是如是介绍序列化的:

                                            序列化(serialization)在计算机科学的数据处理中,是指将数据结构或对象状态转换成可取用格式(例如存成文件,存于缓冲,或经由网络中发送),以留待后续在相同或另一台计算机环境中,能恢复原先状态的过程。依照序列化格式重新获取字节的结果时,可以利用它来产生与原始对象相同语义的副本。对于许多对象,像是使用大量引用的复杂对象,这种序列化重建的过程并不容易。面向对象中的对象序列化,并不概括之前原始对象所关系的函数。这种过程也称为对象编组(marshalling)。从一系列字节提取数据结构的反向操作,是反序列化(也称为解编组、deserialization、unmarshalling)。

                                            综上:序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

                                            https://www.corejavaguru.com/java/serialization/interview-questions-1

                                            # Java 序列化中如果有些字段不想进行序列化,怎么办?

                                            对于不想进行序列化的变量,使用 transient 关键字修饰。

                                            transient 关键字的作用是:阻止实例中那些用此关键字修饰的的变量序列化;当对象被反序列化时,被 transient 修饰的变量值不会被持久化和恢复。

                                            关于 transient 还有几点注意:

                                            • transient 只能修饰变量,不能修饰类和方法。
                                            • transient 修饰的变量,在反序列化后变量值将会被置成类型的默认值。例如,如果是修饰 int 类型,那么反序列后结果就是 0。
                                            • static 变量因为不属于任何对象(Object),所以无论有没有 transient 关键字修饰,均不会被序列化。

                                            # 获取用键盘输入常用的两种方法

                                            方法 1:通过 Scanner

                                            Scanner input = new Scanner(System.in);
                                            String s  = input.nextLine();
                                            input.close();
                                            
                                            1
                                            2
                                            3

                                            方法 2:通过 BufferedReader

                                            BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
                                            String s = input.readLine();
                                            
                                            1
                                            2

                                            # Java 中 IO 流分为几种?

                                            • 按照流的流向分,可以分为输入流和输出流;
                                            • 按照操作单元划分,可以划分为字节流和字符流;
                                            • 按照流的角色划分为节点流和处理流。

                                            Java IO 流共涉及 40 多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

                                            • InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。
                                            • OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。

                                            按操作方式分类结构图:

                                            IO-操作方式分类

                                            按操作对象分类结构图:

                                            IO-操作对象分类

                                            # 既然有了字节流,为什么还要有字符流?

                                            问题本质想问:不管是文件读写还是网络发送接收,信息的最小存储单元都是字节,那为什么 I/O 流操作要分为字节流操作和字符流操作呢?

                                            回答:字符流是由 Java 虚拟机将字节转换得到的,问题就出在这个过程还算是非常耗时,并且,如果我们不知道编码类型就很容易出现乱码问题。所以, I/O 流就干脆提供了一个直接操作字符的接口,方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好,如果涉及到字符的话使用字符流比较好。

                                            edit icon编辑此页open in new window
                                            上次编辑于: 2022/4/26 下午8:00:05
                                            贡献者: guide,WT-AHA,CrazyKid,sam
                                            上一页
                                            Java基础常见知识&面试题总结(中)
                                            鄂ICP备2020015769号-1
                                            Copyright © 2022 Guide