Java Variables and Data Types

What is a Variable in Java?

Variable in Java is a data container that stores data values during Java program execution. Every variable is assigned a data type that designates the type and quantity of value it can hold. A variable is the memory location name of the data. Java variables have mainly three types: Local, Instance, and Static.

In order to use a variable in a program, you need to perform 2 steps:

1. Variable Declaration
2. Variable Initialization

How to Declare Variables in Java?

To declare a variable, you must specify the data type and give the variable a unique name.

Examples of other valid declarations are:

int a, b, c;

float pi;

double d;

char a;

How to Initialize Variables in Java?

To initialize a variable, you must assign it a valid value.

Examples of other valid initializations are:

pi = 3.14f;

do = 20.22d;

a = 'v';

You can combine variable declaration and initialization.

Example:

int a = 2, b = 4, c = 6;

float pi = 3.14f;

double do = 20.22d;

char a = 'v';

Types of Variables in Java

In Java, there are three types of variables:

1. Local Variables
2. Instance Variables
3. Static Variables

1) Local Variables

Local variables are variables that are declared inside the body of a method.

2) Instance Variables

Instance variables are defined without the static keyword. They are declared outside any method, constructor, or block. These variables are specific to each instance of a class and are known as instance variables.

3) Static Variables

Static variables are initialized only once, at the time of class loading, before the execution of the program starts. These variables are shared among all instances of a class and are initialized before any instance variables.

Types of Variables in Java with Examples

class Guru99 {
    static int a = 1; //static variable
    int data = 99; //instance variable
    void method() {
        int b = 90; //local variable
    }
}

What is Data Types in Java?

Data Types in Java are defined as specifiers that allocate different sizes and types of values that can be stored in a variable or an identifier. Java has a rich set of data types. Data types in Java can be divided into two parts:

1. Primitive Data Types :- which include integer, character, boolean, and float.
2. Non-primitive Data Types :- which include classes, arrays, and interfaces.

Primitive Data Types

Primitive data types are predefined and available within the Java language. Primitive values do not share state with other primitive values.

There are 8 primitive types: byte, short, int, long, char, float, double, and boolean.

Integer data types

byte (1 byte)
short (2 bytes)
int (4 bytes)
long (8 bytes)

Floating Data Type

float (4 bytes)

double (8 bytes)

Textual Data Type

char (2 bytes)

Logical

boolean (1 byte) (true/false)

Points to Remember:

• All numeric data types are signed (+/-).
• The size of data types remains the same on all platforms (standardized).
• The char data type in Java is 2 bytes because it uses the UNICODE character set. By virtue of it, Java supports internationalization. UNICODE is a character set that covers all known scripts and languages in the world.

Java Variable Type Conversion & Type Casting

A variable of one type can receive the value of another type. Here there are 2 cases:

Case 1) A variable of smaller capacity is assigned to another variable of bigger capacity.

This process is automatic and non-explicit, and is known as Conversion.

Case 2) A variable of larger capacity is assigned to another variable of smaller capacity.

In such cases, you have to explicitly specify the type cast operator. This process is known as Type Casting.

In case you do not specify a type cast operator, the compiler gives an error. Since this rule is enforced by the compiler, it makes the programmer aware that the conversion they are about to do may cause some loss in data, and it prevents accidental losses.

Example: To Understand Type Casting

Step 1) Copy the following code into an editor.

class Demo {
 public static void main(String args[]) {
  byte x;
  int a = 270;
  double b = 128.128;
  System.out.println("int converted to byte");
  x = (byte) a;
  System.out.println("a and x " + a + " " + x);
  System.out.println("double converted to int");
  a = (int) b;
  System.out.println("b and a " + b + " " + a);
  System.out.println("\ndouble converted to byte");
  x = (byte)b;
  System.out.println("b and x " + b + " " + x);
 }
}

Step 2) Save, Compile & Run the code.

Expected Output:

int converted to byte
a and x 270 14
double converted to int
b and a 128.128 128

double converted to byte
b and x 128.128 -128

FAQs