2020Java面试宝典 -- JavaSE基础篇

Java面试题新开系列：2020Java面试宝典，定时更新，望大家监督哈哈，另外本人水平有限，文章多有疏漏之处，请读者指正。

一 Java 常用名词释义

1、面向对象都有哪些特性以及你对这些特性的理解（经典题，答的出色加分，答不出来很减分哦）

1）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。

2） 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。

3） 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当 A 系统访问 B 系统提供的服务时，B 系统有多种提供服务的方式，但一切对 A 系统来说都是透明的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

4）抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

注：默认情况下面向对象有 3 大特性，封装、继承、多态，如果面试官问让说出 4 大特性，那就把抽象加上去。

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

不同的权限修饰符的区别见下表：

3、谈谈你对Java面向对象的理解？(重要)

总结：

• 面向对象是相对面向过程而言
• 面向对象和面向过程都是一种思想
• 面向过程强调的是功能、行为
• 面向对象是将功能封装进对象，强调具备了功能的对象
• 面向对象是基于面向过程的

举一个面向对象例子方便了解(来自毕向东老师的Java视频)：

把大象放进冰箱里分为以下步骤：把冰箱门打开；把大象放进去；关上冰箱门（强调过程和过程中所涉及的行为（强调行为、动作、过程））。

用面向对象思想考虑：无论是打开冰箱，放进大象，关闭冰箱，所有操作都是操作冰箱这个对象，所以只需要将所有功能都定义在冰箱这个对象上，冰箱上就有打开、存储、关闭得所有功能 。

由上可知，面向对象是一种思想，能让复杂问题简单化，程序员不需要了解具体的实现过程，只需要指挥对象去实现功能。例，面试官面试面试者就是面向对象的体现，面试官需要找具有编程功能的对象（面试者），而我就是一个具有编程功能的对象，面试完后，让面试者去编程，面试者就去实现编程功能。

面向过程和面向对象区别如图所示：

二 JavaSE的基础语法

0、 Java 的基本数据类型相关面试题

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

相关面试题：

1、java中float f=1.1为什么不合法？

因为Java里带有小数点的数默认是double类型，所以1.1在这里是double类型，
把他赋值给比他小的float类型就会出错。
规定 float 类必须在数据后面加上 f 或者 F 。你想通过编译的话有3种方法改：
double f=1.1;
或者
float f=1.1f;
或者
float f=(float)1.1;

2、short s1 = 1; s1 = s1 + 1;有什么错? -- short转int有错

short s1 = 1; s1 +=1;有什么错? -- 无错

对于short s1 = 1; s1 = s1 + 1; 
由于s1+1运算时会自动提升表达式的类型，所以结果是int型，
再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，
java编译器会对它进行特殊处理，因此可以正确编译。

3、用最有效率的方法算出2乘以8等于几? -- 2 << 3

2 << 3，
因为将一个数左移n位，就相当于乘以了2的n次方，
那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，
效率最高，所以，2乘以8等于几的最效率的方法是：2 << 3。

4、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

switch可作用于char byte short int 及其对应的包装类
switch不可作用于long double float boolean，包括他们的包装类。
switch中可以是字符串类型--String(jdk1.7之后才可以作用在string上)。
switch中可以是枚举类型。

5、Integer与int的区别？

int是java提供的8种原始数据类型之一。
Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。
int的默认值为0，而Integer的默认值为null，
即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。
例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。
在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，
值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，
结果为0，所以，int不适合作为web层的表单数据的类型。
另外，Integer提供了多个与整数相关的操作方法。
例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

6、String s = new String("xyz");创建了几个String Object?

二者之间有什么区别？

两个或一个。
”xyz”对应一个对象，这个对象放在字符串常量缓冲区，
常量”xyz”不管出现多少遍，都是缓冲区中的那一个。
New String每写一遍，就创建一个新的对象，
New String("xyz")用那个常量”xyz”对象的内容来创建出一个新String对象。
如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

1、 Java 有没有 goto 语句？

goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。

2、& 和 && 的区别？

&运算符有两种用法：(1)按位与，(2)逻辑与。

&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是 true 整个表达式的值才是 true。 &&之所以称为短路运算是因为，如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。

很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是 null 而且不是空字符串，应当写为 username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的 equals 比较，否则会产生 NullPointerException 异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

