Java繼承復(fù)用中的常見問題與優(yōu)化技巧

更新時(shí)間：2025年05月30日 11:14:44 作者：異常君

繼承是 Java 面向?qū)ο缶幊痰幕A(chǔ)特性,正確使用能提高代碼復(fù)用性,但不恰當(dāng)?shù)睦^承設(shè)計(jì)會(huì)帶來維護(hù)難題和性能問題,本文通過實(shí)際案例分析常見問題,并提供具體優(yōu)化方案,需要的朋友可以參考下

1. 繼承層次過深問題

繼承層次過深會(huì)導(dǎo)致代碼難以理解和維護(hù)，還可能引發(fā)性能問題。

問題案例

class Animal {
    protected String name;

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

    public String getName() {
        return name;
    }

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

class Mammal extends Animal {
    protected int legCount;

    public void setLegCount(int legCount) {
        this.legCount = legCount;
    }

    public int getLegCount() {
        return legCount;
    }

    public void walk() {
        System.out.println(name + " is walking with " + legCount + " legs");
    }
}

class Canine extends Mammal {
    protected boolean hasTail;

    public void setHasTail(boolean hasTail) {
        this.hasTail = hasTail;
    }

    public boolean hasTail() {
        return hasTail;
    }

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

class Dog extends Canine {
    private String breed;

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }

    public void fetch() {
        System.out.println(name + " is fetching");
    }
}

class GermanShepherd extends Dog {
    // 繼承鏈已經(jīng)很長(zhǎng)了
    public void guard() {
        System.out.println(name + " is guarding");
    }
}

這個(gè)繼承鏈中包含了 5 個(gè)層級(jí)，當(dāng)我們使用GermanShepherd類時(shí)：

GermanShepherd dog = new GermanShepherd();
dog.setName("Max"); // 通過setter設(shè)置名稱
dog.setLegCount(4); // 設(shè)置腿的數(shù)量
dog.setHasTail(true); // 設(shè)置是否有尾巴
dog.guard(); // 當(dāng)前類方法

問題分析

代碼可讀性差：必須追溯多個(gè)父類才能理解完整功能
方法解析層級(jí)深：JVM 需從子類到父類逐層查找方法，增加動(dòng)態(tài)綁定開銷
修改基類影響大：修改 Animal 類可能影響整個(gè)繼承鏈

從字節(jié)碼層面看，深層繼承導(dǎo)致方法調(diào)用時(shí) JVM 需要執(zhí)行更多invokevirtual指令來查找方法實(shí)現(xiàn)：

# 繼承鏈方法調(diào)用
javap -c GermanShepherd | grep invokevirtual
# 輸出類似：
# 15: invokevirtual #8  // Method getName:()Ljava/lang/String;
# 25: invokevirtual #10 // Method bark:()V

優(yōu)化方案

組合優(yōu)先于繼承：將部分功能抽取為接口和獨(dú)立類，通過組合方式使用

// 定義行為接口
interface LocomotionBehavior {
    void move(String name);
}

interface GuardBehavior {
    void guard(String name);
}

// 行為集合類
class BehaviorSet {
    private final LocomotionBehavior locomotion;
    private final GuardBehavior guardBehavior;

    public BehaviorSet(LocomotionBehavior locomotion, GuardBehavior guardBehavior) {
        this.locomotion = locomotion;
        this.guardBehavior = guardBehavior;
    }

    public LocomotionBehavior getLocomotion() {
        return locomotion;
    }

    public GuardBehavior getGuardBehavior() {
        return guardBehavior;
    }
}

class Animal {
    private String name;

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

    public String getName() {
        return name;
    }

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

class QuadrupedLocomotion implements LocomotionBehavior {
    private int legCount;

    public QuadrupedLocomotion(int legCount) {
        this.legCount = legCount;
    }

    @Override
    public void move(String name) {
        System.out.println(name + " is moving with " + legCount + " legs");
    }
}

class ActiveGuardBehavior implements GuardBehavior {
    @Override
    public void guard(String name) {
        System.out.println(name + " is actively guarding the area");
    }
}

class Dog extends Animal {
    private final BehaviorSet behaviors;
    private boolean hasTail;
    private String breed;

