Instance variable in java
Instance Variables in Java: The Complete Guide
Instance variables are an important topic in Java programming. They are responsible for defining the characteristics of an object and preserving its state for its whole life cycle. In this blog, we will discuss instance variables in great detail, their different characteristics, usage, and best practices.
What Are Instance Variables?
An instance variable is a variable defined in a class (as opposed to a static variable). Since each object of a class has its own copy of instance variables, changes made to such variables in one object do not have any impact on another object of the same class.
Instance Variables:
- Defined within a class but out of any method, block, or constructor.
- Every instance has its own copy of instance variables.
- Gets a default value until you assign it.
- Can take any access modifier (private, protected, public, or default).
- They are not shared between entities, unlike static variables.
Syntax of Instance Variables
class Car { String brand; int speed; // Instance variables }Here, brand and speed are instance variables. Each instance of the Car class will have its own brand and speed values.
Default values of instance variables:
If an instance variable is not initialized, Java assigns default values as shown below:
| Data Type | Default Value |
|---|---|
| int | 0 |
| double | 0.0 |
| boolean | false |
| char | '\u0000' (null character) |
| String (or Other objects) | null |
Example:
- class Example {
- int number; // default value is 0
- String text; // default value is null
- void display() {
- System.out.println("Number: " + number);
- System.out.println("Text: " + text);
- }
- public static void main(String[] args) {
- Example obj = new Example();
- obj.display();
- }
- }
Instance Variables and Access Modifiers
Instance variables can have different access modifiers, which control their visibility and accessibility.
Private Instance Variables
- Accessibility: same class only.
- Use getters and setters to provide access.
- class Person {
- private String name;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- }
Public Instance Variables
- Accessible from anywhere in the program.
- Not recommended, as it violates encapsulation.
Protected Instance Variables
- Available within the same package and to subclasses.
Default (Package-Private) Instance Variables
- Only accessible within the same package.
Using Instance Variables
Instance variables are used to store object-specific data.
Example java program :
- class Student {
- String name;
- int age;
- // Constructor to initialize instance variables
- public Student(String name, int age) {
- this.name = name;
- this.age = age;
- }
- void display() {
- System.out.println("Name: " + name + ", Age: " + age);
- }
- public static void main(String[] args) {
- Student s1 = new Student("Alice", 20);
- Student s2 = new Student("Bob", 22);
- s1.display();
- s2.display();
- }
- }
Output:
Name: Alice, Age: 20 Name: Bob, Age: 22Each Student object holds its own copy of name and age.
Instance Variable vs Static Variable
| Feature | Instance Variables | Static Variables |
|---|---|---|
| Ownership | Object specific | Class specific |
| Memory Allocation | At object creation | At class loading |
| Access | Requires an object | Accessed via class name |
Example
- class Company {
- static String companyName = "Tech Corp"; // Static variable
- String employeeName; // Instance variable
- }
Best Practices for Instance Variables
- Encapsulation: Use the private access modifier and access it through getters and setters.
- Meaningful Names: Assign well-defined names to variables.
- Initialize in Constructor: Ensure instance variables are initialized in constructors.
- Limit Visibility: Use private or protected unless absolutely necessary.
- Lower Memory Usage: Use only the necessary instance variables in memory-sensitive applications.
Instance variables are critical components of Java's object-oriented programming paradigm. They enable objects to store their own independent state and data. Understanding how they work and following best practices allows you to write clean, efficient, and maintainable Java code.
Want to learn more about Java concepts? Let us know in the comments!
