如何解决抽象类calc()方法子类参数不匹配的继承问题？

嘿，这个问题本质是Java方法重写规则的限制——你原来的子类calc方法和父类的抽象方法签名不匹配，属于重载而非重写，导致父类的抽象方法始终没被实现，编译肯定过不了。下面给你几个实用的解决方案：

方案1：用泛型让抽象类适配不同参数类型 #

把抽象类改成带泛型的，让子类指定自己需要的参数类型，同时统一calc方法的签名：

public abstract class AbstractCalculation<T, U> {
    // 定义带泛型参数的抽象方法
    public abstract double calc(T a, U b);
}

// 处理String类型的子类
public class StringClass extends AbstractCalculation<String, String> {
    @Override
    public double calc(String a, String b) {
        // 这里实现字符串转数字的计算逻辑，比如转成double相加
        return Double.parseDouble(a) + Double.parseDouble(b);
    }
}

// 处理Double类型的子类
public class DoubleClass extends AbstractCalculation<Double, Double> {
    @Override
    public double calc(Double a, Double b) {
        return a + b;
    }
}

这个方案既符合重写规则，又通过泛型约束了子类的参数类型，扩展性也不错。

方案2：通过构造函数传参，保持calc无参 #

如果不想改动父类calc的无参签名，可以把参数通过子类构造函数传入，让calc直接使用成员变量计算：

public abstract class AbstractCalculation {
    public abstract double calc();
}

public class StringClass extends AbstractCalculation {
    private final String a;
    private final String b;

    // 构造函数提前传入参数
    public StringClass(String a, String b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public double calc() {
        return Double.parseDouble(a) + Double.parseDouble(b);
    }
}

public class DoubleClass extends AbstractCalculation {
    private final double a;
    private final double b;

    public DoubleClass(double a, double b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public double calc() {
        return a + b;
    }
}

这个方案适合需要保留原有抽象方法定义的场景，逻辑也更直观。

方案3：策略模式（更灵活的扩展方案） #

如果以后还要支持更多参数类型，策略模式会更优雅——把计算逻辑封装成独立的策略类，避免子类爆炸：

// 定义计算策略接口
public interface CalculationStrategy {
    double calculate();
}

// String参数的策略实现
public class StringCalculation implements CalculationStrategy {
    private String a;
    private String b;

    public StringCalculation(String a, String b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public double calculate() {
        return Double.parseDouble(a) + Double.parseDouble(b);
    }
}

// Double参数的策略实现
public class DoubleCalculation implements CalculationStrategy {
    private double a;
    private double b;

    public DoubleCalculation(double a, double b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public double calculate() {
        return a + b;
    }
}

// 统一调用入口
public class Calculator {
    public double calculate(CalculationStrategy strategy) {
        return strategy.calculate();
    }
}

后续加新参数类型只需要新增策略类即可，完全符合开闭原则。

关键提醒 #

Java方法重写要求方法名、参数列表、返回值类型（协变除外）必须完全匹配，你原来的代码里子类的calc是重载，不是重写，所以父类的抽象方法始终未被实现，这是核心问题~

内容的提问来源于stack exchange，提问作者Erik