    public Dog(String name, int legCount, boolean hasTail, String breed) {
        super(name);
        LocomotionBehavior locomotion = new QuadrupedLocomotion(legCount);
        GuardBehavior guardBehavior = new ActiveGuardBehavior();
        this.behaviors = new BehaviorSet(locomotion, guardBehavior);
        this.hasTail = hasTail;
        this.breed = breed;
    }

    public void move() {
        behaviors.getLocomotion().move(getName());
    }

    public void performGuard() {
        behaviors.getGuardBehavior().guard(getName());
    }

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

字節(jié)碼層面的比較：

# 組合方案方法調(diào)用
javap -c Dog | grep invokeinterface
# 輸出類似：
# 10: invokeinterface #6,  2  // InterfaceMethod LocomotionBehavior.move:(Ljava/lang/String;)V

使用組合后，我們可以通過接口實(shí)現(xiàn)行為的靈活組合，符合"接口隔離原則"，降低了類之間的耦合度。

2. 父類變更對(duì)子類的影響

父類的修改可能會(huì)導(dǎo)致子類行為發(fā)生意外變化，這是 Java 繼承中最容易忽視的問題，即"脆弱基類問題"(Fragile Base Class Problem)。

問題案例

// 初始版本
class Parent {
    public void process() {
        step1();
        step2();
    }

    protected void step1() {
        System.out.println("Parent step1");
    }

    protected void step2() {
        System.out.println("Parent step2");
    }
}

class Child extends Parent {
    @Override
    protected void step2() {
        System.out.println("Child step2");
    }
}

客戶端代碼：

Child child = new Child();
child.process(); // 輸出：Parent step1, Child step2

后來，父類做了"看似無害"的修改：

class Parent {
    public void process() {
        step1();
        step2();
        step3(); // 新增了一個(gè)步驟
    }

    protected void step1() {
        System.out.println("Parent step1");
    }

    protected void step2() {
        System.out.println("Parent step2");
    }

    protected void step3() {
        System.out.println("Parent step3");
    }
}

這時(shí)子類沒有任何修改，但執(zhí)行結(jié)果變成了：Parent step1, Child step2, Parent step3

問題分析

這種問題本質(zhì)上違反了"里氏替換原則"(Liskov Substitution Principle)：子類必須能替換其父類且不改變程序正確性。子類對(duì)父類實(shí)現(xiàn)細(xì)節(jié)的依賴是設(shè)計(jì)問題的根源。

優(yōu)化方案

模板方法模式：父類定義整體流程，子類實(shí)現(xiàn)特定步驟

class Parent {
    // final防止子類覆蓋整個(gè)流程
    public final void process() {
        step1();
        step2();
        step3();
        // 鉤子方法(Hook Method)，子類可以覆蓋
        postProcess();
    }

    // 可以由子類覆蓋的步驟
    protected void step1() {
        System.out.println("Parent step1");
    }

    protected void step2() {
        System.out.println("Parent step2");
    }

    protected void step3() {
        System.out.println("Parent step3");
    }

    // 鉤子方法，默認(rèn)為空實(shí)現(xiàn)
    protected void postProcess() {
        // 默認(rèn)空實(shí)現(xiàn)
    }
}

策略模式：比模板方法更靈活，適合步驟可動(dòng)態(tài)替換的場(chǎng)景

interface ProcessStrategy {
    void execute(List<?> data); // 明確處理的數(shù)據(jù)
}

class DefaultProcessStrategy implements ProcessStrategy {
    @Override
    public void execute(List<?> data) {
        System.out.println("Processing " + data.size() + " items");
    }
}

class Parent {
    private ProcessStrategy processStrategy;
    private List<?> data;

    public Parent(List<?> data) {
        this.data = data;
        this.processStrategy = new DefaultProcessStrategy();
    }

    public void setProcessStrategy(ProcessStrategy strategy) {
        this.processStrategy = strategy;
    }

    public void process() {
        // 前置處理
        preProcess();
        // 委托給策略執(zhí)行
        processStrategy.execute(data);
        // 后置處理
        postProcess();
    }

    protected void preProcess() {
        System.out.println("Pre-processing");
    }

