Java Variables

The variable is the basic unit of storage in a Java program. A variable is defined by the combination of an identifier, a type, and an optional initializer. In addition, all the variables have a scope, which defines their visibility, and a lifetime. You will learn about variable scope in separate chapter scope of variables.

Java Variable Declaration

In Java, all the variables must be declared before they can be used. The basic form of a variable declaration in Java is shown here :

type identifier;

or,

type identifier = value;

or,

type identifier1, identifier2, ... ;

Here, type is one of the Java's types, or the name of a class or interface (you will learn later about class and interface in separate chapters).

The identifier is the name of variable. You can initialize the variable by specifying an equal sign and a value.

Note - Keep in mind that the initialization expression must result in a value of the same/compatible type as that specified for the variable.

To declare more than one variable of the specified type, use a comma-separated list.

Following are some examples of variable declaration of various types. Note that some include an initialization :

int a, b, c;         // declares three ints a, b, and c.
int d = 3, e, f = 5;    // declares three more ints, initializing d and f.
byte z = 22;        // declares and initializes z.
char x = 'x';       // declares and initializes the variable x with the value 'x'.

The identifiers that you choose have nothing intrinsic in their names that indicates their type. Java allows any properly formed identifier to have any declared type.

Dynamic Initialization in Java

Although the preceding examples have used only constants an initializers, Java allows variables to be initialized dynamically, using any expression valid at the time, the variable is declared.

For example, following is a short program that computes the length of the hypotenuse of a right-angle triangle given the lengths of its two opposing sides:

/* Java Program Example - Java Variables
 * This program demonstrates dynamic initialization */

public class JavaProgram
{   
    public static void main(String args[])
    {
        
        double a = 3.0, b = 4.0;
        
        /* c is dynamically initialized */
        double c = Math.sqrt(a * a + b * b);
        System.out.println("Hypotenuse is " + c);
        
    }
}

When the above Java program is compile and executed, it will produce the following output:

Here, the three local variables, a, b, and c are declared. The first two, a and b, are initialized by the constants. However, c is initialized dynamically to the length of the hypotenuse (using the Pythagorean theorem ). The program uses another of Java's built-in method i.e., sqrt(), which is a member of the Math class, to compute the square root of its argument. The key point here is that the initialization expression may use any element valid at the time of initialization, including calls to the methods, other variables, or the literals.

Java Online Test