Local static variables and Java

Question

I was wondering how to achieve the local static variable in java. I know Java wount support it. But what is the better way to achieve the same? I donot want the other methods in my class to access the variable, but it should retain the value across the invocations of the method.

Can somebody please let me know.

Answer 1

I don't think there is any way to achieve this. Java does not support 'local static' a la C, and there is no way to retrofit this while still keeping your sourcecode "real Java"¹.

I donot want the other methods in my class to access the variable, but it should retain the value across the invocations of the method.

The best thing would be to make it an ordinary (private) static, and then just don't access it from other methods. The last bit should be easy ... 'cos you are writing the class.

---

^{1 - I suppose you could hack something together that involves preprocessing your code, but that will make all sorts of other things unpleasant. My advice is don't go there: it is not worth the pain.}

Answer 2

Rather than trying to actually protect the variable, making the code more obscure and complicated, consider logical protection by comment and placement. I declare normal fields at the start of the class, but a field that should only be accessed from one method just before that method. Include a comment saying it should only be used in the one method:

// i should be used only in f
private int i;
/**
* Documentation for f().
*/
public void f(){
    System.out.println(i++);
}

Answer 3

What you want is the ability to constraint intermediate computation results within the relevant method itself. To achieve this, you can refer to the following code example. Suppose you want to maintain a static variable i across multiple calls of m(). Instead of having such a static variable, which is not feasible for Java, you can encapsulate variable i into a field of a class A visible only to m(), create a method f(), and move all your code for m() into f(). You can copy, compile, and run the following code, and see how it works.

public class S {
  public void m() {
    class A {
      int i;

      void f() {
        System.out.println(i++);
      }
    }
    A a = new A();
    a.f();
    a.f();
    a.f();
  }
  public static void main(String[] args) {
    S s = new S();
    s.m();
  }
}

Answer 4

In theory, yes - but not in conventional manners.

What I would do to create this:

1. Create that Object in a totally different class, under the private modifier, with no ability to be accessed directly.

2. Use a debugging tool, such as the JDI to find that variable in the other class, get it's ObjectReference and manipulate directly or create a new variable which references to that object, and use that variable, which references to the object, in your method.

This is quite complicated, as using the JDI is tough, and you would need to run your program on 2 processes. If you want to do this, I suggest looking into the JDI, but my honest answer would be to look for another solution.

Answer 5

Based on dacongy's idea of using a method local class I created a simple solution:

public class Main {
   public static String m() {
      class Statics {
         static String staticString;
      }
      if (Statics.staticString == null)
         Statics.staticString = "My lazy static method local variable";
      return Statics.staticString;
   }

}