Ausgangssituation:
Ich habe zwei Klassen, von denen die eine (Klasse A1) die andere (Klasse B1) kennt.
private final B1 b;
public A1(B1 b) {
this.b = b;
}
public void doSomething() {
b.doSomething();
}
public static void main(String[] args) {
A1 a = new A1(new B1());
a.doSomething();
}
}```
und
```public class B1 {
public void doSomething() {
System.out.println("b1");
}
}```
In diesem Fall ist alles recht einfach. Stehe ich in Eclipse in der Klasse `A1` in Methode `doSoething()` auf dem Aufruf der Methode `b.doSomething()`, so kann ich einfach mit **F3** zu der entsprechenden Methode in der Klasse `B1` springen.
[HR][/HR]
Situation mit Interfaces:
Damit die Klasse `A1` aber nicht ganz abhängig von Klasse `B1` ist, verwende ich gerne Interfaces, die dann nur die Methoden enthalten, die die Klasse `A1` kennen muss.
Jetzt stellt sich die Situation wie folgt dar:
```public class A2 {
private final BForA b;
public A2(BForA b) {
this.b = b;
}
public void doSomething() {
b.doSomething();
}
public static void main(String[] args) {
A2 a = new A2(new B2());
a.doSomething();
}
}
@Override
public void doSomething() {
System.out.println("b2");
}
}
und
void doSomething();
}```
Stehe ich nun in Eclipse in der Klasse `A2` in Methode `doSoething()` auf dem Aufruf der Methode `b.doSomething()`, so komme ich mit **F3** nur noch zu der entsprechenden Methode im Interface `BForA`. Das ist auch klar, es kann ja beliebig viele Klassen geben, die das Interface implementieren. Trotzdem ist das bei der täglichen Arbeit extrem lästig, nicht direkt zu der "echten" Methode in der Klasse `B2` zu gelangen.
Meine Frage lautet: **Gibt es irgendeinen Weg, zu den Implementierungen einer Methode eines Interfaces zu springen (mit irgendeiner Tastenkombination), oder muss ich wählen zwischen schönerer Trennung und Komfort bei der Entwicklung?**
