Forem: Vivek T S

Why local variables need to be initialized in Java?

Vivek T S — Sat, 11 Jul 2020 16:21:23 +0000

Variables in Java can be categorized into instance, static & local. In programming, it is always advisable to only declare and initialize a variable right before it's usage. If a value to intialize couldn't be identified, the need of the variable should be re-evaluated. This is to avoid unnecessary memory usage and enhance code readability because of the reduced scope. In Java, out of these 3 variables, only one is required to be initialized before it's usage or else compiler would throw an error. In other words, local variables don't have default values. Below is a table of different types and their default values. Here, reference types include the wrappers of the primitive types.

Type	Default Value
`byte`, `short`, `int`, `long`	`0`
`float`, `double`	`0.0`
`char`	`\u0000`
`boolean`	`false`
Reference Type	`null`

Before looking into this behavior of the compiler, it is necessary to understand what these variables are and how they differ from each other.

Static Variables

Static variables (or Class variables) are global variables that are available to all programs on the running JVM instance. These are declared on classes or interface with the keyword static. They can be accessed using dot . operator using the class/interface name. Below are their features,

Loaded into memory when the class gets loaded even before an object of the class is created
Don't participate in garbage collection

These variables can be left uninitialized after declaration and they're assigned with their respective default value. If a static variable is declared final, it wouldn't take the default value. It must be initialized either during declaration or it can be initialized in a special block in class called Static Initializer. A non-final static variable can be used/modified anywhere.

Instance Variables

Java is an object oriented programming language. Everything in java is enclosed within a class. A class has properties and can perform actions. The properties are called Instance Variables. An instance variable is unique for every object created. They can be accessed using dot . operator using the object name. Below are their features,

Participate in garbage collection once they go out of scope
Scope is within the object and cannot be accessed outside of it.
Can only be accessed/modified inside a non-static method

These variables can also be left uninitialized similar to static variables and they're auto initialized to the default values. If an instance variable is declared final, it must be either initialized during declaration or on the constructor or on a special block called Instance Initializer.

Local Variables

Local variables are the ones that are declared inside a method. They must be initialized to some value failing which compiler would throw an error. Scope of a local variable is within the method and it can't accessed outside of it. These variables live on the stack and get popped once the method call ends. For reference types, the object it refers to lives on the heap whereas the type on the stack.

Below code example shows the behaviour of static, local and instance variable.

public class Variable{

    public static String staticVariable;
    private final int instanceVariable;
    public boolean defaultInstanceVariable;

    // Static Initializer Block
    static {  
        System.out.println("Static Initializer Block");
        staticVariable= "Static Variable Example";
        System.out.printf("staticVariable After Initialization = %s\n",staticVariable);
    }

    // Instance Initializer Block
    { 
        System.out.println("Instance Initializer Block");
        instanceVariable= 1;
        System.out.printf("instanceVariable After Initialization = %d\n",instanceVariable);
    }

    // Constructor Block
    public Variable(){
        System.out.println("Constructor Block");
            System.out.printf("defaultInstanceVariable = %b\n",defaultInstanceVariable);
    }   

    // Static Method
    public static void staticMethod(){
      System.out.println("Static Method");
  }

    // Instance Method
    public void instanceMethod(){
        char localVariable = '!';
        System.out.println("Instance Method");
    System.out.printf("localVariable After Initialization = %c\n",localVariable );
    }
}


//Call 1:
new Variable().instanceMethod();


//Output 1:
/**
Static Initializer Block
staticVariable After Initialization = Static Variable Example
Instance Initializer Block
instanceVariable After Initialization = 1
Constructor Block
Instance Method
localVariable After Initialization = !
**/

//Call 2:
Variable.staticMethod();

//Output 2:
/**
Static Initializer Block
staticVariable After Initialization = Static Variable Example
Static Method
**/

Why only local variables?

