Java面试/Java必会题/必刷题(1)

灰太狼 2022-11-11 13:10 198阅读 0赞

## 1、JDK、JRE、JVM三者之间的关系？ ##

** JDK**：**J**AVA** D**evelopment**K**it（它是**Java开发运行环境**，在程序员的电脑上当然必要安装JDK) 不仅提供了Java程序运行所需的JRE，**还提供**了一系列的**编译，运行等工具**，如**javac.exe，jar.exe**等。

** JRE：**  **J**AVA Runtime **E**nvironment（它是**Java运行环境**，如果**你不需要开发**，只需要运行Java程序【**不是绝对的**，比如使用**JSP部署Web应用程序**还是要JDK的】，那么你可以安装JRE）**包含了****java虚拟机****，****java基础类库。**

**JVM**：**J**AVA **V**irtual **M**achine(**JAVA虚拟机**)是**运行Java字节码的虚拟机**。**字节码**和**不同系统的JVM**是实现Java语言”**一次编译，到处运行**"的关键。

**三者的包含关系如下图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70][]

**JDK** **=** **JRE ****+****开发工具集**

**JRE** **=****JVM** **+** **JAVA的核心类库**

## 2、面向对象和⾯向过程的区别 ##

**面向对象**：面向对象**易维护**、**易复用**、**易扩展**。因为面向对象有**封装**、**继承**、**多态性**，但是**面向对象性能比面向过程低**。

**面向过程**：**面向过程性能比面向对象高**，**类需要实例化**，**开辟空间，耗资源**。但是面向过程**不易维护、易复用、易扩展**。

## 3、Java和C++的区别 ##

*  都是**面向对象的语言**，都**支持封装**、**继承**和**多态**
 *  **Java不支持指针访问内存**，**程序更安全**。
 *  java是**单继承**（接口可以多继承），C++支持**多继承**
 *  Java有**自动内存管理机制**，不需要程序猿手动释放内存
 *  C语言中的**字符串最后有一个额外的 '\\0'** **来表示结束**，Java语言没有结束符。

## 4、对Java的加载与执行的理解 ##

**问题拆解：Java程序非常重要的哪两个阶段？**

**编译阶段**和**运行阶段**。

**编译期间**：

Java程序员**直接编写的Java代码**（**源程序**）是无法执行，**无法被JVM识别的**。必须得经历一个编译：将这个 "**普通文本**" 转为 "**字节码**" （**JVM能识别的"字节码"** ）

![20210506225112464.png][]

**普通文本****转为****字节码**的过程是**编译**。xxx.java源代码**符合语法规则**就会**编译通过**，形成**xxx.class文件**

**注意**：**字节码不是二进制文件**，如果是二进制文件，那还要JVM干嘛。

**运行期间**：

**JRE起作用**，**JVM**将.**class字节码文件装载进去**，对字节码进行解释（**解释器逐行执行**），**转为二进制**。后面**JVM**将生成的**二进制码**交给**OS操作系统执行**二进制码，操作系统就会执行二进制码和硬件进行交互。

**在windows上可以运行，其他系统也可以运行**：如果是在linux上运行，只要把生成的**.class文件拷贝**过去。在这个过程（**转二进制到与硬件交互**），没有**.java文件**任何事，即使现在删除也没关系（**最好不要，你还会修改代码的呢**），对字节码没有影响。

![20210506231115953.png][]

在这使用CMD编写代码过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 1][]

**javac** 命令**负责编译**（JDK的bin目录下有javac.exe），**java** 命令**负责运行 **(JDK的bin目录下有java.exe)

## 5、Java变量分为哪几类 ##

在Java中所有的变量分为：**成员变量** 和 **局部变量**

先了解它们的区别：**成员变量**是指这个**类**的变量，**局部变量**是类中的**方法内**定义的变量

成员变量包括：**实例变量**  和 **类变量  **

**实例变量**是没有static修改的变量，**类变量**是指以static修饰的。

### **实例变量 和 类变量的区别：** ###

1）**访问**：实例变量是通过定义**类的对象**访问，类变量可以通过类或者**类的对象**访问。

2）**生命周期**：实例变量与**类的对象生命周期**共存亡，类变量与**类**共存亡。

3）**位置**：实例变量存放在**堆**中，类变量存放在**方法区**。

局部变量包括：**形参** 和 **方法局部变量**（在方法内定义）**存放位置**：**栈中**。

### ** 局部变量与成员变量的区别？** ###

**1、定义位置不同：**  
    局部变量：在**方法的内部**  
    成员变量：在方法的外面，直接**写在类当**中  
**2、作用域不同：**  
    局部变量：只有在**方法中**才能使用，出了方法就不能再用了  
    成员变量：**整个类**全部可以用  
