第一天----Java面试题(末文Kotlin

WeChat–Java基础面试题汇总

1、== 和 equals 的区别是什么？

答：==是操作符，是比较两个对象的地址或基本类型，equals是比较两个对象的内容，属于Object里的方法。

2、java 中的 Math.round(-1.5) 等于多少，Math.round（1.5)等于多少？

答：等于-1，等于2
计算方法：
1）、参数的小数点后第一位<5，运算结果为参数整数部分
2）、参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正 负）不变。
3）、参数的 小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。
总结：大于五全部加，等于五正数加， 小于五全不加件等。

3、 Java 中的重载和重写的区别？

重载和重写都允许你用相同的名称来实现不同的功能，
但是重载是编译时活动，而重写是运行时活动。
可以在同一个类中重载方法，但是只能在子类中重写方法。
重写必须要有继承
重写：
1）、在子类中可以根据需要对从基类中继承来的方法进行重写。
2）、重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。
3）、重写方法不能使用比被重写的方法更严格的访问权限。
重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。
无法以返回型别作为重载函数的区分标准。

4、java 中操作字符串都有哪些类？它们之间有什么区别？

答：String、StringBuffer、StringBuilder可以操作拼接字符串
区别：String是不可变的对象，对每次对String类型的改变时都会生成一个新的对象，
StringBuffer和StringBuilder是可以改变对象的。
对于操作效率：StringBuilder > StringBuffer > String
对于线程安全：StringBuffer 是线程安全，可用于多线程；
StringBuilder 是非线程安全，用于单线程

5、访问修饰符public,private,protected,以及不写（默认）时的区别？

答：类的成员不写访问修饰时默认为default。
默认对于同一个包中的其他类相当于公开（public），
对于不是同一个包中的其他类相当于私有（private）。
受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。
Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。
简单些说：Protected可在包内及包外子类访问，
default只能同一包内访问，prvate只能同一类。

6、int和Integer有什么区别，为什么要使用包装类？

答：为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型，
比如int的包装类就是Integer，Java 为每个原始类型提供了包装类型：

• 原始类型: boolean，char，byte，short，int，long，float，double
• 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

7、抽象类（abstract class）和接口（interface）有什么区别？

1）、抽象类和接口都不能够实例化、不能有构造方法，接口用interface来修饰
2）、类能实现一个或多个接口，但只能继承一个抽象类
3）、接口里的方法只能是抽象方法、类方法或者默认方法，
接口里的方法不能有方法实现，但类方法、默认方法都必须要实现。
4）、用抽象类是为了重用。减少编码量，降低耦合性。

8、常见的运行时异常？

答：- ClassNotFoundException（类找不到异常）
- ClassCastException （类转换异常）
- IllegalArgumentException （非法参数异常）
- IndexOutOfBoundsException （下标越界异常）
- NullPointerException （空指针异常）
- SecurityException （安全异常）

9、Java 中堆和栈有什么区别？

答：JVM 中堆和栈属于不同的内存区域，使用目的也不同。
栈常用于保存方法帧和局部变量，而对象总是在堆上分配。
栈通常都比堆小，也不会在多个线程之间共享，而堆被整个 JVM 的所有线程共享。

WeChat–万字梳理，带你拿下Java 面试题！

10、值传递和引用传递的区别？

值传递是指在调用函数时将实际参数复制一份到函数中，
这样的话如果函数对其传递过来的形式参数进行修改，将不会影响到实际参数

引用传递是指在调用函数时将对象的地址直接传递到函数中，
如果在对形式参数进行修改，将影响到实际参数的值。

11、== 和 equals 区别是什么

== 是 Java 中一种操作符，它有两种比较方式。

对于基本数据类型来说， == 判断的是两边的值是否相等；

对于引用类型来说， == 判断的是两边的引用是否相等，也就是判断两个对象是否指向了同一块内存区域。

equals 是 Java 中所有对象的父类，即 Object 类定义的一个方法。
它只能比较对象，它表示的是引用双方的值是否相等。

equals 用作对象之间的比较具有如下特性：
自反性：对于任何非空引用 x 来说，x.equals(x) 应该返回 true。
对称性：对于任何非空引用 x 和 y 来说，若x.equals（y）为 true，则y.equals（x）也为 true。
传递性：对于任何非空引用的值来说，有三个值，x、y 和 z，如果x.equals(y) 返回true，y.equals(z) 返回true，那么x.equals(z) 也应该返回true。
一致性：对于任何非空引用 x 和 y 来说，如果 x.equals(y) 相等的话，那么它们必须始终相等。
非空性：对于任何非空引用的值 x 来说，x.equals(null) 必须返回 false。