In Java, only local variables have a very limited (method) scope and lifetime. And they have a predictable execution route that the compiler understands. These variables don't go beyond the method. Compiler can identify where the variable is declared and can very efficiently instruct a programmer to initialize a variable before using it. When a variable is used without initialization, there's a possibility for a potential bug in the program. Also, initializing every variable with a default value takes a hit on the performance. It is actually an assist from the compiler to make the program better. The actual question should be, why not the compiler helps in not using a static/instance variable before initialization?

The answer to that question lies in the complexity or the more number of ways in accessing those variables. When it comes to a method, the execution path is very clear. The compiler can very well trace the route from using the variable back to its declaration. There's no unique flow that the compiler can identify for a static/instance variable to be set with a value. The initialization can happen under a different program altogether and the usage can be of some place else. Since there's no definite path and the path to map is not a narrow line, they're provided with default values. A default value is definitely better than an unsure/random value. If those variables are not initialized, they can have any value on them and that can be from irrelevant data to sensitive data.

🔥

Does Java pass only by value?

Vivek T S — Fri, 19 Jun 2020 18:59:14 +0000

When it comes to Java in calling a method and passing arguments as primitives, there’s no doubt that it follows the pass by value model. Trouble in understanding comes when dealing with Objects. Since reference types store the address of the object, when reference types are passed as arguments, it’s the memory address of the object that is passed and any change to the object’s nature (instance variables) inside the called method reflects in the caller.

This raises the question, Does Java pass by reference when it comes to reference types?

Variables
Before getting into the discussion of pass by value/reference, let’s understand about the kind of variables apart from the standard variable that were available to programmers in the languages that predate Java.

Pointers — In C/C++, there are special type of variables that stored the address of any type of variable called Pointers. Pointers are usually assigned with address of another variable or they're made to point to nothing (NULL pointer). Pointers are the reference types in Java.

Reference Variables — In C++, another special type of variable that acts as an alias/alternative name to the original variable exists called Reference Variable. So, any change to the original variable or it’s aliases affects everywhere. Reference variables are declared using & operator and must be initialized during creation as it doesn’t accept NULL.

Look at below code example in C++. Note that * and & operators have different functionality in a declaration and an expression.

#include <iostream>
using namespace std;

int main(){
    int var = 45;                //Simple  variable  , stores 45 as its value
    int* varPtr = &var;          //Pointer variable  , stores the address of var as its value
    int** varPtrPtr = &varPtr;   //Pointer variable  , double pointer, stores the address of varPtr as its value
    int& varRef = var;           //Reference variable, acts as a reference to var
    int* varRefPtr = &varRef;    //Pointer variable  , stores the address of varRef as its value  

    cout << "\nvar       : " << var;
    cout << "\nvarPtr    : " << varPtr;
    cout << "\nvarPtrPtr : " << varPtrPtr;
    cout << "\nvarRef    : " << varRef;
    cout << "\nvarRefPtr : " << varRefPtr;
}


/* *
 * Sample Output
 * --------------------
 * var       : 45
 * varPtr    : 0x61fdb4
 * varPtrPtr : 0x61fda8
 * varRef    : 45
 * varRefPtr : 0x61fdb4
 * 
 * */

From the above output, we can see that varPtr stored the address of var whereas varRef stored the value of var. Similarly, the address of varRef i.e., varRefPtr is identical to the address of var i.e., varPtr. This proves that the pointers and reference variables are different conceptually.

Pass by value vs Pass by reference in C++
Now that we understood different types of variables available, let’s see a sample swap program in C++ employing these different variables. Here is summary of various functions in the program.

swapByValue — This function takes in two simple variables and swaps using a temp variable.
swapByPointer — This function takes in two pointer variables and attempts swapping. Note that here pointer dereferencing isn’t used to show the difference between pointer and reference variables.
swapByReference — This function takes in two reference variables and swaps them.
swapByPointerDereference — This function takes in two pointer variables and dereferences it using the address.

#include <iostream>
using namespace std;

void swapByPointerDereference(int* a4, int* b4){
    cout << "\nEnters : a4 value is " <<a4 <<", b4 value is " << b4;
    cout << "\nEnters : a4 address is " << &a4 <<", b3 address is " << &b4;
    int temp = *a4;
    *a4 = *b4;
    *b4 = temp;
    cout << "\nExits  : a4 value is " <<a4 <<", b4 value is " << b4;
    cout << "\nExits  : a4 address is " << &a4 <<", b4 address is " << &b4 << "\n";
}