**3、默认值不一样**  
     局部变量：**没有默认值**，如果使用必须手动进行赋值  
     成员变量：如果**没有赋值会有一个起始值**，规则和数组一样

## 6、&& 与 & 的区别是？|| 和 | 的区别是？ ##

首先这个两者&&和&**运算结果**没什么区别，**完全相同**，只不过 **&&** 会发生"**短路**"**的现象**：比如：**Flag1 && Flag2**，当Flag1为false是Flag2就不会判断。

**|| 和 |也存在上述问题**：如果第一个操作数是true，||运算符就返回true，无需考虑第二个操作数的值。

但&和|却不是这样，它们**总是要计算两个操作数**。性能效率就不如上面的两个。

**重要区别简洁描述**：**条件布尔运算符性能比较好**。它**检查第一个操作数的值，再根据该操作数的值进行操作，可能根本就不处理第二个操作**数。

## 7、++i和i++的小问题 ##

\++无论出现在**变量****前还是后**，只要**++运算结束**，**变量一定会自加1**.

int i = 10;
    i++;
    System.out.println(i); // 11
    
    int k = 10;
    ++k;
    System.out.println(k); // 11

**i++****：**是**先****使用变量的值，****在执行++的操作**，**++i****：**是**先****执行++操作**，**在使用变量的值**。

解开以上题目的**窍门是什么**？**拆分代码**过程：

// ++  在变量的后面 如 i++
    int i = 10;
    int a = i++; // 拆分代码 int a = i; i= i++;
    System.out.println(i); // 11
    System.out.println(a); // 10
    
    // ++ 在变量前面 ++i
    int b = 10;
    int c = ++b; // 拆分代码 b = b++; int c = b;
    System.out.println(b); // 11
    System.out.println(c); // 11

## 8、基本数据类型的运算问题 ##

首先Java的数值有**默认的类型**的

**整数** ：默认为**int类型**，比如 4 + 1;返回的类型是int类型

**带有小数**：默认为**double类型**，比如 1.2 + 1.2;返回的类型是double类型

**理解基本数据类型运算关键**："**低级别**"数据类型 和 "**高级别**"数据类型**运算**，**得出的结果会自动转向"高级别"数据类型**。

**byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算。**

多说也记不住，先看看案例：

//案例1
    char a = 97;
    char b = 'B';
    b = a + 1; //编译不通过的，需要强转；a + 1 这里的"高级别"类型是int，转为int结果，不可以赋值给char的
    
    // 案例2
    byte b1 =1;
    byte b2 =2;
    b1 =b1 + b2;//编译不通过，需要强转为int类型，byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算
    b2 +=b1;//编译通过，这个等同于 b2 = (byte)(b2+b1)
    
    // 案例3
    float f1 = 1.2; //不可以通过，因为1.2在Java中默认是double类型
    float f2 = 1.2f;//通过
    float f3 = 1.2f;//通过
    f2 = 1.2+f3;   //不可以通过，需要强转为double类型，1.2为double类型
    f3=1.2+1.4;   // 不可以通过编译，1.2+1.4都是double类型相加，需要强转

**总结一下**大致规则：

1）**第一条**：八种基本数据类型中，除 boolean 类型不能转换，剩下**七种类型之间都可以进行转换**。

2）**第二条**：如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给byte char 类,short,型的变量；

3）**第三条**：**小容量向大容量转换称为自动类型转换**，容量从**小到大的排序**为：byte < short(char) < int < long < float < double，其中 short和 char 都占用两个字节，但是**char 可以表示更大的正整数**。

4）**第四条**：大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；

5）**第五条**：**byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算。**

6）**第六条**：**多种数据类型混合运算**，各自**先转换成容量最大**的那一种**再做运算**；

## 9、⾃动装箱与拆箱 ##

**装箱**：将**基本类型**用它们**对应的引用类型包装**起来。

**拆箱**：将**包装类型****转换**为**基本类型**。

<table> 
 <tbody> 
 <tr> 
 <td style="text-align:center;">基本数据类型</td> 
 <td style="text-align:center;">包装类</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">byte</td> 
 <td style="text-align:center;">Byte</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">short</td> 
 <td style="text-align:center;">Short</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">int</td> 
 <td style="text-align:center;">Integer</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">long</td> 
 <td style="text-align:center;">Long</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">float</td> 
 <td style="text-align:center;">Float</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">double</td> 
 <td style="text-align:center;">Double</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">boolean</td> 
 <td style="text-align:center;">Boolean</td> 
 </tr> 
 <tr> 
 <td style="text-align:center;">char</td> 
 <td style="text-align:center;">Character</td> 
 </tr> 
 </tbody> 
</table>