    protected void postProcess() {
        System.out.println("Post-processing");
    }
}

Spring 框架使用類似機(jī)制解決這類問題：

// 類似Spring的InitializingBean接口
public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

public abstract class AbstractBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 子類覆蓋此方法進(jìn)行初始化，而不是構(gòu)造函數(shù)
        initBean();
    }

    protected abstract void initBean() throws Exception;
}

3. 構(gòu)造函數(shù)與初始化順序問題

繼承中構(gòu)造函數(shù)的調(diào)用順序和初始化邏輯常常是錯(cuò)誤的根源。

問題案例

class Parent {
    private int value;

    public Parent() {
        init(); // 在構(gòu)造函數(shù)中調(diào)用可能被子類覆蓋的方法
    }

    protected void init() {
        value = 10;
    }

    public int getValue() {
        return value;
    }
}

class Child extends Parent {
    // 顯式初始化，未在構(gòu)造函數(shù)中賦值
    private int childValue = 20;

    @Override
    protected void init() {
        super.init();
        // 父類構(gòu)造調(diào)用此方法時(shí)，childValue已初始化為20
        // 但子類構(gòu)造函數(shù)尚未執(zhí)行完畢
        childValue = childValue * 2; // 此時(shí)childValue=20，結(jié)果為40
    }

    public int getChildValue() {
        return childValue;
    }
}

讓我們修改示例，使問題更明顯：

class Child extends Parent {
    // 不使用顯式初始化
    private int childValue;

    public Child() {
        childValue = 20; // 構(gòu)造函數(shù)中賦值
    }

    @Override
    protected void init() {
        super.init();
        childValue = childValue * 2; // 此時(shí)childValue=0(默認(rèn)值)，結(jié)果為0
    }
}

測(cè)試代碼：

Child child = new Child();
System.out.println(child.getValue() + ", " + child.getChildValue());
// 期望輸出：10, 40
// 實(shí)際輸出：10, 0

問題分析

Java 對(duì)象初始化順序如下：

父類靜態(tài)變量和靜態(tài)塊
子類靜態(tài)變量和靜態(tài)塊
父類實(shí)例變量和實(shí)例初始化塊
父類構(gòu)造函數(shù)
子類實(shí)例變量和實(shí)例初始化塊
子類構(gòu)造函數(shù)

關(guān)鍵問題是：父類構(gòu)造函數(shù)中調(diào)用的被子類覆蓋的方法會(huì)在子類實(shí)例變量初始化前執(zhí)行。

優(yōu)化方案

不在構(gòu)造函數(shù)中調(diào)用可覆蓋的方法：

class Parent {
    private int value;

    public Parent() {
        // 直接初始化，不調(diào)用可能被覆蓋的方法
        value = 10;
    }

    // 提供初始化方法，但不在構(gòu)造函數(shù)中調(diào)用
    protected void init() {
        // 可以被子類安全覆蓋
    }

    public int getValue() {
        return value;
    }
}

class Child extends Parent {
    private int childValue;

    public Child() {
        // 子類構(gòu)造函數(shù)中完成自己的初始化
        childValue = 20;
        init(); // 安全調(diào)用，此時(shí)所有字段都已初始化
    }

    @Override
    protected void init() {
        super.init();
        childValue = childValue * 2; // 現(xiàn)在childValue是20
    }

    public int getChildValue() {
        return childValue;
    }
}

使用工廠方法和后置初始化：

class Parent {
    private int value;

    protected Parent() {
        value = 10;
        // 不調(diào)用可能被覆蓋的方法
    }

    public static Parent create() {
        Parent p = new Parent();
        p.postConstruct(); // 工廠方法中調(diào)用后置初始化
        return p;
    }

    protected void postConstruct() {
        // 初始化代碼放這里，子類可以安全覆蓋
    }

    public int getValue() {
        return value;
    }
}

class Child extends Parent {
    private int childValue;

    protected Child() {
        // 構(gòu)造函數(shù)只做最基本的初始化
        childValue = 20;
    }

    public static Child create() {
        Child c = new Child();
        c.postConstruct(); // 構(gòu)造完成后調(diào)用
        return c;
    }

