Overriding a Computation with a Two-Arg Super

super.method(arg1, arg2) works the same as super.method(), except it passes arguments to the parent's version. The same applies to super(arg1, arg2) in constructors.

This pattern matters when the parent's computation depends on its parameters — and the subclass wants to either reuse the same parameters or modify them before delegation.

On the AP exam, this appears in constructor chaining and in parameterized-method overrides.

Constructor with multi-arg super

public class Rectangle {
    private int width, height;
    public Rectangle(int w, int h) {
        width = w;
        height = h;
    }
    public int area() { return width * height; }
}

public class ColoredRectangle extends Rectangle {
    private String color;
    public ColoredRectangle(int w, int h, String c) {
        super(w, h);   // pass width and height to Rectangle
        color = c;
    }
}

Method override with multi-arg super

public class Discount {
    public double applyDiscount(double price, double percent) {
        return price * (1 - percent / 100);
    }
}

public class TaxedDiscount extends Discount {
    private double taxRate;
    public TaxedDiscount(double t) { taxRate = t; }
    @Override
    public double applyDiscount(double price, double percent) {
        double afterDiscount = super.applyDiscount(price, percent);
        return afterDiscount * (1 + taxRate / 100);
    }
}

Modifying arguments before delegating

@Override
public double applyDiscount(double price, double percent) {
    // give a 5% extra discount on top
    return super.applyDiscount(price, percent + 5);
}