Instance Variable in Java – Syntax with Examples

An Instance variable in Java is also referred to as a class instance-specific variable. In this case, each new instance of a class object that you build will be equipped with a duplicate of the instance variables. If the variables are specified or outlined within a class but outside any methods are known as instance variables. 

You must be aware of a few characteristics of instance variables. We’ll additionally look more closely at each Java instance variable and discuss when it might be a good idea to use them. So, let’s start.

Before getting started, you may want to brush up or enhance your knowledge of Java. Check this article on Types of Inheritance in Java to get started. 

Instance Variables in Java

The Java programming language leverages instance variables. These variables are non-static in nature and defined outside any block, constructor, or method. That variable exists independently in each instantiation instance of the class. 

A class includes an instance variable in java.  You are probably questioning what an instance is specifically. An instance is produced each time a new object belonging to the class is created. Let’s say you possess an EMPLOYEE class. Then,

class Employee
{
String employeeName;
int employeeID;
}

However, if you build not one but two EMPLOYEE objects, then: 

Employee employee1 = new Employee();
Employee employee2 = new Employee().

The class Employee will then create two instances. Every employee would now have a unique name and grade, correct? As a result, the value stored in the “employeeName” and “employeeID” variables—which are referred to as “variables”—would differ for various employees. 

As you can see, each occurrence of these variables has a unique value. In Java, they are known as java instance variables.

Syntax of Instance Variables in Java

  ;
   = ;
public class Employee {
public String Name; // Name is an instance variable with public access modifier
private int salary; // salary is an instance variable with a private access modifier.
Public static String company; // Since Company is a static variable with a class-specific rather than an instance-specific value; it is not an instance variable.
}

Declaration of Instance Variables in Java

Every single instance of a class comes with its own set of java instance variables. In a Java application, it implies that every object has a unique copy of the instance variables that are defined for that class.

A keyword, access specifier (such as “private,” “public,” etc.), the variable’s data type, and finally, the variable’s name is used for declaring an instance variable. To get a clearer understanding, check this example below:

import java.io.*;
public class Student {
 // the instance variable name is visible for any child class.
   public String name;
 // the grade variable is visible in Student class only.
   private double grade;
 // The value for the name variable is assigned in the constructor 
   public Student (String stdName) {
      name = stdName;
   }
 // The variable grade is assigned a value now 
   public void setgrade(double stdgrade) {
      grade = stdgrade;
   }
//The following method will print the details of the Student
   public void printstd() {
      System.out.println("name  : " + name );
      System.out.println("grade :" + grade);
   }
   public static void main(String args[]) {
      Student stdOne = new Student("Mayank");
      stdOne.setgrade(10);
      stdOne.printstd();
   }
}
O/p:
name: Mayank
grade:10.0

Naming Conventions for Instance Variables in Java

The naming conventions for instance variables in Java dictate and demonstrate that every single word must begin with a lowercase letter. However, the initial letter of every single word must also be capitalized. 

Since Java variables can’t include white space, compound word variables must be written using the lower camel case syntax. The following three variables all adhere to the Java naming convention:

• firstName
• timeToFirstLoad
• index

Advantages and Disadvantages of Instance Variables in Java

Want to expand your skills and explore something more exciting and challenging than Java? Learn Business Analytics. This Business Analytics course will help you get started. 

Scope of Instance Variables in Java

The scope of an instance variable in Java includes the following: 

• A class’s instance variables are defined outside of any blocks, methods, or constructors.
• Every instance variable value is given its own slot whenever space is set aside for an object in a heap.
• The class level allows for the declaration of instance variables both before and after use.
• When it comes to instance variables, access modifiers are available for them.

Features of an Instance Variable in Java

There is an inverse correlation between the lifespan of an instance variable to that of an object. It implies that whenever an object is formed, it is most likely that an instance variable will be produced. The vice versa takes place whenever an object is damaged or destroyed. 

Similar to this, other features of an instance variable in Java are as follows: 

• Only objects can be created and used using instance variables.
• Each item will own a unique copy of Situational variables.
• Instance variable initialization is optional. Zero represents the default value.
• In a class, the declaration is made without using a block, constructor, or method. 
• Whenever a variable needs to be accessed by many methods in a class, programmers use instance variables.

Rules for Instance Variable in Java 

The rules for a Java instance variable are as follows: 

• It is not possible to designate instance variables as static. In Java, make use of this static variable.
• The class methods and any other type of scope must not be used while declaring the instance variables.
• Instance variables may be marked with access specifiers.
• Since the abstract keyword is solely utilized for methods, it can’t be utilized for labeling instance variables.
• Instance variables cannot be marked with the struct keyword.

Difference Between Java Instance Variables and Local Variables in Java

Here is a table outlining the difference between a local variable and an instance variable in Java: 

Initialization of Instance Variables

A variable that’s particular to an object is known as an instance variable. It is stated not within any methods and inside the curving braces of the class. The instance variable’s numerical value can be modified easily using any method within a class. 

However, no permission is given to access it from outside the class. Typically, instance variables are initialized at object creation time. 

An instance initializer block, a unique section of code that is executed when an object is created, is used to do this. Initializers, a section of code that runs when a class instance is created, can be applied to instance variables. Initializers are inaccessible for class variables.

Want to learn more about Java? Read this blog post on OOPS (Object Oriented Programming) Concept in Java!

Accessing Instance Variables in Java

There are two effective ways by which one can access instance variables in java. These include: 

• Leveraging an object of the class
• Leveraging the ‘this’ keyword

Conclusion

A class serves as an object template when it is created. The class property known as an instance variable might vary depending on the object. A class definition outside of any method is where you declare an instance variable.

Because they enable every object to hold a separate copy of the data, instance variables are crucial. Your program becomes more adaptable and effective as a result. So, with this, the comprehensive guide on a Java instance variable comes to an end.