多態的動態綁定機制
當你在代碼中寫下 Animal animal = new Dog(); animal.makeSound(); 時，明明 animal 聲明為 Animal 類型，為什麼最終執行的是 Dog 類的 makeSound 方法？這背後正是Java多態的核心——動態綁定機制在起作用。
多態的實現依賴三個條件：繼承關係、方法重寫和父類引用指向子類對象。當調用重寫方法時，JVM會在運行時根據對象的實際類型確定調用哪個類的方法，而非編譯時的聲明類型。這種"運行時才確定具體行為"的特性，讓代碼獲得了驚人的靈活性。
上圖展示了多態調用的內存機制：棧中的父類引用變量指向堆中實際的子類對象。當調用方法時，JVM通過引用找到堆中對象，再根據對象類型調用對應方法。這種機制使得我們可以寫出如下通用代碼：
public class AnimalSound {
public static void makeAnimalSound(Animal animal) {
animal.makeSound(); // 實際調用的是子類重寫的方法
}
public static void main(String[] args) {
makeAnimalSound(new Dog()); // 輸出 "汪汪汪"
makeAnimalSound(new Cat()); // 輸出 "喵喵喵"
makeAnimalSound(new Duck()); // 輸出 "嘎嘎嘎"
}
}這段代碼中，makeAnimalSound 方法僅接收 Animal 類型參數，卻能正確執行不同子類的方法。如果後續需要添加 Pig 類，只需讓其繼承 Animal 並重寫 makeSound 方法，無需修改 AnimalSound 類的代碼——這完美體現了開閉原則（對擴展開放，對修改關閉）。
抽象類與接口的定義及區別
在Java中，抽象類和接口是實現多態的重要工具，但它們的設計目的截然不同。
抽象類：不能實例化的模板類
抽象類使用 abstract 關鍵字修飾，包含抽象方法（沒有方法體的方法）和具體方法。它像一個不完整的模板，強制子類實現抽象方法，同時提供通用功能。例如定義一個形狀抽象類：
public abstract class Shape {
// 抽象方法：強制子類實現
public abstract double getArea();
public abstract double getPerimeter();
// 具體方法：提供通用功能
public void printInfo() {
System.out.println("面積: " + getArea() + ", 周長: " + getPerimeter());
}
}子類繼承抽象類後必須實現所有抽象方法：
接口：純粹的行為規範
接口使用 interface 關鍵字定義，只能包含抽象方法（Java 8後可含默認方法和靜態方法）。它代表一種"能力"或"協議"，不關心實現細節。例如 Comparable 接口定義了對象比較的能力：
public interface Comparable<T> {
int compareTo(T o); // 比較當前對象與參數對象的大小
}實現接口的類必須實現其所有抽象方法：
抽象類與接口的核心區別
表格
|
特性 |
抽象類 |
接口 |
|
繼承 |
單繼承 |
多實現 |
|
成員 |
可包含變量、構造方法、具體方法 |
只能包含常量、抽象方法、默認方法、靜態方法 |
|
設計目的 |
代碼複用（is-a關係） |
行為規範（has-a能力） |
|
關鍵字 |
abstract class |
interface |
|
訪問修飾符 |
任意 |
默認為public（變量為public static final） |
使用場景選擇：當需要為一組相關類提供通用實現時用抽象類；當需要定義跨類別的行為規範時用接口。例如：InputStream 是抽象類（所有輸入流的通用模板），Serializable 是接口（標記類可序列化的能力）。
Object類核心方法
Object 是Java中所有類的根父類，它定義的方法是每個對象都具備的基礎能力。理解這些方法對寫出高質量代碼至關重要。
equals()：對象內容比較
equals() 用於判斷兩個對象內容是否相等。默認實現是比較內存地址（相當於 ==），但通常需要重寫：
public class Student {
private String id;
private String name;
@Override
public boolean equals(Object o) {
if (this == o) return true; // 同一對象直接返回true
if (o == null || getClass() != o.getClass()) return false; // 類型不同返回false
Student student = (Student) o;
return Objects.equals(id, student.id) && Objects.equals(name, student.name);
}
}hashCode()：哈希碼生成
hashCode() 返回對象的哈希碼，主要用於哈希表（如 HashMap）。重寫 equals() 時必須重寫 hashCode()，確保"相等對象必須有相等哈希碼"：
@Override
public int hashCode() {
return Objects.hash(id, name); // 基於參與equals比較的字段生成哈希碼
}toString()：對象字符串表示
toString() 返回對象的字符串描述，默認格式是 類名@哈希碼。重寫後可返回有意義信息：
@Override
public String toString() {
return "Student{id='" + id + "', name='" + name + "'}";
}getClass()：獲取運行時類
getClass() 返回對象的運行時類對象，可用於反射操作：
Student s = new Student();
Class<?> clazz = s.getClass();
System.out.println(clazz.getName()); // 輸出 "com.example.Student"
多態在實際開發中的應用
多態不是語法糖，而是解決複雜問題的強大工具。以下是幾個典型應用場景：
1. 策略模式
定義多種算法，使用多態動態切換：
// 支付策略接口
public interface PaymentStrategy {
void pay(double amount);
}
// 具體策略實現
public class AlipayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("支付寶支付: " + amount);
}
}
public class WechatPayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("微信支付: " + amount);
}
}
// 使用策略
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount); // 多態調用
}
}2. 工廠模式
通過工廠類創建對象，隱藏創建細節：
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() { System.out.println("畫圓形"); }
}
public class Rectangle implements Shape {
@Override
public void draw() { System.out.println("畫矩形"); }
}
public class ShapeFactory {
public static Shape getShape(String type) {
if ("circle".equals(type)) return new Circle();
if ("rectangle".equals(type)) return new Rectangle();
return null;
}
}
// 使用
Shape shape = ShapeFactory.getShape("circle");
shape.draw(); // 多態調用3. 依賴注入
Spring等框架的核心機制，通過多態實現組件解耦：
// 服務接口
public interface UserService {
void saveUser(User user);
}
// 服務實現
@Service
public class UserServiceImpl implements UserService {
@Override
public void saveUser(User user) {
// 保存用户邏輯
}
}
// 控制器依賴接口而非具體實現
@Controller
public class UserController {
@Autowired
private UserService userService; // 多態注入
public void addUser(User user) {
userService.saveUser(user); // 多態調用
}
}多態的本質是分離接口與實現，這使得代碼更靈活、更易於擴展。當你看到 List list = new ArrayList() 這樣的代碼時，就應該意識到這是多態的典型應用——面向抽象編程，而非具體實現。
總結與實踐
今天我們學習了Java面向對象的三大核心特性之一——多態，以及實現多態的重要工具：抽象類和接口，還有所有類的根基 Object 類。這些知識是理解Java框架設計、寫出優雅代碼的基礎。
課後練習：
- 創建一個 Vehicle 抽象類，包含 start()、stop() 抽象方法和 getSpeed() 具體方法
- 定義 Flyable 接口（fly() 方法）和 Swimmable 接口（swim() 方法）
- 創建 Car（實現 Vehicle）、Airplane（實現 Vehicle 和 Flyable）、Ship（實現 Vehicle 和 Swimmable）類
- 編寫測試類，用多態方式創建對象並調用方法
思考問題：
- 為什麼重寫 equals() 必須重寫 hashCode()？
- 接口中定義的變量默認是什麼修飾符？
- 多態調用時，靜態方法和成員變量是否遵循動態綁定？
掌握這些概念需要反覆實踐。明天我們將學習異常處理，這是編寫健壯程序的必備知識。繼續加油！
