In C#, if you have two base interfaces with the same method (say, F()) you can use explicit implementation to perform different impl. for F(). This alloes you to differently treat the object, corresponding to the current point of view: as IMyInterface1 or IMyInterface2. Is this possible in Java?
Add a comment |
4 Answers
No, there's nothing like C#'s explicit interface implementation in Java.
On the plus side, Java has covariant return types, so if you want to provide a more strongly typed implementation than the interface specifies, that's okay. For instance, this is fine:
interface Foo { Object getBar(); } public class Test implements Foo { @Override public String getBar() { return "hi"; } } C# wouldn't allow that (prior to C# 9, which now supports covariant return types) - and one of the ways around it is typically to implement the interface explicitly and then have a more specific public method (usually called by the interface implementation).
3 Comments
Kir_Antipov
P.S. - "C# wouldn't allow that" is not the case anymore, C# 9.0 supports covariant return types :)
Jon Skeet
@Kir_Antipov: Yes, answers from 12 years ago will often be outdated :)
Kir_Antipov
Yeah, I know xD On the contrary, Java-part of the answer is still valid, so I thought it's worth to mention the fact that at least one of the languages is actually developing :)
You can achieve similar effect using the mechanism of anonymous interface implementation in Java.
See example:
interface Foo { void f(); } interface Bar { void f(); } public class Test { private String foo = "foo", bar = "bar"; Foo getFoo() { return new Foo() { @Override public void f() { System.out.println(foo); } }; } Bar getBar() { return new Bar() { @Override public void f() { System.out.println(bar); } }; } public static void main(String... args) { Test test = new Test(); test.getFoo().f(); test.getBar().f(); } } 
Comments
You can only do this if the methods are overloaded. If you have two method which are expected to do different things, they should have different names IMHO.
Comments
No and it should never be present in Java. It's just another bone to throw at people who can't be bothered with good design.
Explicit implementation of an interface should never be needed or used. There are better ways to solver the problem that this tries to solve.
9 Comments
Ben Voigt
Do you also believe that private inheritance is only for "people who can't be bothered with good design"? That's another useful OOP capability missing from Java.
eaglestorm
It will never be in Java for the same reason that delegates will never be in Java.. google it. There is a good article about why delegates where never done in Java and this is similar. It's bad because of what it allows you to do not the good stuff you can do with it. Something Microsoft and it's ecosystem don't get.
Natalie Klestrup Röijezon
@ealgestorm, you do realize that even Swing "abuses" objects to make them behave like delegates, right? Also, I do find it a bit amusing that almost all of your questions are related to .NET.
stackh34p
@eaglestorm, no offence, but I have a little experience with java now, being a .NET developer, and I find anonymous interface implementations very close to what I used to do with delegates. I event believe anonymous interfaces are more powerful in some cases, so, IMHO I do not agree that delegates are bad practice, and that they are not present in Java.
stackh34p
As for explicit interfaces - in complex scenarios you might happen to conform to the APIs of two distinct systems, which happen to define interfaces with matching methods, and still must have different implementations. The burden of complications obviously comes to the consuming code.
|