Introduction

Programs manage data stored in memory. On the machine level, data can only be called by the numeric address of the memory location where the data is stored. In Java, names are used instead of numbers to call data. The programmer only needs to remember the name, and the computer takes care of whe dadata’s locationThis name, which is used to call data stored in memory, which is called a variable.

The only way in which data in a variable can be stored in Java is by using an assignment (initialization)) statement in the form:

variable = expression;

Where an expression represents anything that refers to a value or calculates a value when the computer encounters an “assign” command at runtime, it evaluates the expression a. It saveshe result to a variable.”Where an expression represents anything that refers to a value or calculates a value, when the computer encounters an “assign” command at runtime, it evaluates the expression and saves the result to a variable.

Consider the expression:

interest = percentage * principal;

• Interest, percentage, and principal are variables; the “percentage * principal” value is stored in the interest variable.
• “*” denotes a multiplication operator.

We see that when variables are used in an expression, we are acing the values stored in them. In this expression, the computer works with values.

Basic Syntax

The variable can be used in the program only if it has been previously declared. The variable declaration statement is used to declare a variable and give it a name. By declaration – we reserve a memory location for that variable and associate the variable name with that location. The simple form of the declaration command is:

 variable_type  variable_name;

Example:

int counter1, counter2;// declaring two integer variables
int x = 15, y = 25;  // initialization example
byte L = 18;         // initializing a byte type variable L.
double z = 1.172; // declaring and assigning value of z.
char c = 'c';        // char variable initialized with value

In the above code example, we declared two integer variables in one line called “counter1” and “counter2“. Then initializing them.

The second style is initialized while declaring the variable like in byte and double variables.

Java Variable Types

there are three types of variables based on their scope: local, static, and instance. Let’s explore each of them in detail.

Local Variables:

• These variables are declared within a particular method, block, or constructor in which they are located.
• The value stored in the local variable is valid only within the scope of that method and is lost after the method is exited.
• A local variable with the same name can be declared in multiple methods or blocks without conflict.
• Local variables can not have default values, so if we need to have an initial value – we must assign it at the beginning of the block.

Example:

public class StudentInfo{
public void Student()
{
 // local variable id
 int id= 1200;
 // local variable name
 string name = "John";
 System.out.println("Student Name is: " + name, + " Student Id is: " + id);
 name = "Rick";
 id = id + 1;
 System.out.println("Student Name is: " + name, + " Student Id is: " + id);
}

public void TeacherInfo()
{
 int id = 5000;
 string name = "Peter";
 id= id +1;
 System.out.println("Teacher Name is: " + name + " Teacher ID is: " + id);
)

public static void main(String args())
{
 StudentInfo stud = new StudentInfo();
 stud. Student();
 stud.TeacherInfo();
}
}

Output:

Student Name is: John, Student Id is: 1200
Student Name is: Rick, Student Id is: 1201
Teacher Name is: Peter,  Teacher ID is: 5000

“The example shows that the same local names of the variables”i” and”name” – when declared in two different methods, i.e. Student and TeacherInfo, can be used to assign any number of different values.”The example shows that the same local names of the variables “id” and “name” – when declared in two different methods, i.e. Student and TeacherInfo, can be used to assign any number of different values.

Instance Variables:

• Instance variables are those declared within a class, not within any method.
  They occur when an object is created, and its value is lost when it is destroyed.
• The visibility of instance variables is in all blocks, methods, and constructors within the class.
• Instance variables’ values must be referenced by more than one method, constructor or block, or part of the object’s state that must be present in the class.
• ‘Initialization of these variables is optional, and the value is taken as zero by default. For a boolean – the default value is “false“, and for an object – it is null.’Initialization of these variables is optional, and the value is taken as zero by default. The default value is “false” for a boolean, and for an object, it is null.
• They are non-static variables, meaning that memory for the variable will be allocated whenever a new object is created.

Example:

import java.io.*;
class Dog {
 // a, b are instance variables
 // a, b variables are declared inside a class not method
 int a;
 int b;
 }
class DogsDemo {
public static void main(String args())
{
// first object declaration
 Dog dog1 = new Dog();
 dog1.a= 11;
 dog1.b= 7;
// second object declaration
 Dog dog2 = new Dog();
 dog2.a= 8;
 dog2.b= 4;
// displaying variable values for first object
 System.out.println("Values for the first object:");
 System.out.println(dog1.a);
 System.out.println(dog1.b);
// displaying variable values for the second object
 System.out.println("Values for second object:");
 System.out.println(dog2.a);
 System.out.println(dog2.b);
}
}

Output:

Values for the first object:
11
7
Values for the second object:
8
4

Static Variables:

• Static variables are declared at the beginning of the program, preceded by a static keyword.
• Like instance variables, the initialization of static variables is optional, and their default value is 0.
• The usual usage of static variables is as constants – whing never change their initial value.
• Only one static variable name can be created when the program starts, and it is lost when execution is complete.
• The visibility of static variables is similar to instances, but they are usually declared as public – to be available to all class users.
• Memory for these variables is allocated only once – at the time of class loading and can be shared by multiple objects.
• When objects are different, changes made to a static variable in one of the objects will be reflected in all – as opposed to instance variables where the values declared in one object will not be reflected in others.

Example:

import java.io.*;

class Student {
 //static variable id
  public static int id;
  public static String name = "Emma";
  public static int year;
}
public class StudentInfo {
public static void main(String args())
{
{
 // no need of object to access static variables
 Student.id= 105;
 Student.year=3;
 System.out.println(Student.name + "'s id is:" + Student.id + "and year is:" + Student.year);
}
}

Output:

Emma’s id is: 105 and year is 3

Choosing the Right Variable Scope

Choosing the right variable scope is essential for writing efficient and maintainable Java code. Here are some factors to consider when deciding on the scope of a variable:

1. Visibility: The scope of a variable determines where it can be accessed in the code. For example, a local variable can only be accessed within the method it was declared, while an instance variable can be accessed within the entire class. Choose the appropriate scope to ensure that the variable can be accessed where it is needed.
2. Lifetime: The lifetime of a variable is the duration of time for which it is accessible in the code. Local variables have a short lifetime as they are created and destroyed within a method. In contrast, instance and class variables have longer lifetimes as they are created when an object is created and are destroyed when the object is destroyed or when the program ends. Choose the appropriate scope to ensure that the variable is available for as long as it is needed.
3. Thread safety: If multiple threads are accessing the same variable, it is important to consider the scope of the variable to ensure thread safety. For example, a class variable can be accessed by multiple threads simultaneously, so it needs to be synchronized to avoid data inconsistency issues.
4. Encapsulation: Encapsulation is the practice of hiding implementation details from other parts of the code. By using the appropriate variable scope, you can ensure that implementation details are not exposed unnecessarily, improving your code’s maintainability.

When choosing the appropriate variable scope, it is important to consider all of these factors to ensure that your code is efficient, maintainable, and safe.

Conclusion

In conclusion, understanding the different types of variables in Java is essential for writing efficient and organized code. Local, static, and instance variables have their own characteristics and usage, and it’s essential to use them appropriately based on the program’s requirements.

Additional Resources

Oracle’s Java Tutorials – Variables: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html