void swapByReference(int& a3, int& b3){
    cout << "\nEnters : a3 value is " <<a3 <<", b3 value is " << b3;
    cout << "\nEnters : a3 address is " << &a3 <<", b3 address is " << &b3;
    int temp = a3;
    a3 = b3;
    b3 = temp;
    cout << "\nExits  : a3 value is " <<a3 <<", b3 value is " << b3;
    cout << "\nExits  : a3 address is " << &a3 <<", b3 address is " << &b3 << "\n";
}

void swapByValue(int a1, int b1){
    cout << "\nEnters : a1 value is " <<a1 <<", b1 value is " << b1;
    cout << "\nEnters : a1 address is " << &a1 <<", b1 address is " << &b1;
    int temp = a1;
    a1 = b1;
    b1 = temp;
    cout << "\nExits  : a1 value is " <<a1 <<", b1 value is " << b1;
    cout << "\nExits  : a1 address is " << &a1 <<", b1 address is " << &b1 << "\n";
}

void swapByPointer(int* a2, int* b2){
    cout << "\nEnters : a2 value is " <<a2 <<", b2 value is " << b2;
    cout << "\nEnters : a2 address is " << &a2 <<", b2 address is " << &b2;
    int* temp = a2;
    a2 = b2;
    b2 = temp;
    cout << "\nExits  : a2 value is " <<a2 <<", b2 value is " << b2;
    cout << "\nExits  : a2 address is " << &a2 <<", b2 address is " << &b2 << "\n";
}

int main(){
    int a1 = 45;
    int b1 = 65;
    int a2 = 15;
    int b2 = 35;
    int a3 = 25;
    int b3 = 55;
    int a4 = 75;
    int b4 = 95;

    cout << "\n*-----Swap By Value-----*";
    cout << "\nBefore : a1 value is " << a1 << ", b1 value is " << b1;
    cout << "\nBefore : a1 address is " << &a1 << ", b1 address is " << &b1;
    swapByValue(a1, b1);
    cout << "After  : a1 value is " << a1 << ", b1 value is " << b1 << "\n";
    cout << "After  : a1 address is " << &a1 << ", b1 address is " << &b1 << "\n";

    cout << "\n*-----Swap By Pointer-----*";
    cout << "\nBefore : a2 value is " << a2 << ", b2 value is " << b2;
    cout << "\nBefore : a2 address is " << &a2 << ", b2 address is " << &b2;
    swapByPointer(&a2, &b2);
    cout << "After  : a2 value is " << a2 << ", b2 value is " << b2 << "\n";
    cout << "After  : a2 address is " << &a2 << ", b2 address is " << &b2 << "\n";

    cout << "\n*-----Swap By Reference-----*";
    cout << "\nBefore : a3 value is " << a3 << ", b3 value is " << b3;
    cout << "\nBefore : a3 address is " << &a3 << ", b3 address is " << &b3;
    swapByReference(a3, b3);
    cout << "After  : a3 value is " << a3 << ", b3 value is " << b3 << "\n";
    cout << "After  : a3 address is " << &a3 << ", b3 address is " << &b3 << "\n";

    cout << "\n*-----Swap By Pointer Dereference-----*";
    cout << "\nBefore : a4 value is " << a4 << ", b4 value is " << b4;
    cout << "\nBefore : a4 address is " << &a4 << ", b4 address is " << &b4;
    swapByPointerDereference(&a4, &b4);
    cout << "After  : a4 value is " << a4 << ", b4 value is " << b4 << "\n";
    cout << "After  : a4 address is " << &a4 << ", b4 address is " << &b4 << "\n";

}