在老版本的装箱：`Integer i = ``new` `Integer(``10``);后面只需要 Integer i =5;`

看一下简单代码：

public class Main {
        public static void main(String[] args) {
            Integer i =1;//装箱，1是int类型
            int n = i; // i是Integer类赋值给int
        }
    }

** 装箱过程的debug**：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 2][]

**拆箱过程的bebug**：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 3][]

得知**自动调用**静态方法**Integer.valueof(int)装箱**，在**拆箱**是**自动调用****Integer.intValue**方法。不用使用**debug模式**查看调用方法情况也可以**使用反编译**。

**装箱过程**调用包装器的**valueof方法**实现的，**拆箱过程**是调用包装器的**xxxValue方法**（**包装类转基本类型：调用xxxValue()方法**）

**面试问题**：

public class Main {
        public static void main(String[] args) {
            Integer i1 =1;// 底层是去方法去缓存池中找创建好的对象
            Integer i2 =1;// 底层是去方法去缓存池中找创建好的对象
            Integer i3 =300;// 底层还是 Integer i3 = new Integer(300); i3是引用，保存内存地址执行对象 
            Integer i4 =300;// 底层还是 Integer i4 = new Integer(300); i4是引用，保存内存地址执行对象
            System.out.println(i1==i2);//true
            System.out.println(i3==i4);//false
        }
    }

Java中为了**提高程序的执行效率**，将byte范围的\[-128,127\]之间**所有的包装对象提前创建好**，放到方法区的"缓存池"中**，目的是** ：只要**在这个区间**的数据不需要再new。直接从缓存池中取出。

**i1**和**i2**变量保存对象的地址是一样，输出true。**JVM图如下**：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 4][]

**查看源代码分析**如下：下面这段代码是**Integer的valueOf方法**的**具体实现**

@HotSpotIntrinsicCandidate
 public static Integer valueOf(int i) {
 if (i >= IntegerCache.low && i <= IntegerCache.high)
 return IntegerCache.cache[i + (-IntegerCache.low)];
 return new Integer(i);
 }

**IntegerCache类**的实现为：

private static class IntegerCache {
 static final int low = -128;
 static final int high;
 static final Integer[] cache;
 static Integer[] archivedCache;
 