    @Override
    protected void postConstruct() {
        super.postConstruct();
        childValue = childValue * 2; // 安全地修改childValue
    }

    public int getChildValue() {
        return childValue;
    }
}

4. equals 和 hashCode 繼承問題

equals 和 hashCode 方法的正確實(shí)現(xiàn)對(duì) Java 集合類的正常工作至關(guān)重要，但在繼承中很容易出錯(cuò)。

問題案例

class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Point point = (Point) obj;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;
    }
}

class ColorPoint extends Point {
    private String color; // 不是final，可變

    public ColorPoint(int x, int y, String color) {
        super(x, y);
        this.color = color;
    }

    public String getColor() { return color; }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public boolean equals(Object obj) {
        if (!super.equals(obj)) return false;
        // 這里有問題：父類的equals已經(jīng)做了getClass檢查，這里類型轉(zhuǎn)換可能出錯(cuò)
        ColorPoint colorPoint = (ColorPoint) obj;
        return Objects.equals(color, colorPoint.color);
    }

    // 沒有覆蓋hashCode!
}

測(cè)試代碼：

Point p = new Point(1, 2);
ColorPoint cp1 = new ColorPoint(1, 2, "red");
ColorPoint cp2 = new ColorPoint(1, 2, "blue");

System.out.println(p.equals(cp1)); // false - 類型不匹配
System.out.println(cp1.equals(p)); // ClassCastException! - 無法將Point轉(zhuǎn)為ColorPoint

Map<ColorPoint, String> map = new HashMap<>();
map.put(cp1, "First point");
System.out.println(map.get(cp1)); // "First point"
cp1.setColor("green"); // 修改了影響hashCode的字段
System.out.println(map.get(cp1)); // null - 找不到了!

問題分析

equals 違反了對(duì)稱性：p.equals(cp1)與 cp1.equals(p)結(jié)果不一致，甚至拋出異常
沒有覆蓋 hashCode，違反了"equals 相等則 hashCode 必須相等"的約定
可變對(duì)象作為 HashMap 的鍵會(huì)導(dǎo)致數(shù)據(jù)丟失

《Effective Java》明確指出 equals 必須滿足：

自反性：x.equals(x)為 true
對(duì)稱性：x.equals(y)為 true 當(dāng)且僅當(dāng) y.equals(x)為 true
傳遞性：x.equals(y)為 true 且 y.equals(z)為 true，則 x.equals(z)為 true
一致性：多次調(diào)用 x.equals(y)結(jié)果一致

優(yōu)化方案

組合優(yōu)先于繼承：

class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Point point = (Point) obj;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;
    }

    @Override
    public String toString() {
        return "Point[x=" + x + ", y=" + y + "]";
    }
}

// 使用組合而非繼承
class ColorPoint {
    private final Point point;
    private final String color;

    public ColorPoint(int x, int y, String color) {
        this.point = new Point(x, y);
        this.color = color;
    }

    // 委托方法
    public int getX() { return point.getX(); }
    public int getY() { return point.getY(); }
    public String getColor() { return color; }

    // 防御性拷貝，避免外部修改
    public Point asPoint() {
        return new Point(point.getX(), point.getY());
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        ColorPoint that = (ColorPoint) obj;
        return point.equals(that.point) && Objects.equals(color, that.color);
    }

    @Override
    public int hashCode() {
        return 31 * point.hashCode() + Objects.hashCode(color);
    }

    @Override
    public String toString() {
        return "ColorPoint[point=" + point + ", color=" + color + "]";
    }
}

使用 Java 16+記錄類(Record)：

// 使用記錄類自動(dòng)實(shí)現(xiàn)equals、hashCode、toString
record Point(int x, int y) {}
record ColorPoint(Point point, String color) {
    // 自定義構(gòu)造函數(shù)驗(yàn)證參數(shù)
    public ColorPoint {
        if (color == null) {
            throw new NullPointerException("Color cannot be null");
        }
    }

    // 便捷方法
    public int x() {
        return point.x();
    }

    public int y() {
        return point.y();
    }
}

// 使用示例
Point p = new Point(1, 2);
ColorPoint cp = new ColorPoint(p, "red");
System.out.println(cp.point().x()); // 1