12、String s1 = new String(“abc”) 在内存中创建了一个或者两个对象

String s1 是声明了一个 String 类型的 s1 变量，它不是对象。
使用 new 关键字会在堆中创建一个对象，另外一个对象是 abc ，它会在常量池中创建，所以一共创建了两个对象；
如果 abc 在常量池中已经存在的话，那么就会创建一个对象。

13、static 是 Java 中非常重要的关键字，static 表示的概念是静态的

修饰变量，static 修饰的变量称为静态变量、也称为类变量，
类变量属于类所有，对于不同的类来说，static 变量只有一份，static 修饰的变量位于方法区中；
static 修饰的变量能够直接通过 类名.变量名 来进行访问，不用通过实例化类再进行使用；

修饰方法，static 修饰的方法被称为静态方法，静态方法能够直接通过 类名.方法名 来使用，
在静态方法内部不能使用非静态属性和方法；

static 可以修饰代码块，主要分为两种，
一种直接定义在类中，使用 static{}，这种被称为静态代码块，
一种是在类中定义静态内部类，使用 static class xxx 来进行定义；

static 可以用于静态导包，通过使用 import static xxx 来实现，这种方式一般不推荐使用；

static 可以和单例模式一起使用，通过双重检查锁来实现线程安全的单例模式。

14、final 关键字表示的意思是不可变的

修饰类，final 修饰的类不能被继承，不能被继承的意思就是不能使用 extends 来继承被 final 修饰的类；

修饰变量，final 修饰的变量不能被改写，不能被改写的意思有两种，
对于基本数据类型来说，final 修饰的变量，其值不能被改变，
final 修饰的对象，对象的引用不能被改变，但是对象内部的属性可以被修改。
final 修饰的变量在某种程度上起到了不可变的效果，
所以，可以用来保护只读数据，尤其是在并发编程中，因为明确的不能再为 final 变量进行赋值，
有利于减少额外的同步开销；

修饰方法，final 修饰的方法不能被重写；

final 修饰符和 Java 程序性能优化没有必然联系。

15、抽象类和接口中都允许进行方法的定义，而不用具体的方法实现。抽象类和接口都允许被继承，它们广泛的应用于 JDK 和框架的源码中，来实现多态和不同的设计模式。

抽象级别不同：类、抽象类、接口其实是三种不同的抽象级别，抽象程度依次是 接口 > 抽象类 > 类。
在接口中，只允许进行方法的定义，不允许有方法的实现，
抽象类中可以进行方法的定义和实现；
而类中只允许进行方法的实现，此处的方法的定义是不允许在方法后面出现 {}。

使用的关键字不同：类使用 class 来表示；抽象类使用 abstract class 来表示；接口使用 interface 来表示。

变量：接口中定义的变量只能是公共的静态常量，抽象类中的变量是普通变量。

16、重写和重载都是对同一方法的不同表现形式

子父级关系不同，重写是针对子级和父级的不同表现形式，而重载是在同一类中的不同表现形式；

概念不同，子类重写父类的方法一般使用 @override 来表示；
重写后的方法其方法的声明和参数类型、顺序必须要与父类完全一致；
重载是针对同一类中概念，它要求重载的方法必须满足下面任何一个要求：
方法参数的顺序，参数的个数，参数的类型任意一个保持不同即可。

17、ArrayList、LinkedList、Vector 都是位于 java.util 包下的工具类，它们都实现了 List 接口。

ArrayList 的底层是动态数组，它是基于数组的特性而演变出来的，
所以ArrayList 遍历访问非常快，但是增删比较慢，因为会涉及到数组的拷贝。
ArrayList 是一个非线程安全的容器，在并发场景下会造成问题，
如果想使用线程安全的容器的话，推荐使用 Collections.synchronizedList；
ArrayList 在扩容时会增加 50% 的容量。

LinkedList 的底层是双向链表，所以 LinkedList 的增加和删除非常快，
只需把元素删除，把各自的指针指向新的元素即可。
但是 LinkedList 遍历比较慢，因为只有每次访问一个元素才能知道下一个元素的值。
LinkedList 也是一个非线程安全的容器，推荐使用 Collections.synchronizedList

