1.请说一下对象的创建过程

Java 对象的创建是一个复杂的过程，涉及多个步骤，从类加载到对象初始化，再到内存分配和对象头设置等。以下是详细的分析及示例，帮助你更好地理解这一过程。

1.1 类加载检查

当 JVM 遇到 new 指令时，首先会检查该指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已经被加载、解析和初始化过。如果类尚未被加载，JVM 会启动类加载过程，包括加载、链接（验证、准备、解析）和初始化三个阶段。

• 加载：通过类的全限定名获取其二进制字节流，并将其转换为方法区的运行时数据结构，同时创建一个 java.lang.Class 对象作为访问入口。
• 链接：
  • 验证：确保类的二进制表示在结构上是正确的，避免非法的类文件进入 JVM。
  • 准备：为类变量分配内存并设置初始值，这些变量所使用的内存都在方法区中分配。
  • 解析：将常量池内的符号引用替换为直接引用，这一步是可选的，可以在符号引用第一次被使用时完成。
• 初始化：执行静态代码块和初始化静态域，按照源代码中从上到下的顺序依次执行。

1.2 分配内存

类加载检查通过后，JVM 将为新生对象在堆中分配内存。对象所需内存的大小在类加载完成后已经完全确定。内存分配的方式取决于 Java 堆是否规整，具体有两种方式：

• 指针碰撞（Bump the Pointer）：适用于内存绝对规整的情况，即将使用过的内存与未使用的内存严格分隔开。中间的分界点指示器是一个内存地址的指针，当有新的对象创建需要分配内存空间时，只需要移动分界点指示器即可。
• 空闲列表（Free List）：适用于内存不规整的情况，虚拟机维护一个记录可用内存区域的列表，当需要分配空间时，从列表中找到合适大小的区域分配给新生对象，并更新列表上的记录。

此外，为了保证线程安全，JVM 还提供了两种机制来处理并发情况下的内存分配：

• CAS 同步处理：采用 CAS（Compare-and-Swap）+ 失败重试的方式来保证更新操作的原子性。
• 本地线程分配缓冲（TLAB, Thread Local Allocation Buffer）：每个线程在 Java 堆中预先分配一小块内存，称为 TLAB。哪个线程要分配内存，就在哪个线程的 TLAB 上分配，只有 TLAB 用完并分配新的 TLAB 时，才需要同步锁。

1.3 初始化零值

内存分配完成后，JVM 会将分配到的内存空间（但不包括对象头）都初始化为零值。这意味着所有基本数据类型的成员变量会被设置为其类型的零值（如 int 类型初始化为 0，boolean 类型初始化为 false），而引用类型则初始化为 null。这一操作保证了对象的实例字段可以在不赋初始值的情况下直接使用。

1.4 设置对象头

接下来，JVM 需要对对象的对象头进行必要的设置。对象头包含了一些基本信息，例如对象所属的类元信息、对象的 GC 分代年龄、哈希码、锁标记等。这些信息对于对象的身份识别和垃圾回收非常重要。

1.5 执行 init 方法

以上工作完成后，从 JVM 的视角来看，一个新的对象已经产生了。但是从 Java 程序的视角来看，对象创建才刚刚开始。此时，JVM 会调用构造方法来执行程序员定义的初始化逻辑，包括成员变量的赋值、构造代码块的执行等。构造方法可以包含成员变量、构造代码块的初始化，按照声明的顺序执行，最后执行对象的构造方法，并把堆内对象的首地址赋值给引用变量。

示例代码

下面是一个简单的例子，展示了对象创建的全过程：

public class Person {
    // 静态变量
    public static String staticName = "Static Name";

    // 实例变量
    private String name;
    private int age;

    // 静态代码块
    static {
        System.out.println("Static block executed.");
    }

    // 构造代码块
    {
        System.out.println("Instance block executed.");
    }

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Constructor executed.");
    }

    public static void main(String[] args) {
        // 创建对象
        Person person = new Person("John", 30);
    }
}

在这个例子中，当我们执行 new Person(“John”, 30) 时，JVM 会按照以下顺序执行：

1. 类加载检查：检查 Person 类是否已经被加载，如果没有，则加载并初始化。
2. 分配内存：为 Person 对象在堆中分配内存。
3. 初始化零值：将 name 和 age 初始化为 null 和 0。
4. 设置对象头：设置对象头中的相关信息。
5. 执行 init 方法：

• 打印 “Static block executed.”（静态代码块只执行一次，即使创建多个对象）
• 打印 “Instance block executed.”
• 打印 “Constructor executed.”

通过这个例子，我们可以清楚地看到对象创建过程中各个步骤的具体执行情况。

总结

Java 对象的创建过程涉及到类加载、内存分配、初始化零值、设置对象头以及执行构造方法等多个步骤。每个步骤都有其特定的作用，确保对象能够正确地被创建和初始化。理解这些步骤不仅有助于编写更高效的代码，还能帮助我们更好地调试和优化程序性能。

2.new String(“abc”)到底创建了几个对象？

在 Java 中，new String(“abc”) 的执行涉及到字符串常量池和堆内存中的对象创建。具体来说，当 JVM 遇到这行代码时，会根据字符串 “abc” 是否已经在字符串常量池中存在来决定创建多少个对象。以下是详细的分析：

2.1 字符串常量池与堆内存的区别

• 字符串常量池：位于方法区（JDK 7 之前）或堆内存（JDK 7 及之后），用于存储通过双引号定义的字符串字面量。常量池中的字符串不会重复，以提高存储效率。
• 堆内存：用于存储由 new 关键字创建的对象实例。每个 new 操作都会在堆中分配新的内存空间。

2.2 new String(“abc”) 的执行过程

情况 1：”abc” 不存在于字符串常量池中

1. 检查常量池：JVM 首先会在字符串常量池中查找是否存在值为 “abc” 的字符串对象。如果不存在，则继续下一步。
2. 创建常量池对象：在字符串常量池中创建一个值为 “abc” 的字符串对象，并将其引用保存在常量池中。
3. 创建堆对象：在堆内存中创建一个新的 String 对象，该对象的内容是 “abc”，并将这个堆对象的引用赋值给变量 str。
4. 结果：此时，总共创建了两个对象：一个在字符串常量池中，另一个在堆内存中。

