JAVA面试知识点汇总——持续更新

废话不多说，直接上干货。喜欢的收藏一下，会一直持续更新！！！

1. JDK和JRE区别

   • JDK：是功能齐全的Java SDK
   • JRE：是java程序的运行环境，包括java虚拟机和java基础类库

   总体来说：JDK包括了JRE，还包括了java源码的编译器（javac），监控工具（jconsole）分析工具（jvisualvm）

2. ==和equals区别：

   • ==：比较 的是变量（栈区）内存中存放的对象的（堆区）内存地址，用来判断两个对象地址是否相同，即是否指向相同一个对象。比较的是真正意义上的指针操作。即比较的是操作符两端的操作数是否是同一个对象
   • equals：用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.object类，所以适用于所有对象，如果没有对该方法重写，Object中的equals方法等同于==

   ==运行速度要快，因为= =只是比较引用

3. 基本类型和包装类对象使用==和equals进行比较的结果：

   • ==：
     • 基本类型——基本类型 true
     • 基本类型——包装对象 true 自动拆箱
     • 包装对象——包装对象 false
   • equals：
     • 包装对象——基本类型 true
     • 包装对象——包装对象 false

   • 需要注意的是当需要进行自动装箱时，如果数字在-128到127之间时，会直接使用缓存中的对象而不是重写创建一个对象
   • 所有包装类一律使用equals方法比较值是否相等
   • 所有引用类型，当使用== 运算符时，比较的是两个引用类型变量是否指向相同的对象
   • 要比较引用类型变量的成员变量值是否相等时，要使用equals方法

4. 装箱和拆箱

   • 装箱：基本类型转化为包装器类型的过程，通过调用包装器类的valueOf方法来实现
   • 拆箱：包装器类型转变为基本类型的过程，通过调用包装器类的xxxValue

   常见问题：

   • 整形的包装类valueOf方法返回对象时，在常用的取值范围时，会返回缓存对象
   • 浮点型的包装类valueOf方法返回新的对象
   • 布尔值的包装类valueOf方法Boolean类的静态常量TRUE|FALSE

5. final finally finalize（）区别

   • final：只赋值一次
     • 表示最终的不可改变的，
     • 用于修饰类、方法和变量
     • 表示类不能继承，方法不能重写，成员变量必须要初始化
     • private类型的方法默认是final类型的
   • finally
     • 异常处理的一部分，它只用在try/catch语句中，表示希望finally语句块中的代码最后一定被指向（但是不一定会被执行：直接返回，抛出异常、系统退出）
   • finalize（）
     • 是在java.lang.Object里定义的，Object的finalize方法什么都不做，对象被回首时finalize方法会被调用
     • 特殊情况下，可重写finalize方法，当对象被回收的时候释放一些资源，但要注意，要调用super.finalize()

6. static：静态

   • **修饰成员变量和成员方法:**被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。调用格式：类名.静态变量名 类名.静态方法名()
   • 静态代码块: 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次.
   • 静态内部类（static修饰类的话只能修饰内部类）： 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
   • 静态导包(用来导入类中的静态资源，1.5之后的新特性): 格式为：import static 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。

   注意：

   • static修饰的变量可以重写赋值
   • static方法中不能使用this和super关键字
   • static方法必须被实现，而不能是抽象的abstract
   • static方法只能被static方法覆盖

7. abstract

   • abstract类不能实例化对象
   • abstract类可以不包含abstract方法，但是只要有一个abstract方法，那么该类必须为abstract类
   • abstract方法没有方法体，需要被override
   • abstract类的子类要么实现其父类全部的abstract方法，要么也是一个abstract类
   • abstract不能修饰属性
   • abstract不能修饰局部变量

8. 扩展JDK中的java.lang.Math类

   • round：返回四舍五入
   • ceil：返回小数所在两整数间的较大者
   • tail：返回小数所在两整数间的较小者

9. java八种基本数据类型：

   • byte
   • short
   • char
   • int
   • long
   • float
   • double
   • boolean

10. java中字符串类

    • String：不可变，最慢
      • final修饰，String类的方法都是返回新的String。
      • 适用于少量的字符串操作
    • StringBuilder：快
      • 适用于单线程下在字符串缓冲区进行大量操作
    • StringBuffer：线程安全
      • 适用于多线程下在字符串缓冲区进行大量操作