Vector 向量是最早出现的集合容器，Vector 是一个线程安全的容器，
它的每个方法都粗暴的加上了 synchronized 锁，所以它的增删、遍历效率都很低。
Vector 在扩容时，它的容量会增加一倍。

18、Exception 和 Error 有什么区别？

Exception 泛指的是 异常，Exception 主要分为两种异常，
一种是编译期出现的异常，称为 checkedException ，
一种是程序运行期间出现的异常，称为uncheckedException，
常见的 checkedException 有 IOException，uncheckedException 统称为 RuntimeException，
常见的 RuntimeException 主要有NullPointerException、IllegalArgumentException、ArrayIndexOutofBoundException等，Exception 可以被捕获。

Error 是指程序运行过程中出现的错误，通常情况下会造成程序的崩溃，
Error 通常是不可恢复的，Error 不能被捕获。

19、String、StringBuilder 和 StringBuffer 有什么区别？

String 特指的是 Java 中的字符串，String 类位于 java.lang 包下，
String 类是由 final 修饰的，String 字符串一旦创建就不能被修改，
任何对 String 进行修改的操作都相当于重新创建了一个字符串。
String 字符串的底层使用 StringBuilder 来实现的。

StringBuilder 位于 java.util 包下，StringBuilder 是一非线程安全的容器，
StringBuilder 的 append 方法常用于字符串拼接，它的拼接效率要比 String 中 + 号的拼接效率高。
StringBuilder 一般不用于并发环境。

StringBuffer 位于 java.util 包下，StringBuffer 是一个线程安全的容器，
多线程场景下一般使用 StringBuffer 用作字符串的拼接。

StringBuilder 和 StringBuffer 都是继承于AbstractStringBuilder 类，
AbstractStringBuilder 类实现了 StringBuffer 和 StringBuilder 的常规操作。

20、int 是 Java 中的基本数据类型

int 代表的是 整型，一个 int 占 4 字节，也就是 32 位，int 的初始值是默认值是 0 ，
int 在 Java 内存模型中被分配在栈中，int 没有方法；

Integer 是 Java 中的基本数据类型的包装类，Integer 是一个对象，
Integer 可以进行方法调用，Integer 的默认值是 null，Integer 在 Java 内存模型中被分配在堆中。

int 和 Integer 在计算时可以进行相互转换，
int -> Integer 的过程称为 装箱，Integer -> int 的过程称为 拆箱，
Integer 还有 IntegerCache ，会自动缓存 -128 - 127 中的值

21、Object 类是所有对象的父类，它里面包含一些所有对象都能够使用的方法：

hashCode()：用于计算对象的哈希码
equals()：用于对象之间比较值是否相等
toString(): 用于把对象转换成为字符串
clone(): 用于对象之间的拷贝
wait(): 用于实现对象之间的等待
notify(): 用于通知对象释放资源
notifyAll(): 用于通知所有对象释放资源
finalize(): 用于告知垃圾回收器进行垃圾回收
getClass(): 用于获得对象类

22、可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

内部类的分类一般主要有四种：
静态内部类就是定义在类内部的静态类，静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；

成员内部类就是定义在类内部，成员位置上的非静态类，就是成员内部类。
成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。

定义在方法中的内部类，就是局部内部类。
定义在实例方法中的局部类可以访问外部类的所有变量和方法，
定义在静态方法中的局部类只能访问外部类的静态变量和方法。

匿名内部类就是没有名字的内部类，除了没有名字：
匿名内部类必须继承一个抽象类或者实现一个接口；
匿名内部类不能定义任何静态成员和静态方法；
当所在的方法的形参需要被匿名内部类使用时，必须声明为 final；
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

23、常用的异常

NullPointerException: 空指针异常
NoSuchMethodException：找不到方法
IllegalArgumentException：不合法的参数异常
IndexOutOfBoundException: 数组下标越界异常
IOException：由于文件未找到、未打开或者I/O操作不能进行而引起异常
ClassNotFoundException ：找不到文件所抛出的异常
NumberFormatException：字符的UTF代码数据格式有错引起异常；
InterruptedException：线程中断抛出的异常

WeChat–阿里P9精选：校招面试题之Java语言基础篇

24、Java 中的 Math. round(-1. 5)等于 -1

因为在数轴上取值时，中间值（0.5）向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。

25、String 属于对象，不属于基础类型

基础类型有 8 种：byte、boolean、char、short、int、float、long、double，

