What's the equivalent of C's "static" keyword in Java?

Question

I want to know what could be the equivalent keyword in java which could perform same function as "Static keyword in C".. I want to do recursion in java, performing same function that a static keyword in C does...

Please help..

Solution 1

C has two entirely different uses of the static keyword, and C++ adds a third use:

// Use 1: declare a variable or function to be local to a given module
// At global scope:
static int global_var;
static void func();

In this case, the global variable global_var and the function void func() can only be accessed inside the file in which they are declared; they cannot be accessed by any other file.

// Use 2: declare a variable inside a function with global scope
void func(void)
{
    static int x;
}

In this case, the variable x is effectively a global variable, in that there is only one instance of it -- multiple calls to func() (including recursive calls) will always access the same variable.

// Use 3 (C++ only): declare a global variable with class scope
class Widget
{
public:
    static int var;
};

In this case, this declares the variable Widget::var as a global variable, but its scope is different. Outside of class member functions, it has to be named as Widget::var; inside class member functions, it can be named as just var. It can also be made protected or private to limit its scope even more.

Now, what are the analogs of these 3 uses in Java?

Case 1 has no direct analog; the closest is declaring objects with package scope, which is done by omitting a public, protected, or private:

class Widget  // Declare a class with package scope
{
    int x;  // Declare a member variable with package scope
    void func() {}  // Declare a member function with package scope
}

In this case, the declared objects are only accessible by classes within the same package; they are not accessible to other packages.

Case 2 also does not have an analog in Java. The closest you can get is by declaring a global variable (that is, a static class variable, since Java doesn't have true global variables in the strictest sense):

class Widget
{
    private static int func_x;
    public static void func()
    {
        // use func_x here in place of 'static int x' in the C example
    }
}

Case 3 is the only case that has a direct analog in Java. In this case, the static keyword serves exactly the same purpose.

Solution 2

The "static" keyword in C actually serves two functions depending on where it's used. Those functions are visibility and duration (these are my terms based on quite a bit of teaching, the standard, if you're interested in that level of detail, uses different terms which I often find confuses new students, hence my reticence in using them).

• When used at file level, it marks an item (variable or function) as non-exported so that a linker cannot see it. This is static as in visibility, duration is the same as the program (i.e., until the program exits). This is useful for encapsulating the item within a single compilation unit (a source file, in its simplest definition). The item is available to the whole compilation unit (assuming it's declared before use).
• When used within a function, it controls duration (visibility is limited to within the function). In this case, the item is also created once and endures until the program exits. Non-static variables within a function are created and destroyed on function entry and exit.

I gather what you're after is the first type, basically a global variable since I can't immediately see much of a use for the other variant in recursion..

It can't be done since, in Java, everything must belong to a class. The workaround is to create a class holding the "globals" and either:

• pass that object around so you can reference its members; or
• construct a singleton item so you can access its members.

Solution 3

Java doesn't have global variables, so there isn't a direct equivalent. However, there's a static keyword in Java that shares the state of a field with all instances of a class, which is a good approximation to what you're describing.

I want to do recursion in java, performing same function that a static keyword in C does...

However, if you're looking to do recursion, are you sure that static variables are what you need? Any special state needed for a recursive function call is almost always passed back to itself, not maintained separately.

Solution 4

The concept of static in Java doesn't adhere with the concept of static in C. However, there is a static keyword in Java as well. But its more like a static in C++ then C, with some differences.

View more solutions

Comments

[FL4SOF]

What John mentioned seems absolutely true, I doubt the use of static variable in recursive function. It would be clean if you can write the recursive function as well ...

[John Feminella]

No problem. If you have another question about recursive functions, do go ahead and ask that one too.

[JAB]

Wait, I thought use #2 also existed in Java, in that declaring a variable as static will allow its value to persist between calls to the function. It's been so long since I've used Java that I could be wrong, though.

[stillanoob]

Bunch of unnecessary info dump. The OP doesn't even mention C++ and they are pretty clear about which variant of static in C they need. All that's required was Case 2 of this answer. Keep it to the point.