Calculate tax return Please consider this code for a TaxReturnCalculator (and ignore both the suboptimal use of float instead of BigDecimal and non-existing parameter validation):
public class TaxReturnCalculator {
    
    private static final float FIFTY_PERCENT = 0.5f;
    private static final float THIRTY_PERCENT = 0.3f;
    private static final float MAXIMUM_AMOUNT_TAX_RETURN = 1000f;
    
    public static float calculateTaxReturn(float income)
    {
        float basicTaxReturn = calculateBasicTaxReturn(income);
        
        float taxReturnAddition = calculateTaxReturnAddition(basicTaxReturn);
        
        float taxReturn = basicTaxReturn + taxReturnAddition;
        
        float taxReturnLimited = calculateTaxReturnLimited(taxReturn);
        
        return taxReturnLimited;
    }

    private static float calculateBasicTaxReturn(float income)
    {
        return income * FIFTY_PERCENT; // More complex calculation here
    }

    private static float calculateTaxReturnAddition(float basicTaxReturn) 
    {       
        return basicTaxReturn * THIRTY_PERCENT;  // More complex calculation here
    }
    
    private static float calculateTaxReturnLimited(float taxReturn)
    {
        float taxReturnLimited;
        
        if(taxReturn &gt; MAXIMUM_AMOUNT_TAX_RETURN)
        {
            taxReturnLimited = MAXIMUM_AMOUNT_TAX_RETURN;
        }
        else
        {
            taxReturnLimited = taxReturn;
        }
        
        return taxReturnLimited;
    }
}

I designed the calculateTaxReturn(float income) method to follow the

One Level of Abstractoin per Function

practice recommended in Clean Code by Robert C. Martin: The three functions inside this method are on the same level of abstraction.
However, what doesn't seem well designed to me is that calculateTaxReturnLimited(taxReturn) is always called and thus always produces a taxReturnLimited -- even if the tax return is not to be limited (because it's smaller than the maximum amount)! Isn't this confusing?
Of course I could avoid this by not having a calculateTaxReturnLimited function at all and put it's code directly inside of the calculateTaxReturn, but that would vialote the One Level of Abstractoin per Function principle.
Renaming the function to something like limitTaxReturnIfNecessary doesn't seem good to me either, having multiple ...IfNecessary functions seems like a clutter and code smell to me.
Is this a trade-off? How can it be resolved best to follow best practices?
You don't need to write ...ifNecessary if you just describe the property you want to have in the return value, and then you just know that after calling it, it has that property. You want the return amount to be clamped so it is less than or equal to the maximum amount. It doesn't matter that it might not change it, but it DOES matter to the business logic that it has been applied (i.e. checked). The actual name isn't that important in this case because I think I'd drop it anyway, as per below.
First, I just rewrote your code to use a member variable instead of being static, and without all the intermediate variables:
public class TaxReturn {

    private static final float MAXIMUM_RETURN_AMOUNT= 1000f;

    private final float income;

    public TaxReturn(float income) {
        this.income = income;
    }

    public float returnAmount() {
        return clampReturnAmount(base() + addition());
    }

    private float base() {
        return income * 0.5f; // More complex calculation here
    }

    private float addition() {
        return base() * 0.3f; // More complex calculation here
    }

    private static float clampReturnAmount(float returnAmount) {
        return returnAmount &gt; MAXIMUM_RETURN_AMOUNT ? MAXIMUM_RETURN_AMOUNT
                : returnAmount;
    }

}

But this clampReturnAmount function is just Math.min by a different name. Using Math.min to enforce a limit is common enough to be well understood why we're calling it, especially if we're naming the second argument something like argument MAXIMUM_RETURN_AMOUNT. So just:
public class TaxReturn {

    private static final float MAXIMUM_RETURN_AMOUNT = 1000f;

    private final float income;

    public TaxReturn(float income) {
        this.income = income;
    }

    public float returnAmount() {
        return Math.min(base() + addition(), MAXIMUM_RETURN_AMOUNT);
    }

    private float base() {
        return income * 0.5f; // More complex calculation here
    }

    private float addition() {
        return base() * 0.3f; // More complex calculation here
    }

}