26、操作字符串的类有：String、StringBuffer、StringBuilder。

String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象，
每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象，

而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作，
所以在经常改变字符串内容的情况下最好不要使用 String。

StringBuffer 和 StringBuilder 最大的区别在于，StringBuffer 是线程安全的，
而 StringBuilder 是非线程安全的，但 StringBuilder 的性能却高于 StringBuffer，
所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。

27、String str="i"与 String str=new String(“i”)内存的分配方式不一样。

String str="i"的方式，Java 虚拟机会将其分配到常量池中；
而 String str=new String(“i”) 则会被分到堆内存中。

28、使用 StringBuilder 或者 stringBuffer . reverse() 方法将字符串反转

29、String 类的常用方法

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

WeChat–Java基础知识面试题大集合

30、分类

基本数据类型
整数类型(byte,short,int,long)
浮点类型(float,double)
数值型
字符型(char)
布尔型(boolean)

引用数据类型
类(class)
接口(interface)
数组([])

31、用最有效率的方法计算 2 乘以 8

2 << 3（左移 3 位相当于乘以 2 的 3 次方，右移 3 位相当于除以 2 的 3 次方）。

32、Math.round(11.5)返回值是 12，Math.round(-11.5)返回值是-11。

四舍五入的原理是在参数上加 0.5 然后进行下取整。

33、float f=3.4;不正确。

3.4 是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成 float f =3.4F;。

34、对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型，因此 s1+1 运算结果也是 int型，需要强制转换类型才能赋值给 short 型。

