* 临近秋招，备战暑期实习，祝大家每天进步亿点点！
* 本篇总结的是Java基础知识相关的面试题，后续会每日更新~
---
## 1、请你说一下什么是面向对象？
Java是面向对象的编程语言，不同于C语言是面向过程的。对于面向对象和面向过程的区别，举一个简单的例子说明一下（我们以洗衣机洗衣服为例）：
* **面向过程**：面向过程的编程方式，程序会将要完成的某一个任务拆解成一系列的小步骤 (函数)，如：
* ① 打开洗衣机：`method01()`
* ② 放入要洗的衣服：`method02()`
* ③ 放入洗衣服：`method03()`
* ④ 清洗：`method04()`
* ⑤ 烘干：`method05()`
* **面向对象**：面向对象的编程方式，程序会将要完成的洗衣机洗衣服的任务拆分成如下两个对象：
* 人(`Person`)：`Person`在洗衣机洗衣服这个程序任务中有三个作用，分别是`打开洗衣机`、`放入要洗的衣服`、`放入洗衣粉`。
* 洗衣机(`Machine`)：`Machine`在洗衣机洗衣服这个程序任务中有两个作用，分别是`清洗`、`烘干`。
从上面这个例子能看出，**面向过程的编程方式比较直接且高效，而面向对象的编程方式更易复用、扩展和维护**！
---
## 2、请你简述一下面向对象的三个基本特征？
* **继承**：承是Java中面向对象最显著的一个特征，继承是从已有的类中派生出新的类，新的类可以吸收已有的属性、行为，并扩展新的能力。Java中不支持多继承，但是接口可以支持多实现。
* **封装**：将同一类事物的特征和功能包装在一起，只对外暴露需要调用的接口。封装也称为信息的隐藏，==在Java中接口是体现封装最常用的方法，在接口中我们没有任何功能的实现(具体实现都交给实现类)，只是定义了一系列抽象的方法声明用于外部调用==。
* **多态**：封装和继承都是为多态来服务的，多态是指同一个行为具有多个不同的表现形式。在Java中方法的重载和重写是实现多态的2种方式。
* 重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载。方法重载体现了**编译时的多态性**。
* 重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，重载对返回类型没有特殊的要求。方法重写体现了**运行时的多态性**。
**多态的三要素：继承 、重写、父类指向子类引用**！
---
## 3、为什么说 Java 是一种半解释半编译的程序设计语言呢？
**什么是编译形语言，什么又是解释形语言**？
- 编译型语言：把做好的源程序全部编译成二进制代码的可运行程序。然后，就可以直接运行这个程序。执行**速度快**，**效率高**，依靠编译器，**跨平台性稍差**。
- 解释型语言：把已经做好的源程序，翻译一句，执行一句，直到结束。执行**速度慢**，**效率低**，依靠编译器，但是**跨平台性稍好**。
> **那么为什么说Java 是编译型语言呢**？
第一个观点认为 Java 是编译型语言，因为Java程序想要运行，那么第一步就是要使用**Javac**进行编译(将Java源文件编译成`.class`二进制文件)。没有经过编译的`.java`文件，是没办法运行的！
> **那么为什么又说Java 是解释型语言呢**？
那么第二个观点则是认为Java是解释型语言，Java经过编译，**Javac** 将`.java`源文件编译成`.class`二进制文件之后，仍然需要借助 **JVM** 的解释执行。
综合上面两个观点来看，Java似乎既有编译型语言的特点，又有解释型语言的特点，也没有看到哪本权威的书籍上认定Java就是哪一种类型的语言。
---
## 4、请你说一下Java中的8大基本类型是那些？
如图所示：
**8种基本数据类型和取值范围**：
| 基本类型 | 大小(位/bit) | 字节数(byte) | 最小值 | 最大值 | 默认值 | 包装器类型 |
| :------: | :----------: | :----------: | :-------: | :------------: | :----: | :-----------: |
| boolean | - | - | false | true | false | **Boolean** |
| char | 16 bits | 2 bytes | Unicode 0 | Unicode 2^16-1 | 空 | **Character** |
| byte | 8 bits | 1 byte | -2^7 | 2^7-1 | 0 | **Byte** |
| short | 16 bits | 2 bytes | -2~15 | 2^15-1 | 0 | **Short** |
| int | 32 bits | 4 bytes | -2^31 | 2^31-1 | 0 | **Integer** |
| long | 64 bits | 8 bytes | -2^63 | 2^63-1 | 0 | **Long** |
| float | 32 bits | 4 bytes | | | 0.0 | **Fload** |
| double | 64 bits | 8 bytes | | | 0.0 | **Double** |
**注意**：对于`boolean`值，在Java规范中并没有给出其储存大小，**在《Java虚拟机规范》**中给出了4个字节，和`boolean`数组1个字节的定义，具体还要看虚拟机实现是否按照规范来，所以1个字节、4个字节都是有可能的。除了**void**之外，其他8种基本数据类型被称为**八大基本数据类型**。
图中从左向右的转换都是**隐式转换**，无需再代码中进行强制转换。从右向左均要进行**强制类型转换**，才能通过编译。强制转换会丢失精度。
---
## 5、请你讲讲抽象类和接口有什么区别?
* **(一) 继承方面**：
* 抽象类只能单继承；而接口可以多实现；
* **(二) 成员属性方面**：
* 抽象类中可以有普通属性，也可以有常量；
* 接口中的成员变量全部默认是常量，使用`public static final`修饰，这个可以省略不写;
* **(三) 代码块方面**：
* 抽象类可以含初始化块；接口不能含初始化块;
* **(四) 构造函数方面**：
* 抽象类可以有构函数，但是这里的构造函数不是用来创建对象的，而且用来被实现类调用进行初始化操作的;
* 接口不能有构造函数;
* **(五) 方法方面**：
* 接口在JDK1.8之后可以定义抽象方法(无方法体)、`default` 修饰的默认方法(有方法体)、`static`修饰的静态方法(有方法体)，JDK1.8以前是只能有抽象方法。
```java
public interface Test {
static void test() {
}
default void test2(){
}
void test3();// 默认是abstract修饰
}
```
* 抽象类中除了静态方法和抽象方法外还可以有普通方法。
> 二者相同之处
* 接口与抽象类**都不能被实例化**，需要被其他进行实现或继承。
* 接口与抽象类里面**都能包含抽象方法**，实现接口或继承抽象类的子类都必须实现这些抽象方法。
---
## 6、请判断当一个对象被当作参数传递给一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
==是值传递==。java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
**java中只有值传递，基本类型传递的是值的副本，引用类型传递的是引用的副本**
---
## 7、请你说一下JVM/JRE/JDK的区别？
直接看一张图就可以理解他们的区别了：
* JVM = Java虚拟机
* JRE = JVM + 基础类库
* JDK = JVM + 基础类库 + 编译工具
---
## 8、请你说一下方法重载和方法重写的区别？
* **重载**：方法重载发生在同一个类中，重载的方法之间方法名必须相同，参数列表不同（参数的类型、参数的个数），方法的返回值和访问修饰符可以不同，发生在编译时期（方法重载实现了编译时多态）。
* **重写**：方法重写发生在子父类中，子类重写父类的方法，方法名称必须相同，参数列表也必须相同，方法的返回值**小于等于**父类方法的返回值，访问修饰符方位大于等于父类方法（如果父类方法修饰符为`private`，则子类就无法重写了）。
----
## 9、请你说一下List接口和Set接口的区别？
* `List`：有序、可重复集合。按照对象插入的顺寻保存数据，允许多个`Null`元素对象，可以使用`iterator`迭代器遍历，也可以使用`get(int index)`方法获取指定下标元素。
* `Set`：无序、不可重复集合只允许有一个`Null`元素对象，取元素时，只能使用`iterator`迭代器逐一遍历。
* `Map`： key-value 键值对形式的集合，添加或获取元素时，需要通过key来检索到value。
*Collecttion* 集合体系结构简图：
参考文章：[Java集合中List,Set以及Map等集合体系详解](https://blog.csdn.net/zhangqunshuai/article/details/80660974)
---
## 10、为什么重写了equals()方法还需要重写hashCode()方法？
`equals()`只是判断对象属性是否相同，`hashCode()`要判断二者地址是否相同。java中如果要判断两个对象是否相等，需要同时满足`地址 + 属性`都相同!
* 如果两个对象相同（即：用 `equals()` 比较返回`true`），那么它们的 `hashCode` 值一定要相同；
* 如果两个对象的 `hashCode` 相同，它们并不一定相同；
举例子：
**只重写 `equals()` 方法，不重写 `hashcode()` 方法：**
```java
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
// 省略 get，set方法...
}
```
执行下面的程序看看效果：
```java
public class hashTest {
@Test
public void test() {
Student stu1 = new Student("Jimmy",24);
Student stu2 = new Student("Jimmy",24);
System.out.println("两位同学是同一个人吗？"+stu1.equals(stu2));
System.out.println("stu1.hashCode() = "+stu1.hashCode());
System.out.println("stu1.hashCode() = "+stu2.hashCode());
}
}
```
如果重写了 `equals()` 而未重写 `hashcode()` 方法，可能就会出现两个没有关系的对象 **equals** 相同（因为**equals**都是根据对象的特征进行重写的），但 **hashcode** 不相同的情况。因为此时 `Student` 类的 `hashcode()` 方法就是 Object 默认的 `hashcode()`方 法，由于默认的 `hashcode()`方法是根据对象的内存地址经哈希算法得来的，所以 `stu1 != stu2`，故两者的 **hashcode** 值不一定相等。
根据 **hashcode** 的规则，两个对象相等其 **hash** 值一定要相等，矛盾就这样产生了。上面我们已经解释了为什么要使用 **hashcode** 算法，所以即使字面量相等，但是产生两个不同的 **hashCode** 值显然不是我们想要的结果。
**如果我们在重写 equals() 时，也重写了 hashCode() 方法：**
```java
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
// 省略 get，set方法...
}
```
再来看执行结果：
```java
两位同学是同一个人吗？true
stu1.hashCode() = 71578563
stu1.hashCode() = 71578563
```
从 `Student` 类重写后的 `hashcode()` 方法中可以看出，重写后返回的新的 **hash** 值与 `Student` 的两个属性是有关，这样就确保了对象和对象地址之间的关联性。
---
<font color=red>如果文章帮助您复习巩固了知识点，三连支持一下，后续会亿点点的更新！</font>
---
<font color=orange size=4>为了帮助更多小白从零进阶 Java 工程师，从CSDN官方那边搞来了一套 《Java 工程师学习成长知识图谱》，尺寸 `870mm x 560mm`，展开后有一张办公桌大小，也可以折叠成一本书的尺寸，有兴趣的小伙伴可以了解一下，当然，不管怎样博主的文章一直都是免费的~</font>
综合得分 5.0
服务态度： 5
工作速度： 5
完成质量： 5
（0人评论）