11. 接口和抽象类

    比较	抽象类 extends	接口 implements
    默认方法	抽象类可以有默认的方法实现	java 8之前,接口中不存在方法的实现.
    实现方式	子类使用extends关键字来继承抽象类.如果子类不是抽象类,子类需要提供抽象类中所声明方法的实现.	子类使用implements来实现接口,需要提供接口中所有声明的实现
    构造器	抽象类中可以有构造器和构造方法	接口中不能有构造器和构造方法
    和正常类区别	抽象类不能被实例化	接口则是完全不同的类型
    访问修饰符	抽象方法可以有public,protected和default等修饰	接口默认是public,不能使用其他修饰符
    多继承	一个子类只能存在一个父类	一个子类可以存在多个接口
    添加新方法	向抽象类中添加新方法,可以提供默认的实现,因此可以不修改子类现有的代码	如果往接口中添加新方法,则子类中需要实现该方法.
    构造函数和main方法	可以有	不能有

    • 抽象类中可以有普通成员变量；接口中没有普通成员变量。

12. throw和throws的区别

    • throw：
      • 表示方法内抛出某种异常对象
      • 如果异常对象是非RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常，否则编译报错
      • 执行到 throw 语句则后面的语句块不再执行
    • throws：
      • 方法的定义上使用 throws 表示这个方法可能抛出某种异常
      • 需要由方法的调用者进行异常处理

13. 面向对象和面向过程的区别

    • 面向过程：性能更好，因为类的调用需要实例化，开销比较大，比较消耗资源。所以单片机，嵌入式开发，Linux/Unix一般采用面向过程。
    • 面向对象：易维护，易复用，易扩展。因为面对对象有封装，继承，多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活，更加易于维护。

14. JVM：是运行Java字节码的虚拟机，其有针对不同系统的特定实现，目的是使用相同的字节码，都会产生相同的结果。其中字节码和不同操作系统的JVM实现是Java语言一次编译，随处运行的关键。

    • 组成
      • 类加载子系统:负责从文件系统或者w网络中加载Class信息，加载的信息存放在一块称之为方法区的内存
      • 方法区：就是存放类信息 ，常量信息，常量池信息包括字符串字面量和数字常量等。存储可以运行的class文件。
      • java堆：在java虚拟机启动的时候建立java堆 ，它就是java程序最主要的内存工作区域 几乎所有的对象实例都存放在java堆中， 堆空间s是所有线程共享的。
      • 直接内存：java的NIO库允许java程序使用直接内存，从而提高性能，通常直接内存的速度会优于java堆 读写频繁的场合可能会考虑使用。
      • java栈：每个虚拟机线程都有一个私有的栈，一个线程的java栈在线程创建的时候被创建，java栈中保存着局部变量，方法参数，同时和java方法的调用、返回密切相关。
      • 本地方法栈：JVM在使用操作系统功能的时候使用。本地方法栈和java栈非常类似，最大的不同为本地方法栈用于本地方法调用 java虚拟机允许java直接调用本地方法。
      • 垃圾回收系统：垃圾回收系统是java的核心 也是必不可少的，java有一套自己进行垃圾清理的机制 ，开发人员无需手工清理。
      • PC寄存器：给CPU使用，寄存器也是线程私有的空间 ，java虚拟机会为每个线程创建PC寄存器，在任意时刻，一个java线程在执行一个方法，这个方法被称为当前方法，如果当前方法不是本地方法，PC寄存器就会指向当前正在被执行的指令。如果当前方法是本地方法，那么PC寄存器的值就是undefined，寄存器存放当前执行环境指针，程序计数器，操作栈指针，计算的变量指针等信息。
      • 执行引擎：虚拟机最核心的就是执行引擎了，他负责虚拟机的字节码，现代虚拟机为了提高执行效率，会使用即时编译技术将方法编译成机器码后再执行。

15. 字节码：在Java中JVM可以理解的代码叫做字节码（扩展名为.class的文件），它不面向如何特定的处理机，只面向虚拟机，Java通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，又保留了解释型语言的可移植性，另外Java无需重新编译便可在不同的操作系统的计算机上运行。

16. Java程序从源代码到运行步骤：.java文件通过JDK中的javac编译，变成.class文件然后由JVM变成机器可以执行的二进制机器码。

    • 但是在加载字节码文件，然后通过解释器逐行执行，这种方式相对比较慢，后面对于所谓的热点代码，引入JIT编译器，当其完成第一次编译后，会将字节码对于的机器码保留下来，用于下次直接使用。这就是Java是编译与解释共存的语言。

17. Java序列化：将Java对象转化成字节流的过程。

    • 实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。
    • 注意事项：
      • 某个类可以被序列化，则其子类也可以被序列化
      • 声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
      • 反序列化读取序列化对象的顺序要保持一致

