Overloading an Overridden method in Java

I have a class B that implements interface A such that:

public interface A {

    Map<String, Object> doStuff(Integer param1, Integer Param2);
}

public class B implements A {

    public Map<String, Object> doStuff(Integer param1, Integer param2) {
        return doStuff(param1, param2, newParam3);
    }

    public Map<String, Object> doStuff(Integer param1, Integer Param2, boolean param3) {
        if (param3)
            doSomething;
        return doneStuff;
    }
}

But when I try to access the overloaded but not overridden method I get compile time errors. Shouldn't this be perfectly fine?

There are two entirely separated steps in java method invocation.

Step 1 is: Turn the method invocation (in your source code) into the fully qualified method ID. This occurs entirely at compile time.

Step 2 is: Now that we have a fully qualified method ID, find the actual implementation for this ID by doing a dynamic lookup, starting at the object's actual instance type (x.getClass()), and going upwards in the hierarchy until you find an implementation. This occurs entirely at runtime.

A fully qualified method ID includes the package, class, method name, parameter types and return type.

So, in your class B you have 2 different method IDs. And different method IDs are different methods; the fact that the name is the same is irrelevant.

In other words, this:

A x = new B();
x.doStuff(param1, param2);

is stored as an INVOKEVIRTUAL/INVOKEINTERFACE to method com.foo.pkg.A::doStuff(Ljava/lang/Integer;L/java/lang/Integer;)Ljava/util/Map;. That's literally in the class file; have a look at the output of javap or actually go open that thing with a hex editor and you'll find that string in there, at least, starting at doStuff.

Then at runtime only, that 'INVOKEINTERFACE com.foo.pkg.A doStuff(Ljava/lang/Integer;L/java/lang/Integer;)Ljava/util/Mapbytecode instruction ends up checking the type of the object that yourxvariable is pointing to, figures out it's an instance ofcom.foo.pkg.B`, and will then actually call B's implementation of this method to do the job.

Your second doStuff method has method ID B doStuff(Ljava/lang/Integer;Ljava/lang/Integer;Z)Ljava/util/Map; - note how this is just a completely different method (this one has a Z in it).

Thus, this:

A x = new B();
x.doStuff(1, 2, true);

is a compilation error: The A interface doesn't have that method at all.