What is called a forward reference in Java?

Question

I have been through this question on legality of forward references but not clear as to what is meant by forward references in Java language . Can someone ple

Answer 1

This is specifically a compilation error. And its all about ordering of class variable declarations. Let's use some code for illustrative purposes:

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();
}

As you can see, Java allows you to reference a class variable in a class method, even if the declaration of the variable comes after the method. This is an example of a (legal) forward reference, and support for this is built into the Java compiler.

What you cannot do though, is declare a class variable 'a' that depends on another class variable 'b' that has not been declared yet. Dependent class variable declarations must appear in reverse order of their dependency.

On a tangent, Most, if not all IDE's will warn you if your code contains illegal reference errors.

Illegal forward references are covered in section 8.3.2.3 of the JLS.

Answer 2

It's basically just the order that things are read by the compiler, if you have

int c = 3
int a = b;
int b = 5;

the compiler will read it from top to bottom, so it will se the first line, which declares a variable 'c', and assigns it to 3, and that is fine, then it will encounter the second line, which declares a variable 'a', and then tries to assign it to 'b'.

But now, the compiler has a problem: What is this 'b' thing? It has only yet learned about 'c', and just recently 'a', but it has no knowledge anything called 'b', since to the compiler, it has not yet been declared. So then, since the compiler can't handle all the confusion, it stops, and leaves you to figure what you have done to anger it.

So, the forward reference part would be a reference to something that does not yet exist. Forward in time perhaps..

Answer 3

In simple terms it means referencing (accessing a variable, calling a function) that is further down in the code file.

   static int x=getY();
   static int y=5;
   static int getY() { return y; }

• x's value is set to the result of getY()
• getY() is called before y's value is set to 5
• x's value is therefore 0 (default integer)
• y's value is 5

Answer 4

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 {

}

*********Refer CASE - 1*********

Forward referencing instance variable is not allowed as compiler is not sure of the type of value we are forward referencing or it might even be possible that no such variable exist.

Consider an example :-

int a = b;
boolean b = false;

If forward referencing is allowed in above case then it might create a havoc.

int a = b; // What is b? is it a primitive variable or a value or a object reference

in the above example i have decided not to declare b and now if such assignment were allowed by java, then it will be a nightmare.

**********Refer CASE - 2*********

Static variables are loaded before instance variables and hence forward referencing static variables and assigning them to instance variable is perfectly fine