5. 父類方法重寫問題

方法重寫是 Java 多態(tài)的基礎(chǔ)，但不恰當(dāng)?shù)闹貙憰?huì)帶來意外問題。

問題案例

class DataProcessor {
    protected List<Integer> data;

    public DataProcessor(List<Integer> data) {
        this.data = data;
    }

    public void process() {
        for (int i = 0; i < data.size(); i++) {
            processItem(i);
        }
    }

    protected void processItem(int index) {
        data.set(index, data.get(index) * 2);
    }
}

class FilterProcessor extends DataProcessor {
    private int threshold;

    public FilterProcessor(List<Integer> data, int threshold) {
        super(data);
        this.threshold = threshold;
    }

    @Override
    protected void processItem(int index) {
        if (data.get(index) > threshold) {
            super.processItem(index);
        }
    }
}

現(xiàn)在基類開發(fā)者修改了代碼：

class DataProcessor {
    // 其他代碼不變

    public void process() {
        // 修改了遍歷順序
        for (int i = data.size() - 1; i >= 0; i--) {
            processItem(i);
        }
    }
}

問題分析

子類依賴了父類的實(shí)現(xiàn)細(xì)節(jié)（遍歷順序），當(dāng)父類修改實(shí)現(xiàn)時(shí)，子類行為可能發(fā)生變化。這違反了"里氏替換原則"，子類不能完全替代父類使用。

里氏替換原則的典型反例：

// 矩形/正方形問題
class Rectangle {
    private int width;
    private int height;

    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    public int getArea() { return width * height; }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width); // 正方形要求寬高相等
    }

    @Override
    public void setHeight(int height) {
        super.setHeight(height);
        super.setWidth(height); // 正方形要求寬高相等
    }
}

// 使用代碼
Rectangle rect = new Square();
rect.setWidth(5);
rect.setHeight(10);
int area = rect.getArea(); // 期望50，實(shí)際100

優(yōu)化方案

使用組合和回調(diào)：

// 回調(diào)接口
interface ItemProcessor {
    void process(List<Integer> data, int index);
}

class DataProcessor {
    protected List<Integer> data;
    private ItemProcessor itemProcessor;

    public DataProcessor(List<Integer> data, ItemProcessor itemProcessor) {
        this.data = data;
        this.itemProcessor = itemProcessor;
    }

    public void process() {
        // 實(shí)現(xiàn)可以變化，但接口穩(wěn)定
        for (int i = 0; i < data.size(); i++) {
            itemProcessor.process(data, i);
        }
    }

    // 默認(rèn)處理器作為靜態(tài)工廠方法
    public static DataProcessor createDefault(List<Integer> data) {
        return new DataProcessor(data, (list, index) ->
            list.set(index, list.get(index) * 2));
    }
}

// 過濾處理器
class FilterProcessor implements ItemProcessor {
    private int threshold;
    private ItemProcessor wrapped;

    public FilterProcessor(int threshold, ItemProcessor wrapped) {
        this.threshold = threshold;
        this.wrapped = wrapped;
    }

    @Override
    public void process(List<Integer> data, int index) {
        if (data.get(index) > threshold) {
            wrapped.process(data, index);
        }
    }
}

使用示例：

List<Integer> data = new ArrayList<>(Arrays.asList(1, 5, 10, 15, 20));

// 創(chuàng)建處理器
ItemProcessor doubler = (list, index) -> list.set(index, list.get(index) * 2);
ItemProcessor filtered = new FilterProcessor(7, doubler);
DataProcessor processor = new DataProcessor(data, filtered);

// 處理數(shù)據(jù)
processor.process();

6. 抽象類與接口的選擇問題

錯(cuò)誤的抽象方式會(huì)導(dǎo)致繼承體系僵化，限制擴(kuò)展性。

問題案例

// 錯(cuò)誤設(shè)計(jì)：將具體實(shí)現(xiàn)放在抽象類中
abstract class AbstractRepository {
    private Connection connection;