18. 对象克隆：

    • 需求场景：方法需要return引用类型，但又不希望自己的对象被修改，程序之间方法的调用时参数的传递。有些场景为了保证引用类型的参数不被其他方法修改，可以使用克隆后的值作为参数传递。
    • 实现：
      • 实现Cloneable接口，重写clone（）方法
    • 深拷贝和浅拷贝
      • 浅拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象。
      • 深拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象。

19. Java的GC回收是完全自动的，只能：

    • 及时把它的引用附空
    • 调用System.gc（）但是不一定会运行

20. Java两种传递方式

    • 值传递：基本类型和以string str = “aaa”
    • 引用传递：对象创建、数组

21. Java垃圾回收机制：主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代、年老代、永久代（也就是方法区）。

    • 年轻代：对象被创建时（new）的对象通常被放在 Young（除了一些占据内存比较大的对象）, 经过一定的 Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
    • 年老代：就是上述年轻代移动过来的和一些比较大的对象。Major GC (FullGC) 是针对年老代的回收。
    • 永久代：存储的是 final 常量，static 变量，常量池。

22. 构造函数不能被继承，构造方法只能被显式或隐式的调用。(有参和无参均是这样)

23. hashcode（）和equal（）

    • hashCode()：作用就是获取哈希码（散列值），实际上返回的是一个int整数。这个哈希码的作用就是确定对象在哈希表中的索引位置。

    • 相关规定

      • 如果两个对象相等，则hashcode一定相等
      • 两个对象相等，对两个对象分别调用equals方法都返回true
      • 两个对象有相同的hashcode值，他们不一定相等
      • equals方法被覆盖过则hashcode也必须被覆盖
      • hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

    • 规范：

      • 规范 1：若重写 equals (Object obj) 方法，有必要重写 hashcode () 方法，确保通过 equals (Object obj) 方法判断结果为 true 的两个对象具备相等的 hashcode () 返回值。说得简单点就是：“如果两个对象相同，那么他们的 hashcode 应该 相等”。(注意不是强制)
      • 规范 2：如果 equals (Object obj) 返回 false，即两个对象 “不相同”，并不要求对这两个对象调用 hashcode () 方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的 hashcode 可能相同”。

    • 推论：

      • 1、如果两个对象 equals，Java 运行时环境会认为他们的 hashcode 一定相等。
      • 2、如果两个对象不 equals，他们的 hashcode 有可能相等。
      • 3、如果两个对象 hashcode 相等，他们不一定 equals。
      • 4、如果两个对象 hashcode 不相等，他们一定不 equals。

      因为hashmap要求键值不能相同，java判断是否相同，先调用hashcode()判断hash值是否相同，在调用equal来判断

24. 迭代器

    • 迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为 “轻量级” 对象，因为创建它的代价小。
    • Java中的迭代器只能单向移动

25. 容器：容器可以管理对象的生命周期、对象与对象之间的依赖关系，您可以使用一个配置文件（通常是 XML），在上面定义好对象的名称、如何产生（Prototype 方式或 Singleton 方式）、哪个对象产生之后必须设定成为某个对象的属性等，在启动容器之后，所有的对象都可以直接取用，不用编写任何一行程序代码来产生对象，或是建立对象与对象之间的依赖关系。

    • 换个更直白点的说明方式：容器是一个 Java 所编写的程序，原先必须自行编写程序以管理对象关系，现在容器都会自动帮您作好。

26. 基本类型和包装类型的区别

    • 包装类可以Null而基础类不可以。使得包装类可以应用于POJO（简单无规则的Java对象，只有属性字段以及 setter 和 getter 方法）类似的：数据传输对象DTO（泛指用于展示层与服务层之间的数据传输对象）；视图对象VO（把某个页面的数据封装起来）；持久化对象PO（可以看成是与数据库中的表映射的 Java 对象）
    • 包装类型可用于泛型，而基本类型不可以：因为泛型在编译时会进行类型擦除，最后只保留原始类型
    • 基本类型比包装类型更加高效：基本类型直接存储的具体数值，而包装类型则存储的是堆中的引用
    • 两个包装类型的值可以相同，但是却不相等。

27. 重写和重载

    • 重写：
      • 发送在子类和父类之间，子类覆盖父类（要确保权限大于等于父类）
      • 返回值、方法名和参数相同
      • 子类的异常不能超过父类
      • 运行时的多态性
    • 重载：
      • 同一个类两个或者多个以上方法名相同，
      • 只要他们的参数列表不同（个数不同、数据类型不同、顺序不同）
      • 与修饰符和返回值类型无关
      • 体现的是编译时的多态性