3、在 Java 中，如何跳出当前的多重嵌套循环

在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环。（Java 中支持带标签的 break 和 continue语句，作用有点类似于 C 和 C++中的 goto 语句，但是就像要避免使用 goto 一样）。

4、是否可以继承 String？

String 类是 final 类，不可以被继承。继承 String 本身就是一个错误的行为，对 String 类型最好的重用方式是关联关系（Has-A）和依赖关系（Use-A）而不是继承关系（Is-A）。

但可以自己写一个String类，使用时候注意区分包名即可。

5、重载（overload）和重写（override）的区别？重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。

方法重载的规则：

1.方法名一致，参数列表中参数的顺序，类型，个数不同。
2.重载与方法的返回值无关，存在于父类和子类，同类中。
3.可以抛出不同的异常，可以有不同修饰符。

方法重写的规则：

1.参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写方法的返回类型一致。
2.构造方法不能被重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是能够被再次声明。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.重写的方法能够抛出任何非强制异常（UncheckedException，也叫非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

6、为什么函数不能根据返回类型来区分重载？

该道题来自华为面试题。因为调用时不能指定类型信息，编译器不知道你要调用哪个函数。

例如：

1．float max(int a, int b); 
2．int max(int a, int b);

当调用 max(1, 2);时无法确定调用的是哪个，单从这一点上来说，仅返回值类型不同的重载是不应该允许的。

再比如对下面这两个方法来说，虽然它们有同样的名字和自变量，但其实是很容易区分的：

1．void f() {}  
2．int f() {}

若编译器可根据上下文（语境）明确判断出含义，比如在 int x=f()中，那么这样做完全没有问题。然而，我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法”，因为我

们关心的不是返回值，而是方法调用的其他效果。所以假如我们像下面这样调用方法： f(); Java 怎样判断 f()的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能。

函数的返回值只是作为函数运行之后的一个“状态”，他是保持方法的调用者与被调用者进行通信的关键。并不能作为某个方法的“标识”。

7、两个对象值相同 (x.equals(y) == true) ，但却可有不同的 hashCode，这句话对不对？

不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hashCode）应当相同。 即对象相同，哈希值一定相同。

