Suppose I have:
public class OuterClass() {
public class InnerClass {
public void someMethod(int x) {
someMethod(x);
}
}
public void someMethod(int x) {
System.out.println(x);
}
}
How do I resolve the ambiguity between the someMethod()
of the outer class and the someMethod()
of the inner class?
You can refer to the outer with OuterClass.this
, or call the method with OuterClass.this.method()
.
However, as a point of design, sharing the name is confusing, to say the least. It might be reasonable if the inner class represented an extension or, say, a concrete implementation of an abstract method, but that would be clearer by calling super.method. Calling a super method directly, (as it looks like you're intending to do?), is confusing.
Scope it to the outer class with OuterClass.this.someMethod()
:
public class OuterClass {
public class InnerClass {
public void someMethod(int x) {
OuterClass.this.someMethod(x);
}
}
public void someMethod(int x) {
System.out.println(x);
}
}
Renaming ambiguity is a good practice. Especially if you apply it in the upward and backward architecture.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With