Static Members and Inheritance in Java

Static Modifiers

Static keywords in Java are primarily used to define class-level members rather than instance-level members. Depending on whether a member variable is modified by static, it is categorized into:

• Class Variables: Defined with static. These belong to the class itself, exist in memory only once, and are shared across all instances of the class.
• Instance Variables: Defined without static. These belong to specific objects; each instance maintains its own independent copy.

public class User {
    // Class variable
    static String departmentName;
    
    // Instance variable
    private int userId;
}

Accessing Variables

Class Variables:

• Recommended: ClassName.variableName
• Not Recommended: objectReference.variableName

Using the class name is preferred because class variables are loaded when the class is loaded into the method area; they do not require object instantiation. Accessing them via an object is misleading since they are shared by all objects.

Instance Variables:

• Only accessible via: objectReference.variableName

// Recommended access for class variables
User.departmentName = "Engineering";

// Possible but discouraged
User u1 = new User();
u1.departmentName = "Marketing";

// Accessing instance variables
u1.userId = 101;

When to Use Class Variables

In software development, define a variable as static if data needs to be shared globally and only one copy is required.

• Class Variable: Use when data is shared and modified across instances (e.g., a global counter or configuration constant).
• Instance Variable: Use when data is unique to each object (e.g., username, score, age).

Note: When accessing static members within the same class, the class name can be omitted. However, when accessing them from a different class, the class name must be specified.

Static Methods

Methods modified by static belong to the class. They can be invoked using the class name or an object reference, though the class name is the standard convention. The behavior is similar to static variables.

The Main Method

The main method is static because the JVM calls it before any object instantiation occurs. It acts as the entry point and can accept command-line arguments (String array args).

Utility Classes and Static Methods

The most common use case for static methods is in Utility classes. These classes contain reusable functionality for developers.

• Advantages: Improves code reusability, simplifies invocation (no object needed), and enhances development efficiency.
• Memory Efficiency: Calling instance methods requires creating an object, which consumes memory. If the object exists solely to call a method, this is wasteful. Static methods avoid this overhead.
• Construction: Since utility classes are not meant to be instantiated, their constructors should be marked as private to prevent object creation.

Restrictions on Class Methods

• Class methods can directly access other static members but cannot directly access instance members (variables or methods), as instance members require an object context.
• Instance methods can access both static and instance members.
• The this keyword, referring to the current instance, is valid in instance methods but illegal in static methods.

Code Blocks

Code blocks are one of the five major components of a class (along with variables, constructors, methods, and inner classes).

Static Code Blocks

• Format: static { ... }
• Behavior: Executed automatically once when the class is loaded into memory.
• Usage: Primarily used for initializing complex class variables. For example, initializing a Socket or a Map with complex logic often occurs here, potentially wrapped in try-catch blocks for error handling.

static {
    // Initialization logic executed once on class load
    System.out.println("Static block executed");
}

Instance Code Blocks

• Format: { ... }
• Behavior: Executed every time an object is created, running before the constructor.
• Usage: Used for initializing instance variables. A common practical use is logging object creation, which avoids code duplication if a class has multiple overloaded constructors.

Singleton Design Pattern

Design patterns represent optimal solutions to common software problems. The Singleton pattern ensures that a class has only one instance.

Eager Initialization (Singleton)

• Create the object immediately when the class is loaded.
• Suitable for scenarios where the object is lightweight or will be used frequently (e.g., a Task Manager window).

public class AppManager {
    // 1. Static variable to hold the single instance
    private static AppManager instance = new AppManager();

    // 2. Private constructor to prevent external instantiation
    private AppManager() {}

    // 3. Public static method to provide access
    public static AppManager getInstance() {
        return instance;
    }
}

// Usage
AppManager app = AppManager.getInstance();

Lazy Initialization (Singleton)

• Create the object only when it is requested for the first time.
• Suitable for resource-intensive objects that may not be used immediately.

public class DatabaseConnection {
    private static DatabaseConnection dbInstance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (dbInstance == null) {
            dbInstance = new DatabaseConnection();
        }
        return dbInstance;
    }
}

Inheritance

Java uses the extends keyword to establish an inheritance relationship between classes, creating a parent-child hierarchy.

• Rule: A subclass inherits non-private members (variables and methods) from its parent.
• Object Construction: A subclass object is constructed using both the subclass and parent class blueprints. The resulting object can access any public or protected members defined in either class.

Benefits and Scenarios

• Code Reusability: Reduces redundancy by moving common code to a parent class (base class). Specific classes extend this base class to inherit shared features.

Important Considerations

• Modifiers: Private members are not inherited. Default (package-private) members are inherited only if the subclass is in the same package.
• Single Inheritance: Java supports only single inheritance (a class can have only one direct parent). However, it supports multi-level inheritance (e.g., Grandparent -> Parent -> Child). Multiple inheritance is forbidden to avoid ambiguity (e.g., the Diamond Problem).
• Object Class: java.lang.Object is the root ancestor of all Java classes. Every class implicitly inherits from Object, inheriting methods like hashCode(), equals(), and toString().

Method Overriding

When a subclass implementation of a method inherited from the parent is insufficient or unsuitable, the subclass can redefine the method with the exact same name and parameter list. This is called method overriding.

• Execution Rule: Java follows the "nearest principle"; the JVM executes the subclass's version of the method.

Overriding Rules

• @Override Annotation: Always use this annotation to instruct the compiler to verify the signature, ensuring it actually overrides a parent method. This improves readability and safety.
• Access Modifiers: The access level of the overriding method must be equal to or more permissive than the parent method (Public > Protected > Default).
• Return Type: The return type must match the parent method exactly, or be a subclass of the parent's return type (covariant return types).
• Restrictions: Private methods and static methods cannot be overridden.

The toString() method is a common candidate for overriding. By default, it prints the memory address, but developers typically override it to return meaningful object state information.

Accessing Members in Subclasses

When accessing members (variables or methods) within a subclass method, Java follows a specific lookup order:

1. Look in the local scope (within the method).
2. Look in the subclass member scope.
3. Look in the parent class member scope.

If a variable or method is shadowed or overridden in the subclass, the subclass version is prioritized. To explicitly access the parent version, use the super

super.parentMethod();

Subclass Constructors

All constructors in a subclass must invoke a parent class constructor before executing their own logic.

• Default Behavior: The first line of every subclass constructor implicitly calls super(), which invokes the parent's no-argument constructor.
• Explicit Calls: If the parent does not have a no-argument constructor, the subclass must explicitly call super(args) in its first line to invoke a matching parent constructor.

This ensures that parent-level initialization (e.g., assigning private variables defined in the parent) happens before the subclass initializes its specific state.

Constructor Chaining: this() and super()

Constructors can call other overloaded constructors of the same class using this(...).

• Constraint: super(...) and this(...) cannot both exist in the same constructor.
• Placement: Both calls must be the first statement in the constructor. This is because object initialization must always start from the topmost parent (root) class down to the current subclass.