String str = new String(“abc”);

情况 2：”abc” 已存在于字符串常量池中

1. 检查常量池：JVM 在字符串常量池中找到已经存在的值为 “abc” 的字符串对象。
2. 创建堆对象：在堆内存中创建一个新的 String 对象，该对象的内容是 “abc”，并将这个堆对象的引用赋值给变量 str。
3. 结果：此时，只创建了一个对象，即堆内存中的 String 实例对象。字符串常量池中的 “abc” 对象并未重新创建，而是直接复用了已有的对象。

String str = new String(“abc”);

2.3 示例代码及解释

为了更好地理解 new String(“abc”) 的行为，我们可以编写一些示例代码并进行测试。

示例 1：”abc” 不存在于字符串常量池中

public class StringTest {
    public static void main(String[] args) {
        // 第一次创建 "abc"
        String str1 = new String("abc");
        // 第二次创建 "abc"
        String str2 = new String("abc");

        // 检查 str1 和 str2 是否指向同一个对象
        System.out.println(str1 == str2); // false
        // 检查 str1 和 str2 的内容是否相同
        System.out.println(str1.equals(str2)); // true

        // 检查常量池中是否存在 "abc"
        String str3 = "abc";
        System.out.println(str1 == str3); // false
        System.out.println(str1.equals(str3)); // true
    }
}

输出结果：

false true false true

解释：

• str1 和 str2 是通过 new String(“abc”) 创建的两个不同的堆对象，因此它们的引用不同（== 返回 false），但内容相同（equals() 返回 true）。
• str3 是通过直接赋值 “abc” 创建的，它指向的是字符串常量池中的 “abc” 对象，因此 str1 和 str3 的引用不同（== 返回 false），但内容相同（equals() 返回 true）。

示例 2：”abc” 已存在于字符串常量池中

public class StringTest {
    public static void main(String[] args) {
        // 先将 "abc" 放入常量池
        String str3 = "abc";

        // 使用 new String("abc") 创建对象
        String str1 = new String("abc");
        String str2 = new String("abc");

        // 检查 str1 和 str2 是否指向同一个对象
        System.out.println(str1 == str2); // false
        // 检查 str1 和 str2 的内容是否相同
        System.out.println(str1.equals(str2)); // true

        // 检查常量池中是否存在 "abc"
        System.out.println(str1 == str3); // false
        System.out.println(str1.equals(str3)); // true
    }
}

输出结果：

false true false true

解释：

• 由于 “abc” 已经存在于字符串常量池中，new String(“abc”) 只会在堆内存中创建新的 String 对象，而不会在常量池中创建新的对象。
• str1 和 str2 是两个不同的堆对象，因此它们的引用不同（== 返回 false），但内容相同（equals() 返回 true）。
• str3 仍然指向常量池中的 “abc” 对象，因此 str1 和 str3 的引用不同（== 返回 false），但内容相同（equals() 返回 true）。

2.4 intern() 方法的影响

Java 提供了 String.intern() 方法，它可以将堆中的 String 对象注册到字符串常量池中。如果常量池中已经存在相同的字符串，则返回常量池中的引用；否则，将堆中的字符串添加到常量池，并返回其引用。

示例 3：使用 intern() 方法

public class StringTest {
    public static void main(String[] args) {
        // 创建堆中的 "abc" 对象
        String str1 = new String("abc").intern();
        // 直接从常量池获取 "abc"
        String str2 = "abc";

        // 检查 str1 和 str2 是否指向同一个对象
        System.out.println(str1 == str2); // true
        // 检查 str1 和 str2 的内容是否相同
        System.out.println(str1.equals(str2)); // true
    }
}

输出结果：

true true

解释：

• new String(“abc”).intern() 将堆中的 “abc” 对象注册到字符串常量池中，并返回常量池中的引用。
• str2 直接从常量池获取 “abc”，因此 str1 和 str2 指向同一个对象（== 返回 true），并且内容相同（equals() 返回 true）。

2.5 总结

• 如果 “abc” 不存在于字符串常量池中，new String(“abc”) 会创建两个对象：一个在字符串常量池中，另一个在堆内存中。
• 如果 “abc” 已存在于字符串常量池中，new String(“abc”) 只会在堆内存中创建一个新的 String 对象，而不会在常量池中创建新的对象。
• intern() 方法 可以将堆中的 String 对象注册到字符串常量池中，从而避免重复创建相同的字符串对象。

通过上述分析，我们可以更清楚地理解 new String(“abc”) 的行为及其对内存的影响。在实际开发中，除非有特殊需求，通常建议直接使用字符串字面量（如 String str = “abc”;），而不是使用 new String(“abc”)，因为后者会导致不必要的对象创建，增加内存开销。

3.Integer 使用

在 Java 中，Integer 类作为 int 基本类型的封装类，不仅提供了对 int 类型的操作方法，还引入了享元模式的设计，以优化内存使用和提高性能。具体来说，Integer 类对 -128 到 127 之间的整数值进行了缓存。当创建 Integer 对象时，如果值在这个范围内，JVM 会直接从缓存中获取已有的对象实例，而不是每次都创建新的对象。这种机制可以显著减少内存消耗，并提升程序的运行效率。

3.1 缓存机制的工作原理

Integer 类的缓存机制是通过 IntegerCache 静态内部类实现的。IntegerCache 在类加载时被初始化，并且包含一个 Integer[] 数组，用于存储 -128 到 127 之间的 Integer 对象。默认情况下，缓存的范围是从 -128 到 127，但可以通过设置 JVM 参数 -XX:AutoBoxCacheMax= 来调整缓存的最大值。需要注意的是，缓存的下界 -128 是固定的，不能更改。

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // 初始化缓存的上界，默认为127
        int h = 127;
        String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = Integer.parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
            } catch (NumberFormatException nfe) {
                // 忽略无效的参数
            }
        }
        high = h;

        // 初始化缓存数组
        cache = new Integer[(high - low) + 1];
        int j = low;
        for (int k = 0; k < cache.length; k++) {
            cache[k] = new Integer(j++);
        }

        // 确保缓存范围至少包括 -128 到 127
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

3.2. valueOf() 方法的作用