Java 对于 eqauls 方法和 hashCode 方法是这样规定的：(1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同；(2)如果两个对象的 hashCode 相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

关于 equals 和 hashCode 方法，很多 Java 程序员都知道，但很多人也就是仅仅知道而已，在 Joshua Bloch 的大作《Effective Java》（很多软件公司，《Effective Java》、《Java 编程思想》以及《重构：改善既有代码质量》是 Java 程序员必看书籍，如果你还没看过，那就赶紧去买一本吧）中是这样介绍 equals 方法的。

首先 equals 方法必须满足自反性（x.equals(x)必须返回 true）、对称性（x.equals(y)返回 true 时，y.equals(x)也必须返回 true）、传递性（x.equals(y)和 y.equals(z)都返回 true 时，x.equals(z)也必须返回 true）和一致性（当x 和 y 引用的对象信息没有被修改时，多次调用 x.equals(y)应该得到同样的返回值），而且对于任何非 null 值的引用 x，x.equals(null)必须返回 false。

实现高质量的 equals 方法的诀窍包括：

1.  使用==操作符检查"参数是否为这个对象的引用"；
2.  使用  instanceof  操作符检查"参数是否为正确的类型"；
3.  对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；
4.  编写完  equals  方法后，问自己它是否满足对称性、传递性、一致性；
5.  重写  equals  时总是要重写  hashCode；
6.  不要将  equals  方法参数中的  Object  对象替换为其他的类型，在重写时不要忘掉@Override  注解。

8、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的。

9、 char 型变量中能不能存储一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

补充：使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式，在 JVM 内部都是 Unicode，当这个字符被从 JVM 内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader 和 OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务。

10. 抽象类(abstract class)和接口(interface)有什么异同？

不同：

抽象类：

1.抽象类中可以定义构造器 
2.可以有抽象方法和具体方法 
3.接口中的成员全都是 public 的 
4.抽象类中可以定义成员变量 
5.有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法 
6.抽象类中可以包含静态方法 
7.一个类只能继承一个抽象类

接口：

1.接口中不能定义构造器 
2.方法全部都是抽象方法 
3.抽象类中的成员可以是  private、default、protected、public 
4.接口中定义的成员变量实际上都是常量 
5.接口中不能有静态方法 
6.一个类可以实现多个接口

相同：

1.不能够实例化 
2.可以将抽象类和接口类型作为引用类型
3.一个类如果继承了某个抽象类或者实现了某个接口
都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类 

11、抽象的(abstract)方法是否可同时是静态的(static), 是否可同时是本地方法(native)，是否可同时被 synchronized ？

都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如C/C++ 代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

12、简述静态变量和实例变量的区别？

静态变量: 是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；

实例变量: 必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

13. ==和 equals 的区别？

equals 和== 最大的区别是一个是方法一个是运算符。

==：如果比较的对象是基本数据类型，则比较的是数值是否相等；如果比较的是引用数据类型，则比较的是对象的地址值是否相等。

equals()：用来比较方法两个对象的内容是否相等。

注意：equals 方法不能用于基本数据类型的变量，如果没有对 equals 方法进行重写，则比较的是引用类型的变量所指向的对象的地址。

String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，
这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，
所以，表达式a==b将返回false.
而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等.
例如:String input = …;input.equals(“quit”)，
许多人稍不注意就使用==进行比较了，这是错误的。
记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，
Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，
它默认的equals方法（从Object 类继承的）就是使用==操作符，
也是在比较两个变量指向的对象是否是同一对象，
这时候使用equals和使用==会得到同样的结果，
如果比较的是两个独立的对象则总返回false。
如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，
那么你必须覆盖equals方法，
由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

14、break 和 continue 的区别？

break 和 continue 都是用来控制循环的语句。

break 用于完全结束一个循环，跳出循环体执行循环后面的语句。

continue 用于跳过本次循环，执行下次循环。

15、String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？

没有。因为 String 被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s 原先指向一个 String 对象，内容是 "Hello"，然后我们对 s 进行了“+”操作，那么 s 所指向的那个对象是否发生了改变呢？答案是没有。这时，s 不指向原来那个对象了，而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来表示。这时，应该考虑使用 StringBuffer 类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。例如我们要在构造器中对一个名叫 s 的 String 引用变量进行初始化，把它设置为初始值，应当这样做：

public class Demo { 
   private String s; 
     ... 
     s = "Initial Value"; 
      ... 
}

而非 ：

s = new String("Initial Value");

后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为 String 对象不可改变，所以对于内容相同的字符串，只要一个 String 对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的 String 类型属性 s 都指向同一个对象。

上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java 认为它们代表同一个 String 对象。而用关键字 new 调用构造器，总是会创建一个新的对象，无论内容是否相同。至于为什么要把 String 类设计成不可变类，是它的用途决定的。其实不只 String，很多 Java 标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以 Java 标准类库还提供了一个可变版本，即 StringBuffer。

16、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

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

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

例如，对于如下语句：

 final StringBuffer a=new StringBuffer("immutable");

执行如下语句将报告编译期错误：

a=new StringBuffer("");

但是，执行如下语句则可以通过编译：

a.append(" broken!");

有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：

publicvoid method(final  StringBuffer  param){
}

实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：

param.append("a");

17、GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显式操作方法。

拓展知识：

1、垃圾回收的优点和原理？

Java语言中一个显著的特点就是引入了垃圾回收机制，
使c++程序员最头疼的内存管理的问题迎刃而解，
它使得Java程序员在编写程序的时候不再需要考虑内存管理。
由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，
只有对象的引用才有"作用域"。
垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。
垃圾回收器通常是作为一个单独的低级别的线程运行，
不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，
程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

垃圾回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

2、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？

有什么办法主动通知虚拟机进行垃圾回收？

对于GC来说，当程序员创建对象时，
GC就开始监控这个对象的地址、大小以及使用情况。
通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。
通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。
当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。
程序员可以手动执行System.gc()，通知GC运行，
但是Java语言规范并不保证GC一定会执行。

本系列Java面试题很多代码来自网络，后加上作者的修改。如有侵权，联系作者(公众号后台留言即可)马上删除。

参考文章：

2019Java面试宝典 -- JavaSE基础篇

java面向对象：

https://blog.csdn.net/qq_34569497/article/details/81910426

Java面试宝典 -- 黑马程序员