Java Variables

In this article, we are going to explain to all Java learners what Java variables are and how to work with them.

What is Java variable

A variable in Java can be thought of as a box. This "box" has a certain size: the memory that is allocated for it. How much memory will be allocated depends on the type of the variable, but we are going to talk about this a little bit later. At the same time, the size of the box itself cannot be changed after its creation, but the contents can. The box may be empty. You can "insert" some value into it, and then extract and put some other value. Thus, a variable is a field that stores data values during the execution of a Java program. This box has important features:

it can always contain only one value (or can be empty, in which case it will contain the default value),
It has a data type. Its size depends on the type of data, as well as on which particular area of memory the place is allocated for it (where it lies).

How to declare variables

To declare variables in Java, you need to specify its type and name. Here is an example of declaring three variables:

int myInt;
String s;
Object variableName;

Here int, String, and Object are the data type and myInt, s, variableName are variable names. The data type must be chosen based on the needs of the program, and it is better to choose a name so that it is clear what it is about. Of course, for beginners it’s not that strict, but in large projects, variable names like ‘s’ can impair the readability of the code. So it's better to get used to naming variables in a way that makes it clear what they are for from the very beginning. Within reason, of course.

How to initialize variables

When you declare a variable, you allocate memory for it. Initialization means that you "put" a certain value into the "box". This can be done immediately during the declaration of the variable or later. Also, the value of a variable can change during program execution. Example:

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

Here we declared and initialized the myInt variable in one line, immediately allocating memory for it (32 bits for every int number), gave it a name, and then placed the value 5 in the allocated memory. Then we declared that we were allocating memory space for the string s, and already a separate command put the value “init” into it. After that, we printed out the string and changed the value of the variable s. In this program, we printed out the lines, and if you run it, you will see the following result:

init init5

Data types of variables in Java: primitive and non-primitive

Data types of variables in Java are divided into two groups:

Primitive data types include byte, short, int, long, float, double, boolean, and char
Non-primitive data types such as String, Arrays, and Classes

Here is an example of working with variables:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

int, char, boolean, and float are primitives. String is non-primitive. What about myStudent variable? This is an object of the user-created class Student. It was created simply to illustrate the work with non-primitive variables. They are the majority in Java, since almost everything in this programming language is an object. For understanding, here is the code of the Student class:

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

Types of variables in Java: local, instance, and static

There are three different types of variables in Java, we have listed them as follows:

Local Variables
Instance Variables
Static Variables

Local Variables

A variable declared inside the body of the method is called a local variable. Also, local variables are declared inside constructors and blocks. You can use local variables only within that method, constructor, or block where they were created and the other methods in the class aren't even aware that the variable exists. So local variables are created when the method, constructor, or block is entered and the variable is destroyed once the method, constructor, or block doesn’t work. A local variable cannot be defined with the static keyword. Even more: you can’t use access modifiers for local variables. Here is an example:

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

Here myOtherString is a local variable. You can’t use it from the other method, but myMethod. Local variables can’t have default values. If at least one local variable is not initialized in the program, the program will not work correctly. Let's make a small change in one of the previous examples and "forget" to initialize the myBool variable:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

If we try to run the program, it will throw an error:

Error:(10, 50) java: variable myBool might not have been initialized

Instance Variables

A variable declared inside the class but outside the body of any method, constructor or block is called an instance variable. Instance variables are created when an object is created using the new keyword. It is destroyed when the object is destroyed. It can’t be declared as static, but you can use access modifiers for instance variables. Instance variables are visible for all methods, constructors and blocks in the class. Usually instance variables are private, but you can change the visibility for subclasses. Instance variables as opposed to local variables have default values. For all number primitive types the default value is 0, for booleans it’s false, and for object references it’s null. Values can be assigned during the declaration or within the constructor. Here is an example:

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

Static variables

A variable that is declared as static is called a static variable. Java offers you to declare such variables outside a method, constructor or block. It cannot be local, they belong to class, not to instances. That means that a single copy of a static variable once created and shared among all the instances of the class. Memory allocation for static variables happens only once when the class is loaded in the memory. They can have any visibility, but usually they are declared as public. They also have default values such as instance variables.

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

In the example above, we created a separate Storage class, moved the count and sum variables into it, and declared them static. Public static variables can be accessed from any program method (and not only from a method). To reinforce what you learned, we suggest you watch a video lesson from our Java Course