28. 多态

    • 好处：
      • 可替换性：多态对已存在的代码具有可替换性
      • 可扩充性：增加新的子类不影响已存在的类结构
      • 接口性：多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的
      • 灵活性:
      • 简化性:
    • 实现方法：
      • 接口实现
      • 继承父类重写方法
      • 同一类中进行方法重载

29. java创建对象的几种方式

    • 采用new
    • 通过反射
    • 采用clone
    • 通过序列化机制

30. java四种引用：强引用,软引用,弱引用,虚引用.不同的引用类型主要体现在GC上:

    • 强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
    • 软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
    • 弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象
    • 虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

31. a=a+b 和a+=b的区别;+=会隐式自动类型转换

    拓展：

    short s1=1;s1=s1+1; 错

    shout s1=1;s1+=s1; 对

32. &和&&区别：当表示逻辑运算的时候，&&具有短路效果，另外&还可以进行按位与

33. 垃圾回收算法：

    1. 标记-清除：
       • 过程
         • 标记所有需要回收的对象（判断对象的有效性）
         • 标记完成后清除标记对象
       • 缺点：
         • 每次进行垃圾回收的时候，会暂停当前用户程序的运行
         • 垃圾回收期需要间隔性检查，并标记和清除的过程比较慢
         • 会产生大量的内存碎片。
    2. 标记-复制：以空间换时间
       • 过程:
         • 将内存空间画为两块，每次只使用一块，需要清理的时候把存活对象复制到另一块区域中
       • 缺点：
         • 空间利用率低下
         • 会暂停当前应用的运行
    3. 标记-整理:
       • 过程：让所有存活的对象都想另外一端移动，然后直接清理掉端边界以外的内存
       • 缺点：暂停当前应用的运行，非实时性的回收
    4. 分代收集算法：根据对象生存周期的不同来选择算法
       • 新生代：大量死去：标记复制
       • 老年代：标记-清除或者标记-整理
    5. 增量收集算法

34. 常量

    • 字符串常量
    • 整数常量
    • 浮点数常量
    • 字符常量
    • 布尔常量
    • 空常量

35. byte/short/char：都可以发生数学运算，在运算的过程中会首先提为int类型而boolean类型不能发生数据类型转换

36. switch

    • 后面括号中：
      • 基本数据类型：byte/short/char/int
      • 引用数据类型：String字符串，enum枚举
    • 不能用：long、float、double
    • 运行过程中匹配到哪一个case就从哪一个

37. 成员变量和局部变量的区别

    1. 定义位置不一样
       • 局部变量：在方法内部
       • 成员变量：在方法外部，直接写在类当中
    2. 作用范围不一样
       • 局部变量：只有方法当中才可以使用
       • 成员变量：整合类中通用
    3. 默认值不一样
       • 局部变量：没有默认值，想使用必须手动赋值
       • 成员变量：如果没有赋值，会有默认值
    4. 内存位置不一样
       • 局部变量：位于栈内存
       • 成员变量：位于堆内存
    5. 生命周期不一样
       • 局部变量：随着方法进栈而诞生，随着方法出栈而消失
       • 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

38. this：方法的局部变量和类的成员变量重名的时候，根据就近原则优先使用局部变量。如果需要访问本类当中的成员变量，需要使用格式：
    this.成员变量名

    通过谁调用的方法，谁就是this

39. java bean

    ​ 一个标准的类通常要拥有下面四个组成部分。

    • 所有的成员变量都要使用private关键字修饰
    • 为每一个成员变量编写一对Getter/Setter方法
    • 编写一个无参数的构造方法
    • 编写一个全参数的构造方法

40. String类

    • 构造方法
      • public String(): 初始化新创建的String对象，以使其表示空字符序列
      • public String(char[] value): 通过当前参数中的字符数组来构造新的String
      • public String(byte[] bytes): 通过使用平台默认字符集解码当前参数中的字节数组来构造新的String
    • 常用方法
      • 判断：
        • equals (Object anObject): 将字符串与指定对象比较
        • equalsIgnoreCase(String anotherString)忽略大小写
      • 获取
        • length ():返回此字符串的长度
        • concat(String str): 将指定的字符串拼接到字符串的末尾
        • charAt(int index): 返回指定索引处的char值
        • indexOf(String str): 返回指定字符串第一次出现在该字符串内的索引，-1
        • substring(int beginIndex): 返回子字符串，从beginindex开始截取字符串到字符串末尾
        • substring (int beginIndex,int endIndex)：从beginindex到endIndex截取字符串，左闭右开
      • 转化
        • public char[] toCharArray (): 将此字符串转化为新的字符数组
        • public byte[] getBytes ():使用默认字符集将String编码转换为新的字节数组
        • public String replace(CharSequence target, CharSequence replacement): 将与target匹配的字符串用replacement字符串替换
      • 分隔：public String[] split(String regex): 将此字符串按照给定的regex拆分为字符串数组
      • 其他：
        • trim（）：去除两端空白