    public AbstractRepository() {
        // 固定的數(shù)據(jù)庫(kù)連接初始化
        try {
            connection = DriverManager.getConnection("jdbc:mysql://localhost/db", "user", "pass");
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    // 通用的CRUD操作
    public void save(Object entity) {
        // 保存實(shí)現(xiàn)...
    }

    public Object findById(Long id) {
        // 查詢實(shí)現(xiàn)...
        return null;
    }

    // 子類需要實(shí)現(xiàn)的抽象方法
    protected abstract String getTableName();
}

// 用戶倉(cāng)庫(kù)
class UserRepository extends AbstractRepository {
    @Override
    protected String getTableName() {
        return "users";
    }

    // 特有方法
    public User findByUsername(String username) {
        // 實(shí)現(xiàn)...
        return null;
    }
}

// 訂單倉(cāng)庫(kù)
class OrderRepository extends AbstractRepository {
    @Override
    protected String getTableName() {
        return "orders";
    }

    // 需要使用不同的數(shù)據(jù)庫(kù)連接，但無法修改
}

問題分析

抽象類中包含了具體實(shí)現(xiàn)，所有子類都被迫繼承這些實(shí)現(xiàn)
子類無法選擇不同的數(shù)據(jù)庫(kù)連接策略
如果需要實(shí)現(xiàn)新的存儲(chǔ)方式（如 NoSQL），整個(gè)繼承體系都要重寫

優(yōu)化方案

接口+默認(rèn)實(shí)現(xiàn)類：

// 接口定義行為
interface Repository<T, ID> {
    void save(T entity);
    T findById(ID id);
    List<T> findAll();
}

// 連接工廠接口
interface ConnectionFactory {
    Connection getConnection() throws SQLException;
}

// 默認(rèn)MySQL連接工廠
class MySqlConnectionFactory implements ConnectionFactory {
    @Override
    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://localhost/db", "user", "pass");
    }
}

// 行映射接口
interface RowMapper<T> {
    T mapRow(ResultSet rs) throws SQLException;
}

// 默認(rèn)實(shí)現(xiàn)類
class JdbcRepository<T, ID> implements Repository<T, ID> {
    private final ConnectionFactory connectionFactory;
    private final String tableName;
    private final RowMapper<T> rowMapper;

    // 構(gòu)造函數(shù)注入，符合依賴倒置原則
    public JdbcRepository(ConnectionFactory connectionFactory,
                          String tableName,
                          RowMapper<T> rowMapper) {
        this.connectionFactory = connectionFactory;
        this.tableName = tableName;
        this.rowMapper = rowMapper;
    }

    @Override
    public void save(T entity) {
        // 實(shí)現(xiàn)...
    }

    @Override
    public T findById(ID id) {
        // 實(shí)現(xiàn)...
        return null;
    }

    @Override
    public List<T> findAll() {
        // 實(shí)現(xiàn)...
        return null;
    }
}

// 使用組合方式創(chuàng)建特定倉(cāng)庫(kù)
class UserRepository {
    private final Repository<User, Long> repository;

    public UserRepository(ConnectionFactory connectionFactory) {
        this.repository = new JdbcRepository<>(
            connectionFactory,
            "users",
            rs -> {
                // 映射用戶對(duì)象
                User user = new User();
                user.setId(rs.getLong("id"));
                user.setUsername(rs.getString("username"));
                return user;
            }
        );
    }

    // 委托方法
    public void save(User user) {
        repository.save(user);
    }

    public User findById(Long id) {
        return repository.findById(id);
    }

    // 特有方法
    public User findByUsername(String username) {
        // 實(shí)現(xiàn)...
        return null;
    }
}

7. 序列化與繼承問題

在涉及序列化的繼承關(guān)系中，常常會(huì)出現(xiàn)意外的問題。

問題案例

class Parent implements Serializable {
    private static final long serialVersionUID = 1L;
    private int parentValue;

    public Parent() {
        initParent();
    }

    protected void initParent() {
        parentValue = 10;
    }

    public int getParentValue() {
        return parentValue;
    }
}

class Child extends Parent implements Serializable {
    private static final long serialVersionUID = 1L;
    private int childValue;

    public Child() {
        initChild();
    }

    protected void initChild() {
        childValue = 20;
    }

    @Override
    protected void initParent() {
        super.initParent();
        childValue = 30; // 父類構(gòu)造調(diào)用時(shí)，childValue尚未初始化
    }

