【Java基础常见辨析】重载与重写，深拷贝与浅拷贝，抽象类与普通类

文章目录

• • • [一、重载 (Overload) vs 重写 (Override)](#一、重载 (Overload) vs 重写 (Override))
    • [二、抽象类 (Abstract Class) vs 普通类 (Normal Class)](#二、抽象类 (Abstract Class) vs 普通类 (Normal Class))
    • [三、`final` 字段的作用](#三、final 字段的作用)
    • [四、深拷贝 (Deep Copy) vs 浅拷贝 (Shallow Copy)](#四、深拷贝 (Deep Copy) vs 浅拷贝 (Shallow Copy))
    • 五、实现深拷贝的三种方法
    • 六、泛型 (Generics)
    • [七、Java 创建对象的 5 种方法](#七、Java 创建对象的 5 种方法)
    • 八、获取私有对象的两种方法

一、重载 (Overload) vs 重写 (Override)

特性	重载 (Overload)	重写 (Override)
作用范围	同一个类中	父子类之间
方法签名	方法名相同，参数列表不同	方法名、参数列表、返回值完全相同
访问权限	无要求	子类方法权限 ≥ 父类方法
异常处理	无要求	子类异常范围 ≤ 父类异常

// 重载示例
class Calculator {
    int add(int a, int b) { return a + b; }          // 方法1
    double add(double a, double b) { return a + b; } // 方法2（参数类型不同）
}

// 重写示例
class Animal {
    void sound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("Bark!"); } // 重写父类方法
}

---

二、抽象类 (Abstract Class) vs 普通类 (Normal Class)

特性	抽象类	普通类
实例化	❌ 不能直接实例化	✅ 可以直接实例化
方法实现	可包含抽象方法（无实现）	所有方法必须有实现
继承关系	只能作为基类被继承	可继承/被继承
构造器	可以有构造器（用于子类初始化）	必须有构造器

// 抽象类示例
abstract class Shape {
    abstract void draw();          // 抽象方法（无实现）
    void rotate() { /* 具体实现 */ } // 普通方法
}

// 普通类示例
class Circle extends Shape {
    @Override
    void draw() { System.out.println("Drawing circle"); } // 必须实现抽象方法
}

---

三、final 字段的作用

修饰目标	效果	示例
类	禁止被继承	final class MyFinalClass {}
方法	禁止被子类重写	public final void lock() {}
变量	禁止重新赋值（常量）	final int MAX_SIZE = 100;

---

四、深拷贝 (Deep Copy) vs 浅拷贝 (Shallow Copy)

特性	浅拷贝	深拷贝
对象复制	复制对象本身	复制对象及其引用的所有子对象
引用字段	新旧对象共享同一引用	递归创建引用对象的新副本
内存开销	低	高
独立性	修改引用对象会影响原对象	新旧对象完全独立

// 浅拷贝示例（默认 clone() 行为）
class Person implements Cloneable {
    String name;
    Address address; // 引用类型字段

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝：address 被直接复制引用
    }
}

---

五、实现深拷贝的三种方法

1. 重写 clone() 方法（递归复制）

   @Override
   protected Object clone() throws CloneNotSupportedException {
       Person cloned = (Person) super.clone();
       cloned.address = (Address) address.clone(); // 手动复制引用对象
       return cloned;
   }

2. 序列化/反序列化

   public Person deepCopy() throws IOException, ClassNotFoundException {
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       ObjectOutputStream oos = new ObjectOutputStream(bos);
       oos.writeObject(this);
       
       ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
       ObjectInputStream ois = new ObjectInputStream(bis);
       return (Person) ois.readObject();
   }

3. 手动递归复制

   public Person deepCopyManual() {
       Person copy = new Person();
       copy.name = this.name;
       copy.address = new Address(this.address.street); // 创建新对象
       return copy;
   }

---

六、泛型 (Generics)

核心作用 ：在编译期进行类型安全检查，避免运行时 ClassCastException。
应用场景：

// 泛型类
class Box<T> {
    private T content;
    void setContent(T content) { this.content = content; }
    T getContent() { return content; }
}

// 使用示例
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello Generics!");
String value = stringBox.getContent(); // 无需强制类型转换

---

七、Java 创建对象的 5 种方法

1. new 关键字
   Person p = new Person();

2. 反射 Class.newInstance()
Person p = Person.class.newInstance();

3. 反射 Constructor.newInstance()

   Constructor<Person> constructor = Person.class.getConstructor();
   Person p = constructor.newInstance();

4. 序列化/反序列化

   ObjectInputStream ois = new ObjectInputStream(inputStream);
   Person p = (Person) ois.readObject();

5. clone() 方法
   Person p = originalPerson.clone();

---

八、获取私有对象的两种方法

1. 通过 Getter 方法（标准做法）

   public class User {
       private String secret = "Confidential";
       public String getSecret() { return secret; } // 提供公共访问接口
   }

2. 通过反射（打破封装性）

   Field field = User.class.getDeclaredField("secret");
   field.setAccessible(true); // 关闭访问检查
   String secretValue = (String) field.get(userInstance); // 强制获取

---