 static {
 // high value may be configured by property
 int h = 127;
 String integerCacheHighPropValue =
 VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
 if (integerCacheHighPropValue != null) {
 try {
 h = Math.max(parseInt(integerCacheHighPropValue), 127);
 // Maximum array size is Integer.MAX_VALUE
 h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
 } catch( NumberFormatException nfe) {
 // If the property cannot be parsed into an int, ignore it.
 }
 }
 high = h;
 
 // Load IntegerCache.archivedCache from archive, if possible
 VM.initializeFromArchive(IntegerCache.class);
 int size = (high - low) + 1;
 
 // Use the archived cache if it exists and is large enough
 if (archivedCache == null || size > archivedCache.length) {
 Integer[] c = new Integer[size];
 int j = low;
 for(int i = 0; i < c.length; i++) {
 c[i] = new Integer(j++);
 }
 archivedCache = c;
 }
 cache = archivedCache;
 // range [-128, 127] must be interned (JLS7 5.1.7)
 assert IntegerCache.high >= 127;
 }

当Integer i1=1； **调用valueOf(1)**，**判断i是否在\[-128,127\]之间**，如果在这范围，去**加载内部类IntegerCache**，在**类加载****同时****执行static代码块**，这时就**初始化缓存池**，**创建256个对象**。返回**指向缓存池已经存在的对象引用**；不在范围中就创建一个新对象（**返回**）

Integer i2=1；也是和上面一样操作，这时**它们会指向同一个对象的地址**。

**触发自动拆箱、自动装箱**：（**使用debug模式可以清楚看到过程**）

**自动装箱**：

1）**插入基本数据类型到集合中**(插入对象)

2）Integer i1 =1

3）**基本类型**与**包装类**比较**equals();**变量转为包装类

**自动拆箱**：

1）**包装类之间**进行 +-\*/等运算，**拆箱为基本类型**

2）**包装类**和**基本类型**执行==操作。

## 10、== 与 equals()重要 ##

**==**：可以使用在**基本类型变量**和**引用类型变量**，它是一个**运算符**。

如果比较的是**基本类型变量**，比较的是**两个变量保存的数据值是否相等**（**不一定要相同类型**）

如果比较的是**引用类型变量**，比较的是**两个变量****地址值****是否相等**（**即引用变量是否指向同一个对象实体**）

**案例代码操练**：

public class Main1 {
        public static void main(String[] args) {
            A a1 = new A("A",20);
            A a2 = new A("A",20);
            double d = 5.0;
            int i = 5;
            System.out.println(d==i);// true
            System.out.println(a1==a2);//false,地址值不一样，保存的内容相同的
        }
    }

是不是有疑问？为什么int类型的和double类型比较会相等，其实又**回到上面的第8点**，运算符操作前先把类**型统一转为"高级别"类型**，都变成double类型，在进行比较值是否相等。

**equals()**：它属于**java.lang.Object类型的方法**，作⽤也是**判断两个对象是否相等**。一般分为两种情况：

*  **情况一**：类**没有重写equals（）方法**（**覆盖Object类的**），则通过equals()比较，**等价于"=="**
 *  **情况二**：类重写了equals（）方法，一般重写equals（）方法**比较对象的内容（****类中相应的属性都相等否****）**是否相等；内容相等就返回true。

public class test {
        public static void main(String[] args) {
            String a = new String("ab"); // a 为⼀个引⽤
            String b = new String("ab"); // b为另⼀个引⽤,对象的内容⼀样
            String aa = "ab"; // 放在常量池中
            String bb = "ab"; // 从常量池中查找
            if (aa == bb) // true
            System.out.println("aa==bb");
            if (a == b) // false，⾮同⼀对象
            System.out.println("a==b");
            if (a.equals(b)) // true
                System.out.println("a equals b");
            if (42 == 42.0) { // true
                System.out.println("true");
            }
        }
    }

上面的String类中**重写了equals（）方法**，不是比较两个引用对象的地址值，而是**比较两个对象的"实体内容"是否相同**。其实还有像**File**、**Date**、**包装类**等都**重写了equals（）方法**，**比较**的都变成了**实体内容**。通常情况下，我们**自定义的类**如果**使用equals（）方法也需要重写equals（）方法**，这样也就**比较对象的属性值是否都相等**。

说了这么多，还是看看**Object类中的equals（）**方法原型：

public boolean equals(Object obj) {
        return (this == obj);
    }

**这个****Object的equals（）和==作用相同的，比较对象的地址值。**

## 11 、hashCode 与 equals（重要） ##

###    hashCode()介绍 ###

hashCode（）的作用是**获取哈希码**（**散列码**）返回一个int类型。这个**哈希码的作用**是**确定该对象在哈希表中的索引位置**。

###    hashCode与equals之间的区别 ###

*  **hashCode**如果**相等**的情况下，**对象的值不一定相等**
 *  但是**equals比较对象的内容相同**，那么**hashCode一定相等**。

###   如果重写了equals（）方法后，一定要重写hashCode（）方法为什么 ###

**我们要遵循**：

hashCoed相等的情况下，对象的值不一定相等

但是**equals比较对象的内容相同**，那么**hashCode一定相等**，所有**重写了equals（）方法**，**需要重写hashCode保证原则不变**。**不然重写了equals（）方法不重写hashCode方法**，**两个对象内容相同**，但是hashCode不同。

## 12、在Java中定义一个不干事且没有参数的构造方法的作用 ##

**构造方法**的作用是为**堆区中的对象的属性初始化**。

Java程序在执行**子类的构造器方法**之前，如果没有**使用super（）**调用父类的**特定的构造方法**，则会默认（**不写super（）也是默认写了**）**调用父类中的无参构造方法**，这时**父类**中**没有无参构造方法**，**子类**的**所有构造方法**又没有调用**super（）**来**调用父类的其他有参构造方法**。子类编译时会报错。除非**父类加上无参构造方法**或者**使用super调用其他有参构造方法（一般使用在子类的有参构造方法中且必须出现在首行）**。

既然体到super关键字，就顺便提一下：**super的使用**：子类重写了父类的方法后，在**子类调用父类的方法**必须加上**super.方法**，表明调用父类的方法。**不加上super关键字**，**默认是在子类中找，没找到再去父类中找**。

## 13、数组的初始化方式 ##

**第一种**：**静态初始化**：创建和赋值同时进行

int [] a  = new int[]{1,2,3,4,5}
    //也或者
    int str []={1,2,3,4};

第二种：动态初始化：数组定义与数组元素赋值分开进行

int a [] = new int[4];
    a[0]=1;
    a[1]=2;
    a[2]=3;
    a[3]=4;
    //最常见错误方式
    int bb [] = new int[2]{1,2};//错误❌

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 5][] ###

### 未完待续...... ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70]: /images/20221022/bdf7f7151afd4bf494de8f5d8be45dae.png
[20210506225112464.png]: /images/20221022/b33cfcaa92b4411b8722b3773c09230f.png
[20210506231115953.png]: /images/20221022/5df79fbc4bb74b00b2856c2d28a9f9b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021050623234471.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210507215717883.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2021050721573517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210507222434898.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210508172400987.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcyNTUxNw==,size_16,color_FFFFFF,t_70