In Java, how can I return two different types based on an argument?

Say that I have a method like this:

public AbstractContractApplication acceptOffer(AcceptedOfferDto dto)
{
    // various application stuff
    Contract contract; // deeply integrated into the above code
    return processedApplication;  // also deeply integrated into the above code 
}

I would like to refactor my method to sometimes return contract instead of processedApplication based on an argument provided in the AcceptedOfferDto. Ideally something like this:

if (AcceptedOfferDto.getReturnConfig() == 1){
return contract;
}

else {
return processedApplication; 
}

Is there a clean way to do this which does not involve copy and pasting the bulk of the code in the function or refactoring a large block of extremely important business logic?

The current line of thinking is to create a class that contains instances of both objects and just select the correct value from that. What other options might be available?

Supposing that Contract and AbstractContractApplication have nothing useful in common to rely on polimorphism and you can't refactor too much things, you could use this:

public interface EitherOne<A, B> {
    public default boolean isA() { return false; }
    public default boolean isB() { return false; }
    public default A getA() { throw new IllegalStateException(); }
    public default B getB() { throw new IllegalStateException(); }

    public static <A, B> EitherOne<A, B> a(A a) {
        return new EitherOne<>() {
            @Override public boolean isA() { return true; }
            @Override public boolean getA() { return a; }
        };
    }

    public static <A, B> EitherOne<A, B> b(B b) {
        return new EitherOne<>() {
            @Override public boolean isB() { return true; }
            @Override public boolean getB() { return b; }
        };
    }
}

I really don't recommend anyone using this. It should be used only as a quick and dirty escape hatch hack for complicated situations.

Then, you can try this:

public EitherOne<Contract, AbstractContractApplication> acceptOffer(AcceptedOfferDto dto) {
    // various application stuff
    AbstractContractApplication processedApplication = ...;
    Contract contract = ...; // deeply integrated into the above code
    if (AcceptedOfferDto.getReturnConfig() == 1) return EitherOne.a(contract);
    return EitherOne.b(processedApplication);  // also deeply integrated into the above code 
}

Use Polymorphism.
The type of contract (Contract) and processedApplication (?) must be subtypes of AbstractContractApplication.