Variables in Java

This tutorial provides you with details of how to use variables in Java programs. It is an essential topic for you to know and do real Java programming.

Learn to Use Variables in Java

The tutorial has the following sections to help you learn quickly.

What does a variable mean?

Variables, as the name suggests, can hold a particular value and can also accept modifications time in time out.

In terms of a programming language, a variable is a name pointing to a memory location.

In Java, one should define all the variables before using them.

Why should you use variables in Java?

Consider a scenario where you wish to do arithmetic calculations using a Java program. Assume, you did some initial calculations and came up with a numerical value.

You feed the value (say 1) into your Java program and use that value at about 100 lines in your code.

Now, you decide to re-check your calculations and realize that a blunder occurred at some point as the actual value was 0.5, not 1.

In this case, you can either go on changing the value at all 100 places from 1 to 0.5 or use a variable instead.

How to declare variables in Java?

To use a variable, you need to declare it first. And it is also quite straightforward:

int myVar;

There are a few thumb rules to note while you create a variable in Java.

  • First, never start a variable name with “_” or “$” symbols.
  • Ensure¬†that the variable name is making sense in the context of the value you are storing in it.
  • Also, having multiple variables with the same name doesn’t work if they are in the same scope.

For declaring a variable, first, specify the keyword, i.e., the data type and then type its name.

For example –

int value; // value is name of the variable and int is the keyword

The above is an un-initialized variable. You can also give a default value. See below.

int value = 0; // variable initialized with zero

boolean isOdd = true; // boolean variable set to true whereas its default value is false

char letter = 'J'; // variable to store characters

Until this point of time, three variables “value,” “isOdd,” and “letter” have entered in program’s memory.

learn to use local java variables

The variable “value” points to a memory location which the user can change to assign any value. Similarly, other variables also have memory allocated and can store specific values.

Must Read – Data types in Java

Types of variables

There are three major types of variables in Java:

Local variable:

Any variable which appears inside a constructor or a method or a block is a local one.

These types of variables incarnate whenever a constructor or a method or a block gets invoked and destroyed subsequently upon losing their scope.

The extent of these variables exists just inside the block in which it gets used.

Below is a demo program using the local variables.

public class MyProgram
{
    public static void main(String[] args)
    {
        String myMessage; // local variable, has scope in the main function only.
        myMessage = "I'm learning Java.";
        System.out.println(myMessage);
    }
}

Executing the above code gives the following result:

I'm learning Java.

Instance variable:

An instance variable is one which has its definition inside the class but outside any of its function, constructor or block.

Please note that it is non-static and each object of the class will have its respective copy of the instance variable.

An instance variable gets allocation along with the class object and remains until the object persists.

In contrast to the local ones, you may apply appropriate access specifiers for these variables. If you don’t indicate any, then the default specifier will get used.

Below is a demo program using the instance variable.

public class Book
{
    public String name; // instance variable accessible to any child class.
    private String author; // instance variable accessible only in Book class.

    // Constructor method
    public Book(String value) {
        name = value;
    }

    // Class method to set the private instance variable
    public void setAuthor(String value) {
        author = value;
    }

    // Class method to get the private instance variable
    public void getAuthor() {
        System.out.println("Written by: " + author);
    }

    public static void main(String[] args)
    {
        Book first = new Book("Java");
        first.setAuthor("James Gosling");

        Book second = new Book("Python");
        second.setAuthor("Guido van Rossum");

        System.out.println("Book name: " + first.name);
        first.getAuthor();
        
        System.out.println("\n");

        System.out.println("Book name: " + second.name);
        second.getAuthor();
    }
}

Executing the above code gives the following result:

Book name: Java
Written by: James Gosling

Book name: Python
Written by: Guido van Rossum

Static variable:

Static variables are otherwise called Class variables.

Similar to instance variables, they also have a definition at the class level. But they do differ in a way as we need to prefix the “Static” keyword to declare them. And each class object shares a single copy of them.

The static variables go live at the beginning of program execution and terminate when the application ends. To get to static variables, we don’t need to make any object of that class.

Check out the below program to get more clarity on the functionality of static variables.

// Java program to demonstrate the
// use of a static variable
public class StaticDemo
{
    static int counter = 0;

    // Constructor method incrementing the counter 
    // for every new object getting created
    public StaticDemo() 
    { 
        counter++;
    } 
  
    public static void main(String[] args) 
    { 
          StaticDemo static1 = new StaticDemo(); 
          StaticDemo static2 = new StaticDemo(); 
          StaticDemo static3 = new StaticDemo(); 

          System.out.println("Total objects created: " + counter);
    } 
}

Executing the above code gives the following result:

Total objects created: 3