从其中调用 Overridden 方法时会发生什么？

Question

i was writing Rational class in java to do basic math operation and i want to override methods from Number class and Comparable interface . i have done that for doubleValue & compareTo methods.

As we know that BigInteger class also extends Number class , so i am confused that which method is being called in doubleValue because i have already override doubleValue & compareTo and calling doubleValue with in doubleValue & compareTo with in compareTo . and it's seems silly too.

import java.math.BigInteger;
class Rational extends Number implements Comparable<Rational>{

    // Data fields for numerator and denominator
    private BigInteger numerator = BigInteger.ZERO;
    private BigInteger denominator = BigInteger.ONE;

    // Construct a rational with default properties
    Rational(){
        numerator = BigInteger.ZERO;
        denominator = BigInteger.ONE;
    }
    Rational(BigInteger numerator,BigInteger denominator){
        BigInteger gcde = numerator.gcd(denominator);
        BigInteger temp = BigInteger.valueOf( (long)(denominator.compareTo(BigInteger.ZERO)) );
        this.numerator =  temp.multiply(numerator.divide(gcde));
        this.denominator = (denominator.abs()).divide(gcde);
    }
    
    // subtract a rational number to this rational a/b - r.a/r.b = a*r.b - r.a*b/r.b*b
    public Rational subtract(Rational r){
        BigInteger n = (numerator.multiply(r.getDenominator())).subtract(denominator.multiply(r.getNumerator())); 
        BigInteger d = denominator.multiply(r.getDenominator());
        return new Rational(n,d);
    }
    // Return numerator
    public BigInteger getNumerator(){
        return numerator;
    }
    // Return denominator
    public BigInteger getDenominator(){
       return denominator;
    }
    @Override // Implement the abstract doubleValue method in Number
    public double doubleValue(){
        return numerator.doubleValue()/denominator.doubleValue();
    }
    @Override // Implement the abstract longValue method in Number
    public long longValue(){
        return (long)doubleValue();
    }
    @Override
    public int compareTo(Rational r){
        return (this.subtract(r).getNumerator()).compareTo(BigInteger.ZERO);
    }
}

Answer 1

public double doubleValue(){
    return numerator.doubleValue()/denominator.doubleValue();
}

numerator is a BigInteger so BigInteger.doubleValue() is being called. Same with denominator . It does not matter that your class also happens to have a doubleValue() function. numerator and denominator are a different class than your Rational class.

          Number
          /   \
BigInteger     Rational
    |              |
doubleValue   doubleValue