/* *
 * Sample Output
 * ---------------
 *
 * *-----Swap By Value-----*
 * Before : a1 value is 45, b1 value is 65
 * Before : a1 address is 0x61fe1c, b1 address is 0x61fe18
 * Enters : a1 value is 45, b1 value is 65
 * Enters : a1 address is 0x61fde0, b1 address is 0x61fde8
 * Exits  : a1 value is 65, b1 value is 45
 * Exits  : a1 address is 0x61fde0, b1 address is 0x61fde8
 * After  : a1 value is 45, b1 value is 65
 * After  : a1 address is 0x61fe1c, b1 address is 0x61fe18
 * 
 * *-----Swap By Pointer-----*
 * Before : a2 value is 15, b2 value is 35
 * Before : a2 address is 0x61fe14, b2 address is 0x61fe10
 * Enters : a2 value is 0x61fe14, b2 value is 0x61fe10
 * Enters : a2 address is 0x61fde0, b2 address is 0x61fde8
 * Exits  : a2 value is 0x61fe10, b2 value is 0x61fe14
 * Exits  : a2 address is 0x61fde0, b2 address is 0x61fde8
 * After  : a2 value is 15, b2 value is 35
 * After  : a2 address is 0x61fe14, b2 address is 0x61fe10
 * 
 * *-----Swap By Reference-----*
 * Before : a3 value is 25, b3 value is 55
 * Before : a3 address is 0x61fe0c, b3 address is 0x61fe08
 * Enters : a3 value is 25, b3 value is 55
 * Enters : a3 address is 0x61fe0c, b3 address is 0x61fe08
 * Exits  : a3 value is 55, b3 value is 25
 * Exits  : a3 address is 0x61fe0c, b3 address is 0x61fe08
 * After  : a3 value is 55, b3 value is 25
 * After  : a3 address is 0x61fe0c, b3 address is 0x61fe08
 * 
 * *-----Swap By Pointer Dereference-----*
 * Before : a4 value is 75, b4 value is 95
 * Before : a4 address is 0x61fe04, b4 address is 0x61fe00
 * Enters : a4 value is 0x61fe04, b4 value is 0x61fe00
 * Enters : a4 address is 0x61fde0, b3 address is 0x61fde8
 * Exits  : a4 value is 0x61fe04, b4 value is 0x61fe00
 * Exits  : a4 address is 0x61fde0, b4 address is 0x61fde8
 * After  : a4 value is 95, b4 value is 75
 * After  : a4 address is 0x61fe04, b4 address is 0x61fe00
 * 
*/

The output clearly shows that only during the execution of swapByReference routine, the value & address of variables remained the same. Though swapByPointerDereference function swapped the values, they just employed pass by value with address and performed dereferencing. It is evident from the difference in the addresses of variables between the caller and called function. Thus it proves that only through reference variables, pass by reference can be employed.

Pass by value vs Pass by reference in Java
In Java, there are no such variables as reference variables. The reference type that store the address of an object is just a pointer to the object.

Lets see a similar swap program to the one seen above in Java language. The program can be contains three methods and they do the following,

swapByValue — Method that swaps two primitives
swapByReferenceType — Method that swap two reference types
swapByObjectManipulation — Method that swaps objects by doing something similar to pointer dereferencing using Java dot operator

class Person {
    int id;
    String name;

    Person(int id, String name){
        this.id = id;
        this.name = name;
    }
}

public class PassByModel {
    public static void main(String... args) {
        Person p1 = new Person(1, "Person1.0");
        Person p2 = new Person(2, "Person2.0");
        Person p3 = new Person(3, "Person3.0");
        Person p4 = new Person(4, "Person4.0");
        int a = 1, b = 2;

        System.out.println();
        System.out.println("*-----Swap By Value-----*");
        System.out.println("Before : a is "+a+", b is "+b);
        swapByValue(a, b);
        System.out.println("After  : a is "+a+", b is "+b);
        System.out.println();

        System.out.println("*-----Swap By Reference Type-----*");
        System.out.println("Before : p1 is "+p1+", p2 is "+p2);
        System.out.println("Before : p1 id is "+p1.id+", p1 name is "+p1.name+"; p2 id is "+p2.id+", p2 name is "+p2.name);
        swapByReferenceType(p1, p2);
        System.out.println("After  : p1 is "+p1+", p2 is "+p2);
        System.out.println("After : p1 id is "+p1.id+", p1 name is "+p1.name+"; p2 id is "+p2.id+", p2 name is "+p2.name);
        System.out.println();

        System.out.println("*-----Swap By Object Manipulation-----*");
        System.out.println("Before : p3 is "+p3+", p4 is "+p4);
        System.out.println("Before : p3 id is "+p3.id+", p3 name is "+p3.name+"; p4 id is "+p4.id+", p4 name is "+p4.name);
        swapByObjectManipulation(p3, p4);
        System.out.println("After  : p3 is "+p3+", p4 is "+p4);
        System.out.println("After  : p3 id is "+p3.id+", p3 name is "+p3.name+"; p4 id is "+p4.id+", p4 name is "+p4.name);

    }