Integer.valueOf(int i) 是 Integer 类中用于将 int 值转换为 Integer 对象的方法。与直接使用构造函数 new Integer(int) 不同，valueOf() 方法会优先检查缓存中是否存在对应的 Integer 对象。如果存在，则直接返回缓存中的对象；否则，才会创建一个新的 Integer 对象。这种方式不仅可以节省内存，还可以提高性能，因为缓存中的对象可以被多个地方共享。

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

3.3 == 和 equals() 的区别

在 Java 中，== 操作符用于比较两个对象的引用是否相同，即它们是否指向同一个内存地址。而 equals() 方法则是用于比较两个对象的内容是否相等。对于 Integer 对象来说，equals() 方法会比较两个 Integer 对象所封装的 int 值是否相等。

由于 Integer 类的缓存机制，当两个 Integer 对象的值在 -128 到 127 之间时，它们实际上指向的是同一个对象。因此，在这种情况下，使用 == 比较也会返回 true。然而，如果 Integer 对象的值超出了这个范围，== 比较的结果将是 false，因为此时每个 Integer 对象都是独立创建的，指向不同的内存地址。

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

3.4. 示例代码及解释

为了更好地理解 Integer 缓存机制的工作原理，我们可以编写一些示例代码来演示 == 和 equals() 的不同行为。

示例 1：值在缓存范围内

public class IntegerCacheExample {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;

        // 使用 == 比较
        System.out.println(a == b);  // true
        // 使用 equals() 比较
        System.out.println(a.equals(b));  // true
    }
}

输出结果：

true true

解释：

• 由于 100 在 -128 到 127 的缓存范围内，a 和 b 实际上指向的是同一个 Integer 对象。因此，== 比较返回 true。
• equals() 方法比较的是两个对象的值，显然 100 == 100，所以 equals() 也返回 true。

示例 2：值超出缓存范围

public class IntegerCacheExample {
    public static void main(String[] args) {
        Integer c = 200;
        Integer d = 200;

        // 使用 == 比较
        System.out.println(c == d);  // false
        // 使用 equals() 比较
        System.out.println(c.equals(d));  // true
    }
}

输出结果：

false true

解释：

• 由于 200 超出了 -128 到 127 的缓存范围，c 和 d 是通过 new Integer(200) 创建的两个不同的对象，因此 == 比较返回 false。
• equals() 方法比较的是两个对象的值，显然 200 == 200，所以 equals() 返回 true。

示例 3：混合使用 int 和 Integer

public class IntegerCacheExample {
    public static void main(String[] args) {
        int e = 100;
        Integer f = 100;

        // 使用 == 比较
        System.out.println(e == f);  // true
        // 使用 equals() 比较
        System.out.println(e.equals(f));  // 编译错误
    }
}

输出结果：

true 编译错误

解释：

• e 是一个基本类型 int，而 f 是一个 Integer 对象。在 == 比较时，f 会被自动拆箱（unboxing）为 int，因此 e == f 实际上是比较两个 int 值，结果为 true。
• equals() 方法只能用于对象之间的比较，int 是基本类型，没有 equals() 方法，因此会导致编译错误。如果要比较 int 和 Integer，应该先将 int 装箱为 Integer，或者使用 == 进行比较

3.5 注意事项

• 避免使用

== 比较 Integer 对象：由于 == 比较的是对象的引用，而不是它们的值，因此在比较 Integer 对象时，最好使用 equals() 方法。只有当你可以确定两个 Integer 对象的值在 -128 到 127 之间时，才可以用 == 比较，但这并不是一个好的实践，因为依赖于缓存机制可能会导致不可预见的行为。

• 处理 null 值：在实际开发中，Integer 对象可能是 null，因此在使用 equals() 方法时，应该先检查对象是否为 null，以避免 NullPointerException。可以使用 Objects.equals() 方法来简化这一过程。

import java.util.Objects;

public class IntegerCacheExample {
    public static void main(String[] args) {
        Integer x = null;
        Integer y = 100;

        // 安全地比较两个可能为 null 的 Integer 对象
        System.out.println(Objects.equals(x, y));  // false
    }
}

3.6. 总结

Integer 类的缓存机制是一个非常有用的性能优化手段，尤其适用于频繁使用的 int 值。通过缓存 -128 到 127 之间的 Integer 对象，JVM 可以避免不必要的对象创建，从而减少内存占用并提高程序的执行效率。然而，在使用 Integer 对象时，开发者应该注意 == 和 equals() 的区别，尤其是在比较对象时，推荐使用 equals() 方法来确保正确性。此外，处理 null 值时应格外小心，以避免潜在的空指针异常。

4.Integer 和 int 的区别

在 Java 中，int 和 Integer 是两种不同的整数类型，它们之间的区别主要体现在以下几个方面：基本数据类型与引用类型的差异、内存分配方式、默认值的不同、自动装箱和拆箱机制、以及 Integer 类提供的额外方法。下面将详细分析这些区别，并通过示例代码进行说明。

4.1 基本数据类型 vs 引用类型

• int是 Java 中的基本数据类型之一，用于表示32位有符号整数。它直接存储数值，属于栈上的原始类型，因此它的操作速度较快，且不需要额外的内存开销来存储对象头信息。
• Integer 是 int 的封装类（wrapper class），位于 java.lang 包中。它是引用类型，意味着 Integer 实际上是一个对象，存储的是指向该对象的引用。Integer 对象包含一个 int 类型的字段，用于存储实际的整数值。由于 Integer 是对象，它需要更多的内存空间来存储对象头信息和其他元数据。

示例：

// int 是基本数据类型，直接定义并赋值
int a = 10;

// Integer 是引用类型，可以通过 new 关键字创建对象
Integer b = new Integer(10);

// 也可以使用自动装箱机制
Integer c = 10;

4.2 内存分配方式

• int变量直接存储在栈中，占用固定的4个字节。由于它是基本类型，JVM 不需要为它分配额外的堆内存，因此它的访问速度更快，内存开销也更小。
• Integer变量存储的是指向堆中对象的引用。每次创建 Integer 对象时，JVM 都会在堆中分配内存来存储该对象的实际内容。此外，Integer 还会维护一些额外的元数据，如对象头信息，这使得 Integer 占用的内存比 int 多得多。