41. 继承

    • 定义：多个类存在相同的属性和行为，将其共性抽取，提成父类，子类继承父类的属性和行为，可以直接访问父类的非私有属性和行为
    • 特点
      • 子类拥有父类对象所有的属性和方法（包括私有的），但是父类中的私有属性和方法子类是无法访问的，只是拥有
      • 成员变量重名时，访问父类中的非私有成员变量时，使用关键词super关键词，修饰父类属性
      • 成员方法重名时：重写
      • java只支持单继承，不支持多继承
      • 支持多层继承

42. super和this

    父类空间优先于子类对象产生：

    在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

    • 含义

      • super：表示父类的存储空间标识（父类的引用）
      • this：代表当前对象的引用（谁调用就代表谁）

    • 用法

      • 访问成员

        this.成员变量 – 本类的
        super.成员变量 – 父类的
        this.成员方法名() – 本类的
        super.成员方法名() – 父类的

      • 访问构造方法

        this(…) – 本类的构造方法
        super(…) – 父类的构造方法

    子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

    super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

43. 分布式、多线程、高并发

    • 分布式
      • 含义：为了解决单个物理服务器容量和性能瓶颈问题而蚕蛹的优化手段
      • 实现:
        • 水平扩展：添加机器，将流量平分到所有服务器上
        • 垂直拆分：按照不同的需要分发到不同的机器上
    • 高并发
      • 含义：同时有多少量
      • 解决方法
        • 使用分布式技术去解决
        • 使用缓存系统：将所有静态内容放到CDN
        • 使用多线程技术将一台服务器的服务能力最大化
    • 多线程
      • 含义：多线程是指从软件或者硬件上实现多个线程并发执行的技术，解决CPu调度多个进程的问题

44. java中方法参数的使用情况

    • 一个方法不能修改一个基本数据类型的参数
    • 一个方法可以改变一个对象参数的状态
    • 一个方法不能让对象参数引用一个新的对象

45. Java中的异常处理

    

    • Error(错误)：是程序无法处理的错误，表示代码运行时JVM（java虚拟机）出现问题。这些错误表示故障发生于虚拟机自身，或者发生在虚拟机试图执行应用是。
    • Exception（异常）：是程序本身可以处理的异常
    • 区别：异常能被程序自身处理，错误是无法处理的
    • Throwable类常用方法
      • public string getMessage():返回异常发生时的详细信息
      • public string toString():返回异常发生时的简要描述
      • public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
      • public void printStackTrace():在控制台上打印Throwable对象封装的异常信息
    • 异常处理总结
      • try 块： 用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
      • catch 块： 用于处理try捕获到的异常。
      • finally 块： 无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return 语句时，finally语句块将在方法返回之前被执行。
        • 例外：
          • 在finally语句块第一行发生了异常。 因为在其他行，finally块还是会得到执行
          • 在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ；若该语句在异常语句之后，finally会执行
          • 程序所在的线程死亡。
          • 关闭CPU。
      • PS当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally语句的返回值将会覆盖原始的返回值

46. transient：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。

47. java中IO流

    • 分类：
      • 按照流的流向分，可以分为输入流和输出流；
      • 按照操作单元划分，可以划分为字节流（8位）和字符流（16位）；
      • 按照流的角色划分为节点流和处理流。
    • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
    • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
    • BIO，NIO与AIO
      • BIO：同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成，在面对活动连接数较小的情况下，表现不错
      • NIO：同步非阻塞的I/O模型，它支持面向缓冲的，基于通道的I/O操作方法。在高负载，高并发的网络中效果不错
      • AIO：是NIO的改进版，它是异步非阻塞的IO模型。异步IO是基于时间和回调机制实现的，也就是应用操作以后会直接返回，不会阻塞在哪里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

48. Files的常用方法：

    • Files.exists();检测文件路径是否存在
    • Files.createFile（）；创建文件
    • Files.createDirectory()；创建文件夹
    • Files.delete() 删除文件或者目录
    • Files.copy()
    • Files.move()
    • Files.size()
    • Files.read()
    • Files.write()

49. java容器图：

    

    • Collection：一个独立元素的序列，这些元素都服从一条或者多头规则。其中List必须按照插入的顺序保存元素，set不能有重复的元素，List和Set继承collection接口
    • map：键值对