Sono stato attraverso this question on legality of forward references ma non chiaro su cosa si intende per forward references in linguaggio Java. Qualcuno può spiegare con l'aiuto di un esempio?Che cos'è un riferimento avanzato in Java?
Si tratta in particolare di un errore di compilazione. E riguarda l'ordine delle dichiarazioni delle variabili di classe. Usiamo un po 'di codice per scopi illustrativi:
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();
}
Come si può vedere, Java consente di fare riferimento a un classe variabile in un metodo classe, anche se la dichiarazione della variabile viene dopo il metodo . Questo è un esempio di un riferimento forward (legale) e il supporto per questo è incorporato nel compilatore Java.
Quello che non può fare, però, è dichiarare una variabile di classe 'A' che dipende da un'altra classe variabile 'b' che non è stato ancora dichiarato. Le dichiarazioni delle variabili di classe dipendenti devono apparire in ordine inverso rispetto alla loro dipendenza.
Su una tangente, la maggior parte, se non tutti, gli IDE ti avvertiranno se il tuo codice contiene errori di riferimento illegali.
I riferimenti di inoltro non validi sono compresi in section 8.3.2.3 di JLS.
In termini semplici significa fare riferimento (accesso a una variabile, chiamata a una funzione) che si trova più in basso nel file di codice.
static int x=getY();
static int y=5;
static int getY() { return y; }
è fondamentalmente solo l'ordine in cui le cose vengono letti dal compilatore, se avete
int c = 3
int a = b;
int b = 5;
il compilatore leggere da cima a fondo, in modo da esso se la prima linea, che dichiara una variabile ' c ', e lo assegna a 3, e va bene, allora incontrerà la seconda riga, che dichiara una variabile' a ', e quindi prova ad assegnarla a' b '.
Ma ora il compilatore ha un problema: che cos'è questa cosa "b"? Ha solo imparato a conoscere "c", e solo recentemente "a", ma non ha alcuna conoscenza di ciò che si chiama "b", dal momento che al compilatore non è stato ancora dichiarato. Quindi, dato che il compilatore non può gestire tutta la confusione, si ferma e ti lascia capire cosa hai fatto per farlo arrabbiare.
Quindi, la parte di riferimento avanti sarebbe un riferimento a qualcosa che non esiste ancora. In avanti nel tempo forse ..
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 {
}
********* riferimento CASE - 1 *********
avanti riferimento variabile di istanza non è consentita come compilatore non è certo del tipo di valore che stiamo facendo riferimento o potrebbe anche essere possibile che nessuna variabile di questo tipo esista.
Consideriamo un esempio: -
int a = b;
boolean b = false;
Se riferimento in avanti è consentito in caso di cui sopra, allora si potrebbe creare un caos.
int a = b; // What is b? is it a primitive variable or a value or a object reference
nell'esempio precedente ho deciso di non dichiarare b e ora se tale trasferimento è stato permesso da Java, allora sarà un incubo.
********** consultare CASE - 2 *********
variabili statiche vengono caricati prima variabili istanza e quindi in avanti riferimento variabili statiche e li assegna alla variabile istanza è perfettamente a posto