    public int getChildValue() {
        return childValue;
    }
}

測(cè)試代碼：

// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
Child child = new Child();
oos.writeObject(child);

// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
Child deserializedChild = (Child) ois.readObject();

// 反序列化后的對(duì)象狀態(tài)可能不一致

問題分析

反序列化過程不會(huì)調(diào)用構(gòu)造函數(shù)，而是直接恢復(fù)字段值，這可能導(dǎo)致對(duì)象處于不一致狀態(tài)，特別是當(dāng)子類覆蓋了父類方法且方法之間有依賴關(guān)系時(shí)。

優(yōu)化方案

添加 readObject 鉤子：

class Parent implements Serializable {
    private static final long serialVersionUID = 1L;
    private int parentValue;

    public Parent() {
        initValues();
    }

    // 初始化邏輯單獨(dú)提取
    protected void initValues() {
        parentValue = 10;
    }

    // 反序列化鉤子
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        // 恢復(fù)不可序列化的狀態(tài)
        postDeserialize();
    }

    // 反序列化后的處理
    protected void postDeserialize() {
        // 默認(rèn)不做任何事
    }

    public int getParentValue() {
        return parentValue;
    }
}

class Child extends Parent {
    private static final long serialVersionUID = 1L;
    private int childValue;

    public Child() {
        // 父類構(gòu)造已經(jīng)調(diào)用過initValues
    }

    @Override
    protected void initValues() {
        super.initValues();
        childValue = 20;
    }

    @Override
    protected void postDeserialize() {
        super.postDeserialize();
        // 反序列化后的特殊處理
        validateState();
    }

    private void validateState() {
        if (childValue <= 0) {
            childValue = 20; // 恢復(fù)默認(rèn)值
        }
    }

    // 自定義反序列化鉤子
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        // 不需要顯式調(diào)用postDeserialize，父類的readObject會(huì)調(diào)用
    }

    public int getChildValue() {
        return childValue;
    }
}

使用工廠方法和 Builder 模式：

class ParentBuilder {
    private int parentValue = 10; // 默認(rèn)值

    public ParentBuilder withParentValue(int value) {
        this.parentValue = value;
        return this;
    }

    public Parent build() {
        Parent parent = new Parent();
        parent.setParentValue(parentValue);
        return parent;
    }
}

class Parent implements Serializable {
    private static final long serialVersionUID = 1L;
    private int parentValue;

    // 包級(jí)私有構(gòu)造函數(shù)，強(qiáng)制使用Builder
    Parent() {}

    void setParentValue(int value) {
        this.parentValue = value;
    }

    public static ParentBuilder builder() {
        return new ParentBuilder();
    }

    public int getParentValue() {
        return parentValue;
    }
}

8. 協(xié)變返回類型與泛型問題

Java 支持協(xié)變返回類型，但在繼承和泛型結(jié)合時(shí)容易出現(xiàn)問題。

問題案例