示例：

// int 变量直接存储在栈中
int x = 5;

// Integer 变量存储的是指向堆中对象的引用
Integer y = new Integer(5);

4.3. 默认值

• int的默认值是 0。如果你声明了一个 int 变量但没有显式赋值，Java 会自动将其初始化为 0。这是因为在栈中分配的内存会被初始化为零值。
• Integer的默认值是 null。作为引用类型，Integer 变量在声明时如果没有显式赋值，它的初始值将是 null。这意味着你不能直接对 null 的 Integer 对象进行操作，否则会导致 NullPointerException。

示例：

// int 的默认值是 0
int a;  // a 的值为 0

// Integer 的默认值是 null
Integer b;  // b 的值为 null

// 尝试对 null 的 Integer 对象进行操作会导致 NullPointerException
if (b != null) {
    System.out.println(b.intValue());
} else {
    System.out.println("b is null");
}

4.4. 自动装箱和拆箱

Java 从 JDK 1.5 开始引入了自动装箱（autoboxing）和拆箱（unboxing）机制，允许开发者在 int 和 Integer 之间自动进行转换。自动装箱是指将 int 类型的值自动转换为 Integer 对象，而自动拆箱则是将 Integer 对象自动转换为 int 类型的值。这种机制简化了代码编写，但也会带来一定的性能开销。

示例：

// 自动装箱：int 转换为 Integer
int x = 10;
Integer y = x;  // 自动装箱

// 自动拆箱：Integer 转换为 int
Integer z = 20;
int w = z;  // 自动拆箱

// 在表达式中混合使用 int 和 Integer
Integer a = 30;
int b = 40;
int sum = a + b;  // a 会被自动拆箱为 int，然后进行加法运算

需要注意的是，自动装箱和拆箱虽然方便，但在某些情况下可能会导致性能问题，尤其是在循环或频繁操作中。此外，如果 Integer 对象为 null，在自动拆箱时会抛出 NullPointerException，因此在使用自动拆箱时应确保对象不为 null。

4.5. Integer 类提供的方法和属性

作为 int 的封装类，Integer 提供了许多有用的方法和静态常量，使得整数的操作更加灵活和便捷。以下是一些常见的 Integer 类方法：

• intValue()：将 Integer 对象转换为 int 类型的值。
• toString()：将 Integer 对象转换为字符串表示形式。
• parseInt(String s)：将字符串解析为 int 类型的值。
• valueOf(int i)：将 int 值包装为 Integer 对象。这个方法会利用 Integer 缓存机制，避免不必要的对象创建。
• compareTo(Integer anotherInteger)：比较两个 Integer 对象的大小，返回 -1、0 或 1，分别表示小于、等于或大于。
• equals(Object obj)：判断两个 Integer 对象是否相等。注意，== 比较的是对象的引用，而 equals() 比较的是对象的内容。

示例：

// 使用 intValue() 方法将 Integer 转换为 int
Integer a = 100;
int b = a.intValue();

// 使用 toString() 方法将 Integer 转换为字符串
String str = a.toString();
System.out.println(str);  // 输出 "100"

// 使用 parseInt() 方法将字符串转换为 int
String numStr = "123";
int num = Integer.parseInt(numStr);
System.out.println(num);  // 输出 123

// 使用 valueOf() 方法将 int 转换为 Integer
Integer c = Integer.valueOf(200);
System.out.println(c);  // 输出 200

// 使用 compareTo() 方法比较两个 Integer 对象
Integer d = 150;
Integer e = 200;
int result = d.compareTo(e);
System.out.println(result);  // 输出 -1，因为 150 < 200

// 使用 equals() 方法比较两个 Integer 对象
Integer f = 100;
Integer g = 100;
boolean isEqual = f.equals(g);
System.out.println(isEqual);  // 输出 true

4.6. Integer 缓存机制

Integer 类内部实现了一个缓存机制，用于优化 -128 到 127 之间的整数值。当使用 Integer.valueOf(int i) 方法创建 Integer 对象时，如果 i 的值在这个范围内，JVM 会直接从缓存中返回已有的对象，而不是每次都创建新的对象。这不仅可以减少内存占用，还可以提高程序的性能。

示例：

// 使用 valueOf() 方法创建 Integer 对象
Integer a = Integer.valueOf(100);
Integer b = Integer.valueOf(100);

// 比较两个对象的引用
System.out.println(a == b);  // 输出 true，因为 a 和 b 指向同一个缓存对象

// 使用 new 关键字创建 Integer 对象
Integer c = new Integer(100);
Integer d = new Integer(100);

// 比较两个对象的引用
System.out.println(c == d);  // 输出 false，因为 c 和 d 是独立的对象

4.7. == 和 equals() 的区别

• ==操作符用于比较两个对象的引用是否相同，即它们是否指向同一个内存地址。对于 int 类型，== 比较的是两个数值是否相等。而对于 Integer 对象，== 比较的是对象的引用，而不是它们的值。因此，除非两个 Integer 对象都来自缓存，否则 == 比较的结果通常是 false。
• equals()方法用于比较两个对象的内容是否相等。对于 Integer 对象，equals() 比较的是两个对象所封装的 int 值是否相等。因此，即使两个 Integer 对象不是同一个实例，只要它们的值相同，equals() 也会返回 true。

示例：

// 使用 == 比较两个 Integer 对象
Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // 输出 true，因为 a 和 b 指向同一个缓存对象

// 使用 equals() 比较两个 Integer 对象
Integer c = 200;
Integer d = 200;
System.out.println(c == d);  // 输出 false，因为 c 和 d 是独立的对象
System.out.println(c.equals(d));  // 输出 true，因为 c 和 d 的值相同

4.8. 总结

• int 是基本数据类型，直接存储数值，适合高性能和低内存消耗的场景。它的默认值是 0，并且可以直接进行数值运算。
• Integer 是 int 的封装类，属于引用类型，提供了丰富的操作方法和属性。它的默认值是 null，并且可以通过自动装箱和拆箱机制与 int 互转。Integer 的缓存机制可以优化常用整数值的创建和使用，但需要注意 == 和 equals() 的区别，以避免潜在的错误。

在实际开发中，选择使用 int 还是 Integer 应根据具体需求来决定。如果只需要进行简单的数值运算，建议使用 int 以提高性能；如果需要使用集合类或其他只能存储对象的结构，或者需要调用 Integer 类提供的方法，则应选择 Integer。

5. 为什么要有继承

继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类或派生类）从另一个类（父类或基类）继承属性和方法。通过继承，程序员可以实现代码的重用、更好地组织代码、提高代码的可维护性和扩展性，并且能够更贴近现实世界的建模。以下是继承的主要优势及其详细分析，结合具体的示例来说明。

5.1. 避免代码重复

继承的一个重要目的是减少代码的重复。如果你有一些公共的方法或属性，可以在父类中定义它们，然后让其他类继承这个父类，从而避免在每个类中重复这些方法和属性。这种方式不仅提高了代码的简洁性，还减少了维护成本，因为只需要在一个地方修改代码即可。

示例：

假设我们有一个 Animal 类，它包含了一个所有动物都有的行为——吃东西。我们可以将这个行为定义在 Animal 类中，然后让不同的动物类型（如 Dog 和 Cat）继承这个类，而不需要在每个具体的动物类中重复定义 eat 方法。

class Animal {
    void eat() {
        System.out.println("The animal eats.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自 Animal 的方法
        dog.bark(); // Dog 类自己的方法

        Cat cat = new Cat();
        cat.eat();  // 继承自 Animal 的方法
        cat.meow(); // Cat 类自己的方法
    }
}

在这个例子中，Dog 和 Cat 类都继承了 Animal 类的 eat 方法，而不需要各自重新定义这个方法。这样不仅减少了代码量，还使得代码更加易于维护。

5.2. 代码组织

继承有助于将相关的代码组织在一起，使代码更容易理解和维护。通过将具有相同功能的代码放在一个类中，可以更好地管理和修改这些功能。例如，如果我们有多个类都涉及到某种特定的行为或属性，可以将这些共同的部分提取到一个父类中，形成一个清晰的层次结构。

示例：

假设我们正在开发一个电子商务系统，其中有许多不同类型的用户：普通用户、VIP 用户、管理员等。这些用户都有登录和注销的功能，但 VIP 用户可能还有一些额外的特权。我们可以通过创建一个 User 类来定义所有用户的共通行为，然后让 VipUser 和 AdminUser 继承这个类，分别添加各自的特有功能。

class User {
    void login() {
        System.out.println("User logged in.");
    }

    void logout() {
        System.out.println("User logged out.");
    }
}

class VipUser extends User {
    void getDiscount() {
        System.out.println("VipUser gets a discount.");
    }
}

class AdminUser extends User {
    void manageUsers() {
        System.out.println("AdminUser manages users.");
    }
}

public class Main {
    public static void main(String[] args) {
        VipUser vipUser = new VipUser();
        vipUser.login();     // 继承自 User 的方法
        vipUser.getDiscount();// VipUser 自己的方法

        AdminUser adminUser = new AdminUser();
        adminUser.login();   // 继承自 User 的方法
        adminUser.manageUsers(); // AdminUser 自己的方法
    }
}

在这个例子中，VipUser 和 AdminUser 都继承了 User 类的 login 和 logout 方法，而各自又添加了特有的功能。这种层次结构使得代码更加清晰，易于理解和维护。

5.3. 增加可重用性

继承可以显著提高代码的可重用性。你可以创建一个基类，并在其他类中重用它。这样，你可以在不同的项目中使用相同的基类，而无需从头开始编写代码。此外，继承还允许你在不改变现有代码的情况下，通过扩展子类来添加新的功能。

示例：

假设我们正在开发一个图形编辑器，其中有许多不同类型的形状：圆形、矩形、三角形等。这些形状都有绘制和移动的功能，但每种形状的具体绘制方式可能不同。我们可以通过创建一个 Shape 类来定义所有形状的共通行为，然后让 Circle、Rectangle 和 Triangle 继承这个类，分别实现各自的绘制逻辑。

abstract class Shape {
    abstract void draw();

    void move(int x, int y) {
        System.out.println("Shape moved to (" + x + ", " + y + ")");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

class Triangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a triangle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();  // 子类实现的方法
        circle.move(10, 20); // 继承自 Shape 的方法

        Shape rectangle = new Rectangle();
        rectangle.draw();  // 子类实现的方法
        rectangle.move(30, 40); // 继承自 Shape 的方法
    }
}

在这个例子中，Circle、Rectangle 和 Triangle 都继承了 Shape 类的 move 方法，而各自实现了 draw 方法。这种设计使得我们可以轻松地添加新的形状类，而无需修改现有的代码。

5.4. 实现多态

继承是多态实现的基础。通过继承，你可以在不同的类中使用相同的接口或方法名称，从而实现多态。这意味着你可以在运行时根据实际类型选择不同的行为。多态性使得代码更加灵活，能够在不改变调用方代码的情况下，动态地处理不同类型的对象。

示例：

继续上面的图形编辑器的例子，假设我们有一个方法 drawAllShapes，它接受一个 Shape 类型的数组，并依次调用每个形状的 draw 方法。由于 Circle、Rectangle 和 Triangle 都继承了 Shape，并且各自实现了 draw 方法，因此我们可以将不同类型的形状对象传递给这个方法，而不需要关心具体的类型。

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = {new Circle(), new Rectangle(), new Triangle()};
        drawAllShapes(shapes);
    }

    public static void drawAllShapes(Shape[] shapes) {
        for (Shape shape : shapes) {
            shape.draw();  // 根据实际类型调用不同的 draw 方法
        }
    }
}

在这个例子中，drawAllShapes 方法并不知道传入的 Shape 数组中具体包含哪些类型的对象，但它仍然能够正确地调用每个对象的 draw 方法。这就是多态性的强大之处，它使得代码更加通用和灵活。

5.5. 维护和扩展

继承有助于维护和扩展代码。如果你需要修改一个基类的方法或属性，你只需要在一个地方进行修改，而无需在每个子类中进行相同的修改。此外，你可以通过添加新的继承层次来扩展代码，而无需修改现有的代码。这种设计使得代码更加模块化，易于维护和扩展。

示例：

class Vehicle {
    void start() {
        System.out.println("Vehicle started.");
    }

    void stop() {
        System.out.println("Vehicle stopped.");
    }
}

class ElectricVehicle extends Vehicle {
    void charge() {
        System.out.println("ElectricVehicle is charging.");
    }
}

public class Main {
    public static void main(String[] args) {
        ElectricVehicle ev = new ElectricVehicle();
        ev.start();  // 继承自 Vehicle 的方法
        ev.charge(); // ElectricVehicle 自己的方法
        ev.stop();   // 继承自 Vehicle 的方法
    }
}

在这个例子中，ElectricVehicle 继承了 Vehicle 的所有方法，并添加了新的 charge 方法。如果将来需要为所有车辆添加新的功能，我们只需在 Vehicle 类中进行修改，所有的子类都会自动受益于这些改进。

5.6. 符合现实世界

在现实世界中，许多事物都有层次结构。例如，动物是一类生物，猫和狗都是动物的子类。通过继承，你可以更好地模拟现实世界中的关系，从而使代码更加符合实际情况。这种设计不仅使得代码更具可读性，还能帮助开发者更好地理解系统的结构和功能。

示例：

假设我们正在开发一个动物园管理系统，其中有许多不同类型的动物：哺乳动物、鸟类、爬行动物等。这些动物都有共同的特征，如进食、睡觉等，但每种动物的具体行为可能不同。我们可以通过创建一个 Animal 类来定义所有动物的共通行为，然后让 Mammal、Bird 和 Reptile 继承这个类，分别实现各自的特有功能。

class Animal {
    void eat() {
        System.out.println("The animal eats.");
    }

    void sleep() {
        System.out.println("The animal sleeps.");
    }
}

class Mammal extends Animal {
    void giveBirth() {
        System.out.println("Mammal gives birth.");
    }
}

class Bird extends Animal {
    void layEggs() {
        System.out.println("Bird lays eggs.");
    }
}

class Reptile extends Animal {
    void shedSkin() {
        System.out.println("Reptile sheds skin.");
    }
}

public class Main {
    public static void main(String[] args) {
        Mammal mammal = new Mammal();
        mammal.eat();      // 继承自 Animal 的方法
        mammal.sleep();    // 继承自 Animal 的方法
        mammal.giveBirth(); // Mammal 自己的方法

        Bird bird = new Bird();
        bird.eat();      // 继承自 Animal 的方法
        bird.sleep();    // 继承自 Animal 的方法
        bird.layEggs();  // Bird 自己的方法

        Reptile reptile = new Reptile();
        reptile.eat();      // 继承自 Animal 的方法
        reptile.sleep();    // 继承自 Animal 的方法
        reptile.shedSkin(); // Reptile 自己的方法
    }
}

在这个例子中，Mammal、Bird 和 Reptile 都继承了 Animal 类的 eat 和 sleep 方法，而各自实现了特有的行为。这种设计不仅使得代码更加符合现实世界的层次结构，还使得系统更加易于扩展和维护。

结论

继承是面向对象编程中的一种强大工具，它不仅能够帮助我们避免代码重复，还能更好地组织和管理代码，提高代码的可重用性和可维护性。通过继承，我们还可以实现多态性，使得代码更加灵活和通用。此外，继承还能够帮助我们更好地模拟现实世界中的关系，从而使代码更加直观和易于理解。然而，过度使用继承也可能导致代码结构变得复杂和难以管理，因此在实际编程中需要谨慎使用。

6.Java面向对象有哪些特征，如何应用

Java作为一种面向对象编程（OOP）语言，其核心理念是通过类和对象来模拟现实世界中的实体及其行为。面向对象编程的主要优势在于它能够提高代码的可读性、可维护性和可扩展性。Java的面向对象特性主要体现在三个核心概念上：封装、继承和多态。这三个特性不仅帮助开发者更好地组织代码，还使得程序更加灵活和易于扩展。

6.1. 封装（Encapsulation）

封装是指将数据（属性）和操作这些数据的方法捆绑在一起，并隐藏类的内部实现细节，只暴露必要的接口给外部使用。通过封装，类的内部状态可以得到保护，防止外部直接访问或修改，从而提高了代码的安全性和稳定性。封装的另一个重要特点是“高内聚，低耦合”，即类的内部逻辑紧密相关，而类与类之间的依赖关系尽可能减少。

封装的应用：

• 属性封装：在Java中，通常使用private修饰符来限制类的属性访问，确保这些属性只能在类的内部进行操作。为了允许外部访问这些属性，通常会提供getter和setter方法。这样不仅可以控制对属性的访问，还可以在setter方法中加入验证逻辑，确保数据的有效性。

public class Person {
    private String name;
    private int age;

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age with validation
    public void setAge(int age) {
        if (age >= 0 && age <= 130) {
            this.age = age;
        } else {
            System.out.println("Invalid age!");
        }
    }
}

在这个例子中，name和age属性被私有化，外部无法直接访问它们。通过getter和setter方法，我们可以安全地获取和设置这些属性的值。特别是setAge方法中加入了年龄的验证逻辑，确保了数据的合理性。

• 方法封装：封装不仅仅是针对属性的，方法也可以被封装。通过封装，开发者可以隐藏方法的具体实现细节，用户只需调用方法即可，而不必关心其内部是如何工作的。这种方式简化了代码的使用，同时也便于后续的维护和扩展。

public class Calculator {
    // 内部实现细节对外界隐藏
    private int add(int a, int b) {
        return a + b;
    }

    // 提供一个公共接口
    public int sum(int... numbers) {
        int result = 0;
        for (int num : numbers) {
            result = add(result, num);
        }
        return result;
    }
}

在这个例子中，add方法被私有化，外部无法直接调用它。相反，用户可以通过sum方法来计算多个数的和，而不需要知道add方法的具体实现。这种设计使得代码更加简洁，同时也增强了可维护性。

6.2. 继承（Inheritance）

继承是面向对象编程中的一种机制，允许一个类（子类）从另一个类（父类）继承属性和方法。通过继承，子类可以获得父类的所有非私有成员，并可以在其基础上添加新的功能或重写已有功能。继承的本质是“特殊-一般”的关系，即子类是父类的一个特例，具有父类的所有特征，同时还可以拥有自己独特的属性和行为。

继承的应用：

