--- # dir: # text: Java全栈面试 # icon: laptop-code # collapsible: true # expanded: true # link: true # index: true title: Java全栈面试 index: true # icon: laptop-code # sidebar: true # toc: true # editLink: false --- ## 1 Java基础 > Java基础部分，包括语法基础，泛型，注解，异常，反射和其它（如SPI机制等）。 ### 1.1 语法基础 #### 面向对象特性？ - **封装** 利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。优点: - 减少耦合: 可以独立地开发、测试、优化、使用、理解和修改 - 减轻维护的负担: 可以更容易被程序员理解，并且在调试的时候可以不影响其他模块 - 有效地调节性能: 可以通过剖析确定哪些模块影响了系统的性能 - 提高软件的可重用性 - 降低了构建大型系统的风险: 即使整个系统不可用，但是这些独立的模块却有可能是可用的以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。 ```java public class Person { private String name; private int gender; private int age; public String getName() { return name; } public String getGender() { return gender == 0 ? "man" : "woman"; } public void work() { if (18 <= age && age <= 50) { System.out.println(name + " is working very hard!"); } else { System.out.println(name + " can't work any more!"); } } } ``` - **继承** 继承实现了 **IS-A** 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。 Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 **向上转型** 。 ```java Animal animal = new Cat(); ``` - **多态** 多态分为编译时多态和运行时多态: - 编译时多态主要指方法的重载 - 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定运行时多态有三个条件: - 继承 - 覆盖(重写) - 向上转型下面的代码中，乐器类(Instrument)有两个子类: Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。 ```java public class Instrument { public void play() { System.out.println("Instrument is playing..."); } } public class Wind extends Instrument { public void play() { System.out.println("Wind is playing..."); } } public class Percussion extends Instrument { public void play() { System.out.println("Percussion is playing..."); } } public class Music { public static void main(String[] args) { List instruments = new ArrayList<>(); instruments.add(new Wind()); instruments.add(new Percussion()); for(Instrument instrument : instruments) { instrument.play(); } } } ``` #### a = a + b 与 a += b 的区别 += 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两个整型相加，如 byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。 ```java byte a = 127; byte b = 127; b = a + b; // error : cannot convert from int to byte b += a; // ok ``` (因为 a+b 操作会将 a、b 提升为 int 类型，所以将 int 类型赋值给 byte 就会编译出错) #### 3*0.1 == 0.3 将会返回什么? true 还是 false? false，因为有些浮点数不能完全精确的表示出来。 #### 能在 Switch 中使用 String 吗? 从 Java 7 开始，我们可以在 switch case 中使用字符串，但这仅仅是一个语法糖。内部实现在 switch 中使用字符串的 hash code。 #### 对equals()和hashCode()的理解? - **为什么在重写 equals 方法的时候需要重写 hashCode 方法**? 因为有强制的规范指定需要同时重写 hashcode 与 equals 是方法，许多容器类，如 HashMap、HashSet 都依赖于 hashcode 与 equals 的规定。 - **有没有可能两个不相等的对象有相同的 hashcode**? 有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。相等 hashcode 值的规定只是说如果两个对象相等，必须有相同的hashcode 值，但是没有关于不相等对象的任何规定。 - **两个相同的对象会有不同的 hash code 吗**? 不能，根据 hash code 的规定，这是不可能的。 #### final、finalize 和 finally 的不同之处? final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。 Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的，但是什么时候调用 finalize 没有保证。 finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。 #### String、StringBuffer与StringBuilder的区别？第一点: 可变和适用范围。String对象是不可变的，而StringBuffer和StringBuilder是可变字符序列。每次对String的操作相当于生成一个新的String对象，而对StringBuffer和StringBuilder的操作是对对象本身的操作，而不会生成新的对象，所以对于频繁改变内容的字符串避免使用String，因为频繁的生成对象将会对系统性能产生影响。第二点: 线程安全。String由于有final修饰，是immutable的，安全性是简单而纯粹的。StringBuilder和StringBuffer的区别在于StringBuilder不保证同步，也就是说如果需要线程安全需要使用StringBuffer，不需要同步的StringBuilder效率更高。 #### 接口与抽象类的区别？ - 一个子类只能继承一个抽象类, 但能实现多个接口 - 抽象类可以有构造方法, 接口没有构造方法 - 抽象类可以有普通成员变量, 接口没有普通成员变量 - 抽象类和接口都可有静态成员变量, 抽象类中静态成员变量访问类型任意，接口只能public static final(默认) - 抽象类可以没有抽象方法, 抽象类可以有普通方法；接口在JDK8之前都是抽象方法，在JDK8可以有default方法，在JDK9中允许有私有普通方法 - 抽象类可以有静态方法；接口在JDK8之前不能有静态方法，在JDK8中可以有静态方法，且只能被接口类直接调用（不能被实现类的对象调用） - 抽象类中的方法可以是public、protected; 接口方法在JDK8之前只有public abstract，在JDK8可以有default方法，在JDK9中允许有private方法 #### this() & super()在构造方法中的区别？ - 调用super()必须写在子类构造方法的第一行, 否则编译不通过 - super从子类调用父类构造, this在同一类中调用其他构造均需要放在第一行 - 尽管可以用this调用一个构造器, 却不能调用2个 - this和super不能出现在同一个构造器中, 否则编译不通过 - this()、super()都指的对象,不可以在static环境中使用 - 本质this指向本对象的指针。super是一个关键字 #### Java移位运算符？ java中有三种移位运算符 - `<<` :左移运算符,`x << 1`,相当于x乘以2(不溢出的情况下),低位补0 - `>>` :带符号右移,`x >> 1`,相当于x除以2,正数高位补0,负数高位补1 - `>>>` :无符号右移,忽略符号位,空位都以0补齐 ### 1.2 泛型 #### 为什么需要泛型？ 1. **适用于多种数据类型执行相同的代码** ```java private static int add(int a, int b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } private static float add(float a, float b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } private static double add(double a, double b) { System.out.println(a + "+" + b + "=" + (a + b)); return a + b; } ``` 如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个add方法；通过泛型，我们可以复用为一个方法： ```java private static double add(T a, T b) { System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue())); return a.doubleValue() + b.doubleValue(); } ``` - **泛型中的类型在使用时指定，不需要强制类型转换**（**类型安全**，编译器会**检查类型**）看下这个例子： ```java List list = new ArrayList(); list.add("xxString"); list.add(100d); list.add(new Person()); ``` 我们在使用上述list中，list中的元素都是Object类型（无法约束其中的类型），所以在取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现`java.lang.ClassCastException`异常。引入泛型，它将提供类型的约束，提供编译前的检查： ```java List list = new ArrayList(); // list中只能放String, 不能放其它类型的元素 ``` #### 泛型类如何定义使用？ - 从一个简单的泛型类看起： ```java class Point{ // 此处可以随便写标识符号，T是type的简称 private T var ; // var的类型由T指定，即：由外部指定 public T getVar(){ // 返回值的类型由外部决定 return var ; } public void setVar(T var){ // 设置的类型也由外部决定 this.var = var ; } } public class GenericsDemo06{ public static void main(String args[]){ Point p = new Point() ; // 里面的var类型为String类型 p.setVar("it") ; // 设置字符串 System.out.println(p.getVar().length()) ; // 取得字符串的长度 } } ``` - 多元泛型 ```java class Notepad{ // 此处指定了两个泛型类型 private K key ; // 此变量的类型由外部决定 private V value ; // 此变量的类型由外部决定 public K getKey(){ return this.key ; } public V getValue(){ return this.value ; } public void setKey(K key){ this.key = key ; } public void setValue(V value){ this.value = value ; } } public class GenericsDemo09{ public static void main(String args[]){ Notepad t = null ; // 定义两个泛型类型的对象 t = new Notepad() ; // 里面的key为String，value为Integer t.setKey("汤姆") ; // 设置第一个内容 t.setValue(20) ; // 设置第二个内容 System.out.print("姓名；" + t.getKey()) ; // 取得信息 System.out.print("，年龄；" + t.getValue()) ; // 取得信息 } } ``` #### 泛型接口如何定义使用？ - 简单的泛型接口 ```java interface Info{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型 } class InfoImpl implements Info{ // 定义泛型接口的子类 private T var ; // 定义属性 public InfoImpl(T var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } } public class GenericsDemo24{ public static void main(String arsg[]){ Info i = null; // 声明接口对象 i = new InfoImpl("汤姆") ; // 通过子类实例化对象 System.out.println("内容：" + i.getVar()) ; } } ``` #### 泛型方法如何定义使用？泛型方法，是在调用方法的时候指明泛型的具体类型。 - 定义泛型方法语法格式 ![img](https://b2files.173114.xyz/blogimg/2025/03/4eebe47eb4f2f9d0833c0d687d44b940.png) - 调用泛型方法语法格式 ![img](https://b2files.173114.xyz/blogimg/2025/03/2e383a7c2bbbf60c5bb35c95f128edf9.png) 说明一下，定义泛型方法时，必须在返回值前边加一个``，来声明这是一个泛型方法，持有一个泛型`T`，然后才可以用泛型T作为方法的返回值。 `Class`的作用就是指明泛型的具体类型，而`Class`类型的变量c，可以用来创建泛型类的对象。为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。泛型方法要求的参数是`Class`类型，而`Class.forName()`方法的返回值也是`Class`，因此可以用`Class.forName()`作为参数。其中，`forName()`方法中的参数是何种类型，返回的`Class`就是何种类型。在本例中，`forName()`方法中传入的是User类的完整路径，因此返回的是`Class`类型的对象，因此调用泛型方法时，变量c的类型就是`Class`，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。当然，泛型方法不是仅仅可以有一个参数`Class`，可以根据需要添加其他参数。 **为什么要使用泛型方法呢**？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。 #### 泛型的上限和下限？在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。上限 ```java class Info{ // 此处泛型只能是数字类型 private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } } public class demo1{ public static void main(String args[]){ Info i1 = new Info() ; // 声明Integer的泛型对象 } } ``` 下限 ```java class Info{ private T var ; // 定义泛型变量 public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } public String toString(){ // 直接打印 return this.var.toString() ; } } public class GenericsDemo21{ public static void main(String args[]){ Info i1 = new Info() ; // 声明String的泛型对象 Info