实例变量可以在类的底部声明吗？

Question

I have a question when I saw "Instance variables can be declared in class level before or after use." in the site java_variable_types

I don't understand what is the class level and the meanning of this sequense.

Answer 1

I think they mean that this is legal:

 public class Test {
    private int someValue;

    public int myMethod() {
        return someValue + anotherValue;
    }

    private int anotherValue;
 }

(And it is!)

However, I think it is a mistake for the site to describe this as "[i]nstance variables can be declared in class level before or after use" .

1. The phrase "declared in class level" is bad English grammar.

2. The phrase "in class level" is ambiguous. It could mean declared in the body of a class. However, it could also mean declared as "class-level" (ie static ) variables. (That is contradictory, and incorrect, but ...)

3. The phrase "before or after use" is ambiguous. It could mean before or after in the source code file. It could also mean in before or after in the temporal sense. (That would be incorrect. At runtime, all of an object's instance variables are declared and initialized before the code in a method or constructor body is executed.)

---

While what they are trying to say (I think) in that sentence is correct, they have expressed themselves poorly, and it is clearly causing confusion for some readers.

Answer 2

Instance variable val is declared in line #2( please note the marking) but referenced even before in line #1. You can remove comment from line #3 and comment line #2. Then also it will work.

It means variable val using in line #1 even before declare in case if line#2 consider using after if you consider line#3.

public class prog{
     //private  int val; //line# 3
      public  int getVal()
       { 
          return val;//line# 1
       }
        private  int val; //line# 2
        prog()
        {
           val=0;
        }
        public static void main( String [] args)
        {
            prog obj= new prog();
            System.out.println("val:"+obj.getVal());
        }
    }

Answer 3

While your reference does a good job of explaining it, I'll add some details for completeness.

---

An instance variable...

• is declared at the class level
• can have any visibility that is necessary ( public , protected , private , or no modifier to signify package-private)
• will receive an initial value after instantiation (that is, you don't have to instantiate the field with a value...but if you don't instantiate a reference value, you may run into a NullPointerException )

The phrase "before or after use" doesn't make much sense, but let's illustrate a scenario:

public class Foo {
    private String word;

    public void printTheWord() {
        System.out.println(word);
    }
}

word hasn't been instantiated, but we can use it since it's received an initial value of null . This means that we won't get the value we want, but it will compile.

Contrast this with a local variable. The below code won't compile because word hasn't been instantiated.

public class Foo {
    public void printTheWord() {
        String word;
        System.out.println(word);
    }
}

Answer 4

The phrase "before or after use." would mean that the instance variable, which is applicable to the class as a whole ,unlike local variable which is restricted only inside of that method.

It can be declared or initialized at the start of the class,which is generally the most likely way. Other , inside of the class, it can be declared , after the call of the method using it.

Please find the below code snippet to understand the phrase:

public class InstanceVariable {

    //declared before
    int foo=4;
    public void testInstanceVariableUse(){
        System.out.println("The total value of the instance variable is "+ (foo+boo));
    }
    //declared after        
    int boo=5;
}


class TestInstanceVariable{
    public static void main(String[] args){
        InstanceVariable instanceVar = new InstanceVariable();
        instanceVar.testInstanceVariableUse();
    }
}

Output: The total value of the instance variable is 9