    static void swapByValue(int a, int b) {
        System.out.println("Enters : a is "+a+", b is "+b);
        int temp = a;
        a = b;
        b = temp;
        System.out.println("Exits  : a is "+a+", b is "+b);
    }

    static void swapByReferenceType(Person p1, Person p2) {
        System.out.println("Enters : p1 is "+p1+", p2 is "+p2);
        Person temp = p1;
        p1 = p2;
        p2 = temp;
        System.out.println("Exits  : p1 is "+p1+", p2 is "+p2);
    }

    static void swapByObjectManipulation(Person p3, Person p4) {
        System.out.println("Enters : p3 is "+p3+", p4 is "+p4);
        Person temp = p3;
        p3.id = p3.id;
        p3.name = p3.name;
        p4.id = temp.id;
        p4.name = temp.name;
        System.out.println("Exits  : p3 is "+p3+", p4 is "+p4);
    }
}

/*
 * Sample Output
 * -------------
 *
 * *-----Swap By Value-----*
 * Before : a is 1, b is 2
 * Enters : a is 1, b is 2
 * Exits  : a is 2, b is 1
 * After  : a is 1, b is 2
 * 
 * *-----Swap By Reference Type-----*
 * Before : p1 is Person@18e8568, p2 is Person@33e5ccce
 * Before : p1 id is 1, p1 name is Person1.0; p2 id is 2, p2 name is Person2.0
 * Enters : p1 is Person@18e8568, p2 is Person@33e5ccce
 * Exits  : p1 is Person@33e5ccce, p2 is Person@18e8568
 * After  : p1 is Person@18e8568, p2 is Person@33e5ccce
 * After  : p1 id is 1, p1 name is Person1.0; p2 id is 2, p2 name is Person2.0
 * *-----Swap By Object Manipulation-----*
 * Before : p3 is Person@326de728, p4 is Person@25618e91
 * Before : p3 id is 3, p3 name is Person3.0; p4 id is 4, p4 name is Person4.0
 * Enters : p3 is Person@326de728, p4 is Person@25618e91
 * Exits  : p3 is Person@326de728, p4 is Person@25618e91
 * After  : p3 is Person@326de728, p4 is Person@25618e91
 * After  : p3 id is 3, p3 name is Person3.0; p4 id is 3, p4 name is Person3.0
 *  
 */

The methods swapByValue and swapByReference produce similar output. Even though the reference type holds the address of an object as its value (Person), the value is just assigned onto the parameter and these parameters are no direct references to the object created in the caller. Java language doesn’t allow a programmer to create reference variables. It can be concluded from the above experiment that pass by reference is never really allowed in Java.

Java is designed with C as the fundamental programming model and C++ for the OOP principles. Java passes values to methods and these values are just copied across parameters be it primitives or reference types. It is often misunderstood that since the reference types store the address of an object, it is passed by reference. Reference types are pointers and not reference variables. In fact, there are no reference variables or aliases/alternatives in Java as in C++.

Answering the question, Java passes only by value for both primitives and reference types!!!

Useful links on the topic
https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value
https://stackoverflow.com/questions/1961146/memory-address-of-variables-in-java
https://stackoverflow.com/questions/14612314/how-are-variable-names-stored-in-memory-in-c
https://stackoverflow.com/questions/48204770/get-name-of-variable-from-its-address