Ich war durch this question on legality of forward references, aber nicht klar, was mit forward references in Java Sprache gemeint ist. Kann jemand bitte anhand eines Beispiels erklären?Was ist eine Vorwärtsreferenz in Java?
Dies ist speziell ein Kompilierungsfehler. Und alles über das Ordnen von Klassenvariablen-Deklarationen. Lassen Sie uns einige Code zu illustrativen Zwecken verwenden:
public class ForwardReference {
public ForwardReference() {
super();
}
public ForwardReference echoReference() {
return this;
}
public void testLegalForwardReference() {
// Illustration: Legal
this.x = 5;
}
private int x = 0;
// Illustration: Illegal
private ForwardReference b = a.reference();
private ForwardReference a = new ForwardReference();
}
Wie Sie sehen können, Java können Sie eine Klassenvariable in einem Klassenmethode, auch wenn die Deklaration der Variablen nachreferenzieren kommt das Verfahren . Dies ist ein Beispiel für eine (legale) Vorwärtsreferenz, und Unterstützung dafür ist in den Java-Compiler integriert.
Was Sie nicht zwar tun, ist eine Klassenvariable deklarieren ‚a‘ das hängt von einer anderen Klasse Variable ‚b‘, die noch nicht erklärt wurde. Deklarationen abhängiger Klassenvariablen müssen in umgekehrter Reihenfolge ihrer Abhängigkeit angezeigt werden.
Auf einer Tangente, Most, wenn nicht alle IDEs warnen Sie, wenn Ihr Code ungültige Referenzfehler enthält.
Illegale Vorwärtsreferenzen sind in section 8.3.2.3 der JLS enthalten.
In einfachen Worten bedeutet es Referenzieren (Zugriff auf eine Variable, Aufruf einer Funktion), die weiter unten in der Codedatei ist.
static int x=getY();
static int y=5;
static int getY() { return y; }
Es ist im Grunde nur die Ordnung, die Dinge vom Compiler gelesen werden, wenn Sie
int c = 3
int a = b;
int b = 5;
der Compiler es von oben nach unten wird gelesen haben, so wird es sich die erste Zeile, die eine Variable erklärt ' c ', und weist es auf 3, und das ist in Ordnung, dann wird es die zweite Zeile, die eine Variable' a 'deklariert, und dann versucht, es zu' b 'zuweisen.
Aber jetzt hat der Compiler ein Problem: Was ist das 'b' Ding? Es hat nur noch von 'c' und erst kürzlich 'a' gelernt, aber es hat nichts, was 'b' genannt wird, da es für den Compiler noch nicht deklariert wurde. Also, da der Compiler nicht mit der ganzen Verwirrung umgehen kann, hört er auf und lässt Sie herausfinden, was Sie getan haben, um ihn zu verärgern.
Der Forward-Referenzteil wäre also ein Verweis auf etwas, das noch nicht existiert. vielleicht in der Zeit vorwärts ..
public class AnyCode {
void print() {
System.out.println("Value of j - " + j); // legal
System.out.println("Value of i - " + i); // legal
}
// CASE - 1
int k = i; // illegal
int i;
// CASE - 2
int l = j; // legal
static int m = j; // illegal
static int j;
// CASE - 3
A aObj = bObj; // illegal
B bObj = new B();
public static void main(String[] args) {
/*
Note :- here anyCode act as a local variable and get space on stack
whereas the object it is referring to is present on heap. And you
cannot forward reference a local variable.
*/
anyCode.print(); // 'Cannot find symbol' error
AnyCode anyCode = new AnyCode();
}
}
class A {
}
class B {
}
********* CASE Siehe - 1 *********
Vorwärts-Instanzvariable Referenzierung nicht als Compiler erlaubt ist, ist nicht sicher von der Art von Wert, auf den wir uns beziehen, oder es könnte sogar möglich sein, dass keine solche Variable existiert.
Betrachten wir ein Beispiel: -
int a = b;
boolean b = false;
Wenn vorwärts Referenzierung in obigen Fall erlaubt ist, dann könnte es ein Chaos schaffen.
int a = b; // What is b? is it a primitive variable or a value or a object reference
im obigen Beispiel ich nicht und jetzt zu erklären, b entschieden haben, wenn eine solche Zuordnung von Java erlaubt wurden, dann wird es ein Alptraum sein.
********** CASE Siehe - 2 *********
Statische Variablen geladen werden, bevor die Instanzvariablen und damit vorwärts Referenzierung statischen Variablen und diese Instanzvariable Zuweisen ist völlig in Ordnung