• 代码复用：继承的最大优势之一是它可以避免重复代码。如果多个类之间有一些共同的属性或方法，可以将这些共性提取到一个父类中，然后让其他类继承这个父类。这样不仅减少了代码量，还使得代码更加易于维护。

// 父类 Animal
public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类 Dog 继承自 Animal
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);  // 调用父类的构造函数
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

// 子类 Cat 继承自 Animal
public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);  // 调用父类的构造函数
    }

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", 3);
        dog.eat();  // 继承自 Animal 的方法
        dog.bark(); // Dog 类自己的方法

        Cat cat = new Cat("Whiskers", 2);
        cat.eat();  // 继承自 Animal 的方法
        cat.meow(); // Cat 类自己的方法
    }
}

在这个例子中，Dog和Cat类都继承了Animal类的eat和sleep方法，而各自又实现了特有的行为（如bark和meow）。通过继承，我们避免了在每个类中重复定义相同的方法，从而使代码更加简洁和易于维护。

• 扩展功能：继承不仅允许子类继承父类的属性和方法，还可以在此基础上添加新的功能或重写已有功能。例如，子类可以重写父类的方法以提供更具体的实现，或者添加新的方法来满足特定的需求。

// 父类 Vehicle
public class Vehicle {
    public void start() {
        System.out.println("Vehicle started.");
    }

    public void stop() {
        System.out.println("Vehicle stopped.");
    }
}

// 子类 ElectricVehicle 继承自 Vehicle
public class ElectricVehicle extends Vehicle {
    @Override
    public void start() {
        System.out.println("Electric vehicle started quietly.");
    }

    public void charge() {
        System.out.println("Charging the electric vehicle.");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        ElectricVehicle ev = new ElectricVehicle();
        ev.start();  // 重写了父类的方法
        ev.charge(); // ElectricVehicle 自己的方法
        ev.stop();   // 继承自 Vehicle 的方法
    }
}

在这个例子中，ElectricVehicle类重写了Vehicle类的start方法，提供了更适合电动汽车的实现。此外，ElectricVehicle还添加了一个新的charge方法，用于充电。这种设计使得代码更加灵活，能够在不改变现有代码的情况下扩展功能。

6.3. 多态（Polymorphism）

多态是指同一个操作作用于不同的对象时，可以产生不同的执行结果。在Java中，多态性主要通过继承和方法重写来实现。多态的核心思想是：父类引用可以指向子类对象，并且在调用方法时，实际执行的是子类中重写的方法。多态使得代码更加通用和灵活，能够在不改变调用方代码的情况下，动态地处理不同类型的对象。

多态的应用：

• 编译时多态（静态多态）：编译时多态主要是指方法的重载（overloading），即在同一类中定义多个同名但参数列表不同的方法。编译器根据传入的参数类型和数量来决定调用哪个方法。虽然这种方法也被称为多态，但它并不是真正的多态性，因为它是在编译时确定的，而不是在运行时。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1, 2));    // 调用 int 版本的 add 方法
        System.out.println(calc.add(1.5, 2.5)); // 调用 double 版本的 add 方法
    }
}

在这个例子中，Calculator类中有两个add方法，分别处理整数和浮点数的加法。编译器根据传入的参数类型自动选择合适的方法。这是编译时多态的一个典型例子。

• 运行时多态（动态多态）：运行时多态是真正的多态性，它允许在运行时根据对象的实际类型来调用相应的方法。运行时多态的实现需要满足三个条件：继承、方法重写和父类引用指向子类对象。通过这种方式，即使调用的是父类的方法，实际执行的却是子类中重写的方法。

// 父类 Animal
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

// 子类 Dog 继承自 Animal
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

// 子类 Cat 继承自 Animal
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows.");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // 父类引用指向子类对象
        Animal animal2 = new Cat();  // 父类引用指向子类对象

        animal1.makeSound();  // 实际调用的是 Dog 类的 makeSound 方法
        animal2.makeSound();  // 实际调用的是 Cat 类的 makeSound 方法
    }
}

在这个例子中，animal1和animal2都是Animal类型的引用，但实际上它们分别指向Dog和Cat对象。当调用makeSound方法时，实际执行的是子类中重写的方法。这种设计使得代码更加灵活，能够在不改变调用方代码的情况下，动态地处理不同类型的对象。

• 多态的好处：
  • 可替换性：多态允许父类类型的变量可以替换为子类的对象，而无需修改调用方的代码。例如，draw方法可以接受任何形状对象（如圆形、矩形等），而无需为每种形状编写单独的代码。
  • 可扩展性：多态使得代码更具扩展性。当添加新的子类时，现有的代码无需修改，只需要确保新类遵循相同的接口即可。例如，如果我们添加一个新的动物类（如Bird），现有的makeSound方法仍然可以正常工作。
  • 灵活性：多态使得代码更加灵活，能够在运行时根据对象的实际类型选择不同的行为。这使得程序更加通用，能够处理多种不同的情况。
  • 简化性：多态简化了代码的编写和维护。通过使用父类类型的引用，我们可以编写更加通用的代码，而无需为每种具体类型编写单独的逻辑。

结论

Java的面向对象编程三大特征——封装、继承和多态，共同构成了OOP的核心思想。封装通过隐藏类的内部实现细节，保护了数据的安全性，并提高了代码的可维护性；继承通过从已有的类中派生出新的类，实现了代码的复用和扩展；多态则通过允许父类引用指向子类对象，使得代码更加灵活和通用。这三大特性相互配合，帮助开发者构建出结构清晰、易于维护且具有良好扩展性的软件系统。

在实际开发中，合理运用这些特性可以使代码更加简洁、高效，并且更容易适应未来的变化。然而，过度使用继承可能会导致代码结构变得复杂，因此在设计时应谨慎权衡，确保继承关系符合“is-a”的逻辑关系，避免不必要的复杂性。

7.重写和重载有哪些区别

方法重载（Overloading）与方法重写（Overriding）的区别

在Java中，方法重载和方法重写是实现多态性的两种不同方式。尽管它们都涉及到方法的名称相同这一特性，但它们的作用范围、实现机制以及规则有着显著的区别。下面我们将详细分析这两者的区别，并通过具体的代码示例来说明。

7.1. 编译时多态 vs 运行时多态

