一、Java基础
1. final 关键字的作用：
- 修饰类时，被修饰的类无法被继承。
- 修饰方法时，被修饰的方法无法被重写。
- 修饰变量时，变量为常量，初始化后无法重新赋值。
2. static 关键字的作用：
- 修饰变量和方法时，被修饰的变量和方法是静态的，可以直接通过类来引用，而不需要创建实例。
- 修饰代码块时，是静态代码块，在类加载时自动加载，只执行一次。
- 修饰内部类时，是静态内部类，只能访问外部类的静态成员变量和方法。静态内部类可以单独创建。
- 修饰导入包中的静态方法或变量时，可以直接使用被修饰的方法和变量，而不需要加上所属的类。
3. 基本类型和引用类型的区别：
在Java编程语言中，数据类型可以分为两大类：基本数据类型（又称原始数据类型）和引用数据类型。这两者的区别主要体现在以下几个方面：
存储内容：
- 基本数据类型：直接存储实际值在栈（Stack）中，例如数值、字符或布尔值。
- 引用数据类型：存储堆（Heap）内存地址在栈中，该地址指向实际数据所在的位置。
内存分配：
- 基本数据类型：在变量声明时，系统会在栈上为其分配空间并直接存储值。
- 引用数据类型：声明引用变量时，栈上分配的空间存放的是对象的内存地址，对象本身的数据存储在堆上。
数据类型种类：
- 基本数据类型：包括整数类型（byte、short、int、long）、浮点类型（float、double）、字符类型（char）和布尔类型（boolean）。
- 引用数据类型：包括类（Class）、接口（Interface）、数组（Array）、枚举（Enum）、注解（Annotation）和字符串（String）等。
使用方式：
- 基本数据类型：可以直接使用算术运算符进行操作，比如加减乘除。
- 引用数据类型：不能直接使用算术运算符（除了==和！=比较地址），但可以调用其方法和属性。
传递方式：
- 基本数据类型：作为方法参数传递时，传递的是数据的值（值传递）。
- 引用数据类型：作为方法参数传递时，传递的是内存地址（引用传递），因此方法内部对对象的修改会影响原始对象。
默认值：
- 基本数据类型：具有默认值，例如整型的默认值是0，布尔型的默认值是false。
- 引用数据类型：默认值是null。
性能：
- 基本数据类型：由于存储在栈上，访问速度相对较快。
- 引用数据类型：存储在堆上，需要通过栈上的引用访问，速度相对较慢-
注意：在Java中，当谈到引用数据类型的参数传递时，通常指的是“引用传递”（pass by reference），但这可能会引起一些误解。
在Java中，所有参数传递都是按值传递（pass by value），包括引用数据类型。
这意味着当我们将一个引用数据类型的变量传递给方法时，实际上传递的是该变量存储的值的副本，即对象的引用。以下是这个过程的具体解释：
按值传递的本质： 传递的是值的副本。对于基本数据类型，这个值就是数据本身；对于引用数据类型，这个值是对象的引用。
误解引用传递： 有人可能会认为，因为引用数据类型的参数可以改变原始对象的状态，所以Java使用的是引用传递。
举例说明：
假设有一个对象 Person p 存储在堆上，其引用存储在栈上的变量 p 中。
当我们将 p 作为参数传递给方法时，栈上会创建一个引用的副本。
方法内部使用这个副本引用来访问和修改堆上的对象。
示例代码：
public class Person {
String name;
public Person(String name) {
this.name = name;
}
}
public void changeName(Person p) {
p.name = "New Name";
}
public static void main(String[] args) {
Person person = new Person("Original Name");
changeName(person);
// person.name 现在是 "New Name"
}
在这个例子中，changeName 方法接收了一个 Person 对象的引用。虽然看起来像是引用传递，但实际上是按值传递了这个引用的副本。这个副本指向与原始引用相同的 Person 对象，所以修改是通过引用副本进行的，但影响到了原始对象。
总结： 在Java中，引用数据类型的参数传递是按值传递的，传递的是对象引用的副本，但由于这个副本和原始引用指向同一个对象，所以看起来像是引用传递。
真正的引用传递（pass by reference）是指将变量的引用传递给方法或函数，且按引用传递传递的不是值的副本，而是实际的引用本身。
4. String是值传递还是引用传递？
在Java中，String是一种特殊的引用数据类型。对于String类型的参数传递，可以认为是按值传递的，但情况稍微有些复杂。
String的特殊性： String是不可变（immutable）的，这意味着一旦创建了一个String对象，其内容就不能改变。因此，任何试图修改String对象内容的操作都会返回一个新的String对象。
参数传递行为： 当我们将一个String对象作为参数传递给方法时，传递的是该String对象的引用的副本。然而，由于String是不可变的，所以方法内部无法直接修改原始的String对象。任何修改操作都会创建一个新的String对象，并将引用副本指向这个新对象。
示例：
public class Main {
public static void main(String[] args) {
String original = "Hello";
changeString(original);
System.out.println(original); // 输出仍然是 "Hello"
}
public static void changeString(String str) {
str = "World"; // 这不会改变原始的String对象
System.out.println(str); // 输出 "World"
}
}
在这个例子中，changeString方法试图修改传入的String参数。然而，由于String是不可变的，str = "World";实际上是在栈上创建了一个新的String引用，并将其指向一个新的String对象。原始的String对象仍然保持不变，所以main方法中的original变量打印出来的仍然是"Hello"。
总结： 虽然String的参数传递看起来像是引用传递，但由于String是不可变的，所以方法内部无法修改原始的String对象。因此，在某种意义上，String的参数传递可以被认为是按值传递。
5. 接口和抽象类的区别：
- 相同点：都是上层的抽象层，不能被实例化，都能包含抽象方法。
- 不同点：
- 抽象类可以包含非抽象方法，而接口中只能包含抽象方法。
- 抽象类可以包含普通和静态的成员变量，接口只能包含
public static final修饰的常量。 - 一个类只能继承一个抽象类，但可以实现多个接口。
- 抽象类可以包含构造方法，接口不能包含构造方法。
interface MyInterface {
void method1(); // Abstract method
}
abstract class MyAbstractClass {
abstract void method2(); // Abstract method
void method3() {
// Concrete method
}
}
6. 反射是在运行时获取类的相关信息。可以通过 Class 类来获取字段、方法等信息，从而对类进行操作。
在Java中，反射允许我们在运行时获取类的相关信息，并且可以动态地操作类的字段、方法、构造函数等。通过使用Class类，我们可以获取类的各种信息并对其进行操作。
下面是一个简单的示例来说明如何使用反射来获取类的信息：
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) throws Exception {
Class<?> myClass = Class.forName("***.example.MyClass"); // 获取类的 Class 对象
// 获取类的字段信息
Field[] fields = myClass.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName());
}
// 获取类的方法信息
Method[] methods = myClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
// 创建类的实例并调用方法
Object obj = myClass.getDeclaredConstructor().newInstance();
Method myMethod = myClass.getDeclaredMethod("myMethod");
myMethod.invoke(obj);
}
}
在这个示例中，我们使用Class.forName方法来获取指定类的Class对象，然后通过该对象可以获取类的字段和方法信息。我们还演示了如何通过反射来创建类的实例，并调用其方法。
需要注意的是，反射是一种功能强大但也复杂的机制，应该谨慎使用。过度依赖反射会导致代码可读性和性能上的问题。因此，在使用反射时需要权衡利弊，并尽量避免滥用。
7. Java 中创建实例对象的初始化顺序：
在Java中，创建实例对象的初始化顺序通常按照以下步骤进行：
- 父类的静态变量和静态代码块初始化
- 子类的静态变量和静态代码块初始化
- 父类的实例变量和代码块按照在类中的声明顺序初始化
- 父类的构造函数
- 子类的实例变量和代码块按照在类中的声明顺序初始化
- 子类的构造函数
这个顺序确保了在创建对象时，各个部分都能够按照正确的顺序得到初始化。这个过程对于理解Java对象创建和初始化非常重要，特别是在涉及到继承关系和多态性的情况下。
8. 获取反射的几种方式：
在Java中，获取反射的几种方式包括使用Class.forName()、对象.getClass()和直接通过类名.class来获取Class对象。这些方式都可以用于获取反射对象并进行动态操作。
-
Class.forName()：
使用Class.forName()方法可以根据类的全限定名（包括包名）来获取对应的Class对象。Class clazz = Class.forName("***.example.YourClass"); -
对象.getClass()：
在已经存在对象的情况下，可以通过调用对象的getClass()方法来获取对应的Class对象。YourClass obj = new YourClass(); Class clazz = obj.getClass(); -
直接通过类名.class：
可以直接通过类名后加上.class来获取对应的Class对象。Class clazz = YourClass.class;
这些方式都可以用于获取Class对象，然后通过Class对象进行反射操作，例如创建对象、调用方法、访问字段等。根据具体的情况选择合适的方式来获取反射对象，以便实现灵活的编程和动态的操作。
9. 类加载双亲委派模型：
当然可以，以下是完整的内容，包括了9.1和9.2的部分：
9什么是双亲委派模型
在双亲委派模型中，类加载器收到类加载请求时，会按照以下步骤操作：
-
检查该类是否已被加载：首先检查这个类是否已经被当前类加载器加载过，如果已经加载过，则直接返回已加载的类。
-
委派给父类加载器：如果该类尚未被加载，则当前类加载器会将请求委派给其父类加载器去处理。这一过程会一直上溯到启动类加载器（Bootstrap Class Loader）。
-
尝试加载：只有当父类加载器无法完成这个类的加载请求时（例如，该类不在父类加载器的搜索路径中），当前类加载器才会尝试自己加载这个类。
为什么叫双亲委派模型
这个模型被称为“双亲委派”是因为每个类加载器都有一个“父”类加载器，它首先将加载请求委托给这个“父”加载器。这里的“双亲”并不是指生物学上的双亲，而是指在类加载器层次结构中的“父辈”。
双亲委派模型的好处
双亲委派模型有以下几个好处：
- 避免类的重复加载：通过委派给父类加载器，可以避免同一个类被不同的类加载器多次加载，确保每个类在JVM中只存在一个副本。
- 保证Java核心API不被篡改：由于Bootstrap Class Loader是位于委派链的最顶端，负责加载Java的核心类库，因此可以确保这些核心类库不会被自定义的类加载器加载，从而保护了Java核心API的安全性和稳定性。
如何打破双亲委派模型
在某些特殊情况下，可能需要打破双亲委派模型。可以通过以下方式实现：
- 自定义类加载器：通过定义自己的类加载器并重写其loadClass方法，可以改变委派逻辑，实现自定义的类加载行为。
- 场景举例：例如，在Java EE容器或者某些Web服务器（如Tomcat）中，由于需要实现容器的隔离性或者热替换等特性，会实现自己的类加载器，并不完全遵循双亲委派模型。
综上所述，双亲委派模型是Java类加载机制中的一个重要概念，它通过委派的方式提高了类加载的效率和安全性，但在特定场景下，也可以根据需要进行适当的打破和调整。
public class ClassLoadingExample {
public static void main(String[] args) {
ClassLoadingExample example = new ClassLoadingExample();
ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("Application ClassLoader: " + appClassLoader);
System.out.println("Extension ClassLoader: " + appClassLoader.getParent());
System.out.println("Bootstrap ClassLoader: " + appClassLoader.getParent().getParent());
}
}
10. 在重写 equals 方法时通常需要重写 hashCode 方法，以确保相等的对象具有相同的 hashCode 值，避免在集合类中可能出现的问题。
在Java中，如果一个类重写了equals方法以改变两个对象相等的定义，通常也需要重写hashCode方法。以下是需要同时重写这两个方法的原因：
10.1 equals和hashCode方法的关系
在Java中，equals和hashCode方法之间有一个重要的契约，这个契约在java.lang.Object类的文档中有详细的描述：
- 如果两个对象根据equals(Object)方法返回的结果是相等的，那么调用这两个对象各自的hashCode()方法必须返回相同的整数结果。
- 如果两个对象根据equals(Object)方法返回的结果是不相等的，那么调用这两个对象各自的hashCode()方法通常（不是必须）应该返回不同的整数结果。
10.2 为什么需要重写hashCode
- 一致性：当对象的状态没有改变时，多次调用同一个对象的hashCode()方法应该返回相同的值。
- 相等对象必须有相同的hashCode：如果两个对象相等（即equals方法返回true），它们必须有相同的hashCode值，这是为了保证在使用哈希表（如HashSet、HashMap等）时，这两个对象能够被存储在同一个桶（bucket）中。
- 不相等对象应该有不同的hashCode：虽然不是必须的，但如果两个对象不相等，它们有不同的hashCode值可以提高哈希表的性能，因为这样可以减少哈希冲突的可能性。
10.3 不遵守契约的问题
如果不遵守这个契约，在集合类（如HashSet、HashMap等）中可能会出现以下问题：
- 如果两个相等的对象具有不同的hashCode值，那么在哈希表中它们可能会被存储在不同的桶中，这将导致equals方法不会被调用，从而无法正确处理这两个对象（例如，无法删除其中一个对象）。
- 如果多个不相等的对象具有相同的hashCode值，那么它们都会被映射到同一个桶中，这将增加哈希表的冲突率，导致性能下降。
10.4 如何正确重写hashCode
为了遵守上述契约，重写hashCode方法时，以下是一些通用的指导原则：
- 确保相同的对象总是返回相同的hashCode值。
- 确保如果两个对象根据equals方法相等，它们也必须有相同的hashCode值。
- 尽量使不相等的对象的hashCode值不同，以减少哈希冲突。
- 通常，hashCode方法会基于对象中用于确定相等性的所有字段来计算哈希值，并且计算方式应该尽可能简单和高效。很多IDE都提供了自动生成hashCode和equals方法的功能，这通常是一个安全且高效的方式。
public class Person {
private String name;
private int age;
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Person person = (Person) obj;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
11. 面向对象的特征：
- 封装：将对象的属性和行为封装在一起，隐藏内部细节，提供对外的接口。
- 继承：允许子类继承父类的属性和方法，实现代码复用。
- 多态：同一方法在不同对象上表现出不同的行为。
当然可以，下面是带有英文缩写的设计原则：
1. 抽象
- 过程抽象：将复杂的操作或行为抽象为一个简单的函数或方法调用。
- 数据抽象：定义数据类型和可以对这些类型执行的操作，而无需关心数据的具体表示。
2. 封装
- 封装（Encapsulation）：隐藏对象的内部细节，仅对外暴露需要公开的接口。这有助于保护对象的状态不被外部干扰和不恰当的使用。
3. 继承
- 继承（Inheritance）：允许某个类（子类）继承另一个类（父类）的属性和方法，实现代码重用并添加新功能。
4. 多态
- 多态（Polymorphism）：允许不同类的对象对同一消息做出响应，实现同一操作通过不同对象执行不同行为。
扩展的特征和设计原则
- 单一职责原则（SRP - Single Responsibility Principle）：一个类应该只有一个改变的理由。
- 开放封闭原则（OCP - Open/Closed Principle）：软件实体应该对扩展开放，对修改封闭。
- 里氏替换原则（LSP - Liskov Substitution Principle）：子类必须能够替换其父类在程序中的任何位置。
- 合成/聚合原则（C/A - ***position/Aggregation Principle）：优先使用对象组合，而不是类继承。
- 迪米特法则（LoD - Law of Demeter）：一个对象应当对其他对象有尽可能少的了解。
12. StringBuffer 和 StringBuilder 的区别：
-
StringBuffer是线程安全的，使用synchronized关键字来保证线程安全，效率较低。 -
StringBuilder是非线程安全的，效率较高。
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString());
}
}
13. 浅拷贝和深拷贝：
- 浅拷贝：复制对象时只复制对象本身和其内部基本类型属性的值，而不复制引用类型属性指向的对象。
- 深拷贝：复制对象时会递归地复制所有引用类型属性指向的对象，使得新对象和原对象完全独立。
public class DeepCopyExample {
public static void main(String[] args) {
List<String> list1 = new ArrayList<>();
list1.add("item1");
list1.add("item2");
// Shallow copy
List<String> list2 = new ArrayList<>(list1);
list2.add("item3");
// Deep copy
List<String> list3 = new ArrayList<>(list1.size());
for (String item : list1) {
list3.add(new String(item));
}
list3.add("item4");
System.out.println("List1: " + list1);
System.out.println("List2 (Shallow Copy): " + list2);
System.out.println("List3 (Deep Copy): " + list3);
}
}