class Animal {
    public Animal reproduce() {
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    public Dog reproduce() { // 協(xié)變返回類型
        return new Dog();
    }
}

// 泛型容器
class Container<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

class AnimalContainer extends Container<Animal> {
    // 嘗試覆蓋泛型方法
    @Override
    public Animal getValue() {
        return super.getValue();
    }
}

class DogContainer extends AnimalContainer {
    // 不能使用協(xié)變返回類型
    // @Override
    // public Dog getValue() { // 編譯錯(cuò)誤
    //    return (Dog) super.getValue();
    // }
}

問題分析

泛型類型擦除導(dǎo)致在繼承層次中無法正確應(yīng)用協(xié)變返回類型。雖然Dog是Animal的子類，但Container<Dog>不是Container<Animal>的子類。

優(yōu)化方案

泛型通配符和自限定類型：

abstract class Animal<T extends Animal<T>> {
    @SuppressWarnings("unchecked")
    public T reproduce() {
        try {
            return (T) getClass().getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

class Dog extends Animal<Dog> {
    // 無需覆蓋reproduce方法，自動(dòng)返回正確類型
}

// 容器設(shè)計(jì)
interface Container<T, S extends Container<T, S>> {
    T getValue();
    S setValue(T value);
}

class GenericContainer<T> implements Container<T, GenericContainer<T>> {
    private T value;

    @Override
    public T getValue() {
        return value;
    }

    @Override
    public GenericContainer<T> setValue(T value) {
        this.value = value;
        return this;
    }
}

class DogContainer extends GenericContainer<Dog> {
    // 自動(dòng)繼承正確的返回類型
}

總結(jié)

下面是 Java 繼承復(fù)用中常見問題及解決方案的總結(jié)：

問題類型	代碼審查關(guān)鍵點(diǎn)	推薦解決方案	重構(gòu)工具建議
繼承層次過深	類層級(jí)>3 層，使用`protected`字段超過 3 個(gè)	使用組合+接口替代繼承，控制繼承層次不超過 2 層	IDEA 的"Extract Interface"和"Replace Inheritance with Delegation"
父類變更影響	子類依賴父類實(shí)現(xiàn)細(xì)節(jié)，父類方法被子類廣泛覆蓋	使用模板方法模式，或用組合+策略模式替代繼承	IDEA 的"Extract Method"和"Extract Delegate"
構(gòu)造函數(shù)問題	構(gòu)造函數(shù)中調(diào)用可覆蓋方法，子類構(gòu)造中使用`super`以外的代碼	避免在構(gòu)造函數(shù)中調(diào)用可覆蓋方法，使用工廠方法+后置初始化	FindBugs 的"SE_METHOD_MUST_BE_PRIVATE"
equals/hashCode 錯(cuò)誤	未正確覆蓋 hashCode，使用 instanceof 或==比較對(duì)象引用	優(yōu)先使用組合而非繼承，確保 equals/hashCode 符合約定	FindBugs 的"EQ_DOESNT_OVERRIDE_HASHCODE"
方法重寫問題	子類依賴父類實(shí)現(xiàn)細(xì)節(jié)，違反里氏替換原則	使用組合和回調(diào)機(jī)制，避免不當(dāng)重寫	SonarQube 的"S1161"（覆蓋方法應(yīng)調(diào)用 super）
抽象類濫用	抽象類中包含具體實(shí)現(xiàn)，繼承鏈僵化	優(yōu)先使用接口+默認(rèn)實(shí)現(xiàn)類，通過組合實(shí)現(xiàn)代碼復(fù)用	IDEA 的"Replace Constructor with Factory Method"
序列化問題	繼承類序列化未處理自定義反序列化邏輯	添加 readObject 鉤子，使用 Builder 模式	FindBugs 的"SE_NO_SUITABLE_CONSTRUCTOR"
協(xié)變返回與泛型	嘗試在泛型類中使用協(xié)變返回類型	使用自限定泛型和接口隔離	IDEA 的"Generify"

性能測(cè)試顯示，在大型項(xiàng)目中，優(yōu)化繼承結(jié)構(gòu)可以帶來 5-15%的性能提升，更重要的是可維護(hù)性的大幅提高。

@State(Scope.Benchmark)
public class InheritanceVsCompositionBenchmark {
    private GermanShepherd inheritanceDog;
    private Dog compositionDog;

    @Setup
    public void setup() {
        inheritanceDog = new GermanShepherd();
        inheritanceDog.setName("Rex");
        compositionDog = new Dog("Rex", 4, true, "German Shepherd");
    }

    @Benchmark
    public void inheritanceMethodCall(Blackhole bh) {
        bh.consume(inheritanceDog.getName());
        inheritanceDog.eat();
    }

    @Benchmark
    public void compositionMethodCall(Blackhole bh) {
        bh.consume(compositionDog.getName());
        compositionDog.eat();
    }
}

合理使用繼承和組合是 Java 面向?qū)ο缶幊痰年P(guān)鍵技能。記住"組合優(yōu)先于繼承"的原則，在適當(dāng)?shù)膱?chǎng)景選擇正確的代碼復(fù)用方式，可以大大提高代碼的可維護(hù)性和健壯性。

以上就是Java繼承復(fù)用中的常見問題與優(yōu)化技巧的詳細(xì)內(nèi)容，更多關(guān)于Java繼承復(fù)用的問題與優(yōu)化的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: