Just playing around with interfaces and I have a question about something which I can’t really understand.
The following code doesn’t run, which is the behaviour I expect as the interface method requires the method to work for any object and the implemented method has the signature changed to only allow string objects.
interface I {
public void doSomething(Object x);
}
class MyType implements I {
public void doSomething(String x) {
System.out.println(x);
}
}
However, using the following block of code, I was shocked to see that it did work. I thought it would not work as we are expecting to return an object and the implemented method will only return a string object. Why does this work and what is the difference between the two principles here of passed parameters and return types?
interface I {
public Object doSomething(String x);
}
class MyType implements I {
public String doSomething(String x) {
System.out.println(x);
return(x);
}
}
has to return something. Anything, in fact, so long as it is some type of object. So if you implement
that’s fine, because it does in fact return an Object. The fact that the object it will return will always be a String is no big deal.
The reason the first example doesn’t work, is because accepting only strings is more limiting than accepting any object. But returning only strings is fine.
For an analogy, let’s say you got a contract to paint a building, and you’re gonna hire some employees to help you out. The contract requires that you hire any painter that applies, regardless of how tall they are, but doesn’t specify what color paint to use. If you only hired painters over 6 ft tall (that’s the input, accepting only String instead of all Object), you’d be violating the contract. But choosing to paint with only blue paint (returning only strings) is just fine, because the contract didn’t specify color, only that you must paint the building.