• 方法重载（Overloading）：实现的是编译时多态性。当多个同名方法在同一个类中存在，但它们的参数列表不同（参数类型、个数或顺序不同），这就是方法重载。编译器根据调用时传入的参数类型和数量来决定调用哪个方法。因此，重载是在编译阶段确定的。
• 方法重写（Overriding）：实现的是运行时多态性。当子类中定义了一个与父类中某个方法具有相同签名（包括方法名、参数列表和返回类型）的方法时，这就构成了方法重写。在运行时，JVM会根据对象的实际类型来决定调用哪个方法，而不是根据引用的类型。这意味着即使使用父类类型的引用指向子类对象，实际调用的仍然是子类中重写的方法。

7.2. 发生的位置

• 方法重载：发生在同一个类中。也就是说，重载的方法必须在同一类中定义，且它们的参数列表必须有所不同。重载方法可以有不同的返回类型，但这不是区分重载方法的标准。
• 方法重写：发生在子类与父类之间。子类可以通过重写父类中的方法来提供不同的实现。重写要求子类方法的签名（方法名、参数列表和返回类型）与父类方法完全一致。

7.3. 参数列表的要求

• 方法重载：参数列表必须不同。具体来说，参数的类型、个数或顺序可以不同。例如，void method(int a) 和 void method(double a) 是两个不同的重载方法，因为它们的参数类型不同。同样，void method(int a, int b) 和 void method(int a) 也是不同的重载方法，因为它们的参数个数不同。
• 方法重写：参数列表必须完全相同。子类重写的方法必须与父类被重写的方法具有相同的参数列表，包括参数的类型、个数和顺序。这是为了确保在运行时能够正确地调用子类的方法。

7.4. 返回类型的要求

• 方法重载：返回类型可以不同，但这不是区分重载方法的标准。编译器主要根据参数列表来区分不同的重载方法。因此，即使返回类型不同，只要参数列表相同，编译器仍然会认为它们是同一个方法。
• 方法重写：返回类型必须相同或为父类返回类型的子类（协变返回类型）。从Java 5开始，允许子类重写方法的返回类型是父类返回类型的子类。例如，如果父类方法返回Object，子类可以返回String，因为String是Object的子类。

7.5. 异常声明的要求

• 方法重载：可以抛出不同的异常，甚至可以不抛出异常。由于重载方法的区分标准是参数列表，因此异常声明不会影响方法的选择。
• 方法重写：不能抛出新的强制性异常（Checked Exception），或者比父类方法声明的更广泛的强制性异常。但是，子类可以抛出更少的异常，或者不抛出任何异常。对于非强制性异常（Unchecked Exception），子类可以自由地抛出或不抛出。

7.6. 访问修饰符的要求

• 方法重载：可以有不同的访问修饰符。由于重载方法的区分标准是参数列表，因此访问修饰符不会影响方法的选择。
• 方法重写：子类方法的访问修饰符不能比父类方法的访问修饰符更严格。换句话说，子类方法的访问权限必须至少与父类方法相同，或者更加宽松。例如，如果父类方法是public，子类方法也必须是public，而不能是protected或private。

7.7. 构造方法的处理

• 方法重载：构造方法可以被重载。一个类可以有多个构造方法，只要它们的参数列表不同即可。构造方法的重载使得类可以以不同的方式初始化对象。
• 方法重写：构造方法不能被重写。构造方法是特定于类的，每个类都有自己的构造方法，因此不存在继承和重写构造方法的概念。不过，子类可以调用父类的构造方法来完成初始化工作。

7.8. 静态方法的处理

• 方法重载：静态方法可以被重载。静态方法的重载遵循与实例方法相同的规则，即参数列表必须不同。
• 方法重写：静态方法不能被重写。静态方法属于类本身，而不是类的实例，因此它们不会参与多态性。如果子类中定义了与父类静态方法同名的方法，这实际上是一个新的静态方法，而不是对父类方法的重写。

示例代码

方法重载的示例

public class Calculator {
    // 重载方法1：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 重载方法2：两个浮点数相加
    public double add(double a, double b) {
        return a + b;
    }

    // 重载方法3：三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Integers: " + calc.add(1, 2));          // 调用 int 版本的 add 方法
        System.out.println("Doubles: " + calc.add(1.5, 2.5));      // 调用 double 版本的 add 方法
        System.out.println("Three integers: " + calc.add(1, 2, 3)); // 调用三个参数版本的 add 方法
    }
}

在这个例子中，Calculator类中有三个名为add的方法，但它们的参数列表不同。编译器根据传入的参数类型和数量来选择合适的方法进行调用。这是方法重载的一个典型应用。

方法重写的示例

// 父类 Animal
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

// 子类 Dog 继承自 Animal
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

// 子类 Cat 继承自 Animal
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows.");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // 父类引用指向子类对象
        Animal animal2 = new Cat();  // 父类引用指向子类对象

        animal1.makeSound();  // 实际调用的是 Dog 类的 makeSound 方法
        animal2.makeSound();  // 实际调用的是 Cat 类的 makeSound 方法
    }
}

在这个例子中，animal1和animal2都是Animal类型的引用，但实际上它们分别指向Dog和Cat对象。当调用makeSound方法时，实际执行的是子类中重写的方法。这种设计使得代码更加灵活，能够在不改变调用方代码的情况下，动态地处理不同类型的对象。

总结

• 方法重载和方法重写虽然都涉及方法名称相同的情况，但它们的应用场景和规则截然不同。重载主要用于在同一类中提供多种方法变体，而重写则用于子类中覆盖父类的方法，以提供更具体的实现。
• 重载发生在编译时，依赖于参数列表的不同；而重写发生在运行时，依赖于对象的实际类型。
• 重载对返回类型没有特殊要求，而重写要求返回类型必须相同或为父类返回类型的子类。
• 重载可以有不同的异常声明，而重写不能抛出新的强制性异常或更广泛的异常。
• 重载可以有不同的访问修饰符，而重写的访问修饰符不能比父类方法更严格。
• 构造方法可以被重载，但不能被重写；静态方法可以被重载，但不能被重写。

通过理解这些区别，开发者可以在编写代码时更好地利用这两种机制，从而构建出更加灵活、可维护的程序。