而 short s1 = 1; s1 += 1;可以正确编译，因为 s1+= 1;相当于 s1 = (short(s1 + 1);其中有隐含的强制类型转换。

35、可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。
public : 对所有类可见。使用对象：类、接口、变量、方法

36、&运算符有两种用法(1)按位与；(2)逻辑与。&&运算符是短路与运算。

虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。
如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。

逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

37、final finally finalize区别

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、
修饰变量表示该变量是一个常量不能被重新赋值。
finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，
表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，
当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()（一个对象是否可回收的最后判断）回收垃圾。

38、super（参数）：调用父类中的某一个构造函数。this（参数）：调用本类中另一种形式的构造函数。

（都应该为构造函数中的第一条语句）

39、static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！

static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。
static块可以置于类中的任何地方，类中可以有多个static块。
在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。
因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

40、接口和抽象类都不能实例化，都位于继承的顶端用于被其他实现或继承，都包含抽象方法其子类都必须覆写这些抽象方法

41、方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），
与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分

重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，
访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

42、JDK 中常用的包

java.lang：这个是系统的基础类；
java.io：这里面是所有输入输出有关的类，比如文件操作等；
java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；
java.net：这里面是与网络有关的类；
java.util：这个是系统辅助类，特别是集合类；
java.sql：这个是数据库操作的类。

43、java 中 IO 流分为几种?

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

Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。
InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

44、String 类是 final 类，不可以被继承。

45、String s = new String(“xyz”);创建了两个对象，一个是静态区的"xyz"，一个是用new创建在堆上的对象。

46、因为内存的分配方式不一样，String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。

47、String 类的常用方法都有那些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

48、HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以当创建字符串时，它的 hashcode 被缓存下来，不需要再次计算，所以相比于其他对象更快。

WeChat–精选Java基础面试120题（附刷题小程序）

49、标识符是大小写字母、数字字符、$和_组成，不能以数字开头，也不能是java关键字，并且区分大小写

50、常用的DOS命令并解释？

d: 回车 盘符切换
dir (directory) 列出当前目录下的文件以及文件夹
cd (change directory) 改变指定目录(进入指定目录)
cd… 退回到上一层目录
cd \ 退回到跟目录
md (make directory) 创建目录
rd (remove directory) 删除目录
del (delete) 删除文件，删除一堆后缀名一样的文件*.txt
cls (clear screen) 清屏
exit 退出dos命令行

51、强制类型转换容量大的类型向容量小的类型转换时使用，隐式类型转换容器小的类型向容量大的类型转换时使用

52、==比较运算符，用来比较操作符两边的变量的值是否相等。

=赋值运算符，把操作符右边的值，赋值给左边的变量

53、this用来解决成员变量与局部变量重名问题 this关键字代表的是本类对象引用；谁调用我,this就代表谁.

54、package，包的意思，其实就是文件夹，它可以对类进行分类管理

55、String s = “a”+“b”+”c”; 创建了5个对象，a、b、c、ab、abc

56、如何实现StringBuffer和String的相互转换？

通过String类的构造方法
通过StringBuffer类中的toString()方法
通过StringBuffer类中的substring()方法 (注：不常用) String 转换到 StringBuffer的方式：
通过StringBuffer类的构造方法
通过StringBuffer类的append()、insert()方法

57、String类表示内容不可以改变的字符串，StringBuffer类表示内容可以被修改的字符串

58、使用 StringBuilder 或者 stringBuffer.reverse() 方法将字符串反转。

59、 String 类的常用方法都有那些？

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

60、请说明一个对象的创建过程做了哪些事情？

Student s = new Student();

将Student.class 字节码文件加载到内存
在栈内存中，开辟一个空间存储 s变量，用来记录Student对象的引用
在堆内存中，开辟一个空间存储 new Student()对象的成员信息
加载类中静态成员
执行类中静态代码块
加载对象中普通成员
执行构造代码块
执行构造方法
将new Student()的地址赋值给 s 变量

61、抽象类虽然不能进行实例化,但是抽象类中是存在构造方法，该构造方法的作用是用于子类访问父类数据时的初始化.

62、一个类可以继承一个类的同时实现多个接口，接口与接口可以是单继承也可以是多继承

类与类是继承的关系,只支持单继承,可以是多层继承。
类与接口是实现的关系,可以是多实现

63、线程安全Vector；非线程安全，查找多 ArrayList，增删多 LinkedList

ArrayList：底层数组结构
线程不同步、效率高、元素查找快、增删慢；

Vector：底层数组结构
线程同步、安全、元素查找快、增删慢

LinkedList：底层链表结构
线程不同步、效率高、元素增删快、查找慢

64、throws与throw的区别？

throws通常被应用在声明方法时，用来指定可能抛出的异常，多个异常可以使用逗号隔开。
当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。

throw通常用在方法体中，并且抛出一个异常对象。
程序在执行到throw语句时立即停止，它后面的语句都不执行。
通常throw抛出异常后，如果想在上一级代码中捕获并处理异常，
则需要在抛出异常的方法中使用throws关键字在方法声明中指定要抛出的异常；
如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

65、final、finally与finalize的区别？

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，
可以覆盖此方法提高垃圾收集时的其他资源回收，例如关闭文件等。
JVM不保证此方法总被调用。

66、异常的注意事项及如何使用异常处理？

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。

如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常。

如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，
如果子类方法内有异常发生，那么子类只能try…catch，不能throws

67、最常见到的RuntimeException异常

NullPointerException空指针引用异常
ClassCastException类型强制转换异常
IllegalArgumentException传递非法参数异常
ArithmeticException算术运算异常
ArrayStoreException向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException下标越界异常
NumberFormatException数字格式异常

68、简述IO流的分类

字节流
字节输入流 InputStream
字节输出流 OutputStream
字符流
字符输入流 Reader
字符输出流 Writer

69、Files的常用方法都有哪些？

Files.exists()：检测文件路径是否存在。
Files.createFile()：创建文件。
Files.createDirectory()：创建文件夹。
Files.delete()：删除一个文件或目录。
Files.copy()：复制文件。
Files.move()：移动文件。
Files.size()：查看文件个数。
Files.read()：读取文件。
Files.write()：写入文件。

WeChat–kotlin面试题看这一篇就行了

70、Kotlin中有两类构造函数 1.主要构造函数 2.次级构造函数

71、Kotlin类的默认行为？

Kotlin中所有的类默认为final.
Kotlin支持多继承，Open class比final class造成更多开销

72、使用== 操作符和compoareTo()扩展函数比较两个字符串

73、Val是在运行时被设置， 加一个const 修饰符在val上将会变成编译时常量。

Const不能修饰var，不能用于局部变量

74、！！操作符 和?.操作符 在打开可空变量时有什么区别？

！！操作符强行打开可空类型。如何返回值是Null，可导致运行时崩溃。 因此！！只用于你确定这个值不会为空。
?.是一个Elvis操作符可是安全的调用。 可以用lambda表达式 let来安全的调用

75、双等于比较双方的值是否相等， ===比较双方引用是否相等。

76、kotlin的可见修饰符为public, internal, protected, private 。public是默认的修饰符。

77、在Kotlin泛型中，*和Any的区别

List<*> 更够包含任何类型，但只有该擦除后的类型
List可以包含任何类型。