Access Modifiers and Information Hiding

The private access modifier restricts visibility to the declaring class itself. When applied to fields or methods, these members become inaccessible from external classes, enforcing information hiding—a core principle of object-oriented design.

Key Applications:

• Protecting sensitive data from direct manipulation
• Hiding implementation details that might change
• Enforcing controlled access through public interfaces

Example:

public class SecureVault {
    private String confidentialKey = "classified-data";
    
    private void auditAccess() {
        System.out.println("Access logged for: " + confidentialKey);
    }
    
    public void retrieveData() {
        auditAccess(); // Internal use permitted
        // Return processed data...
    }
}

External code cannot invoke auditAccess() or access confidentialKey directly; interaction must occur through retrieveData().

Encapsulation Patterns

Encapsulation extends beyond private fields by bundling data with validated access methods. This approach allows classes to maintain invariants and execute side effects during state changes.

Implementation Strategy:

1. Declare fields as private to prevent direct mutation
2. Provide public getter methods for read access
3. Provide public setter methods for controlled write access, incorporating validation logic

Practical Implementation:

import java.time.LocalDateTime;

public class BankAccount {
    private String accountHolder;
    private double currentBalance;
    
    public BankAccount(String holder, double initialDeposit) {
        this.accountHolder = holder;
        this.currentBalance = initialDeposit;
    }
    
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive");
        }
        logTransaction("DEPOSIT", amount);
        this.currentBalance += amount;
    }
    
    public void withdraw(double amount) {
        if (amount > currentBalance) {
            throw new IllegalStateException("Insufficient funds");
        }
        logTransaction("WITHDRAWAL", -amount);
        this.currentBalance -= amount;
    }
    
    public double checkBalance() {
        System.out.println(LocalDateTime.now() + " - Balance inquiry for " + accountHolder);
        return currentBalance;
    }
    
    private void logTransaction(String type, double amount) {
        System.out.printf("[%s] %s: %s %.2f%n", 
            LocalDateTime.now(), accountHolder, type, amount);
    }
}

The currentBalance field cannot be modified arbitrarily; all changes flow through deposit() and withdraw(), ensuring transaction logging and balance validation.

The this Reference

Within instance methods and constructors, this refers to the current object instance. This reference serves three primary purposes:

1. Disambiguating shadowed variables when parameter names match field names
2. Invoking other constructors within the same class (constructor chaining)
3. Passing the current object as a parameter to other methods

Constructor Chaining Example:

public class Employee {
    private String empId;
    private String fullName;
    private String department;
    private double salary;
    
    public Employee() {
        this("TEMP-ID", "Unknown", "Unassigned", 0.0);
    }
    
    public Employee(String id, String name) {
        this(id, name, "General", 3000.0);
    }
    
    public Employee(String id, String name, String dept, double initialSalary) {
        this.empId = id;
        this.fullName = name;
        this.department = dept;
        this.salary = initialSalary;
    }
    
    public void transferToDepartment(String newDept) {
        System.out.println(this.fullName + " moving from " + this.department + " to " + newDept);
        this.department = newDept;
    }
}

Note that this() calls must appear as the first statement in a constructor body.

Package Organization

Packages provide namespace management, preventing class name collisions while organizing related types into coherent units. They mirror directory structures and follow reverse-domain naming conventions.

Standard Package Conventions:

• com.organization.utilities - Helper classes and static utilities
• com.organization.domain - Entity classes and business objects
• com.organization.data - Data access layers and repositories
• com.organization.services - Business logic and service implementations

Proper packaging enables:

• Clear separation of concerns
• Controlled visibility (package-private access)
• Modular deployment via JAR archives

Static Contexts and Class Members

The static keyword associates members with the class itself rather than individual instances.

Static Fields

Static fields reside in the method area (or metaspace in modern JVMs) and are shared across all instances. They initialize when the class loads and persist until class unloading.

public class SystemConfiguration {
    private static String environment = "development";
    private static int activeConnections = 0;
    
    // Instance-specific data
    private String sessionToken;
    
    public static void setEnvironment(String env) {
        environment = env; // Valid: accessing static from static
    }
    
    public void connect() {
        activeConnections++; // Valid: accessing static from instance
        this.sessionToken = generateToken();
    }
}

Access static members via class references (SystemConfiguration.environment) rather than instances to avoid compiler warnings.

Static Methods

Utility functions that don't require object state should be declared static. These methods cannot access instance variables or this references.

Tool Class Design:

public final class ArrayUtils {
    private ArrayUtils() {
        // Prevent instantiation
    }
    
    public static int findMax(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("Array must not be empty");
        }
        int max = array[0];
        for (int value : array) {
            if (value > max) max = value;
        }
        return max;
    }
    
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

Static Initialization Blocks

Static blocks execute during class loading, before any instances are created or static methods called. They initialize complex static data structures.

public class DatabasePool {
    private static Map<String, Connection> connectionCache;
    
    static {
        connectionCache = new HashMap<>();
        loadDriver();
        System.out.println("Database pool initialized");
    }
    
    private static void loadDriver() {
        // Driver registration logic
    }
}

Execution order: Static fields/blocks (in declaration order) → Instance fields/blocks → Constructors.

JAR Management and Documentation

Creating and Consuming JARs

Exporting JAR Archives: In Eclipse: Select project → File → Export → Java → JAR File → Specify destination and manifest options.

Importing Dependencies:

1. Create a lib folder in the project root
2. Copy JAR files into lib
3. Right-click JAR → Build Path → Add to Build Path

This attaches the archive to the classpath, making its classes available for import.

API Documentation Generation

Generate HTML documentation using Javadoc:

1. Select project → Export → Java → Javadoc
2. Specify the javadoc.exe path (e.g., JDK_HOME/bin/javadoc.exe)
3. Set destination directory
4. Ensure source code contains documantation comments

Documentation Comment Syntax:

/**
 * Calculates compound interest over time.
 * 
 * @param principal Initial investment amount
 * @param rate Annual interest rate (decimal)
 * @param years Investment duration
 * @return Final balance including interest
 * @throws IllegalArgumentException if rate is negative
 */
public static double calculateInterest(double principal, double rate, int years) {
    // Implementation
}

Eclipse Shortcut Reference:

• Toggle line comment: Ctrl + /
• Block comment: Ctrl + Shift + / (add) and Ctrl + Shift + \ (remove)
• Generate Javadoc: Alt + Shift + J

Class Loading Mechanisms

The JVM initializes classes through a three-phase process: Loading, Linking, and Initialization.

1. Loading: The classloader reads the .class file and creates a java.lang.Class object representing the type in the method area.
2. Linking: Verification (bytecode validation), Preparation (allocating memory for static variables with default values), and Resolution (symbolic references to direct references).
3. Initialization: Execution of static initializers and static field assignments in textual order.

Static Initialization Order Traps

Scenario A:

public class InitializationTrap {
    static InitializationTrap instance = new InitializationTrap();
    static int counter1;
    static int counter2 = 0;
    
    public InitializationTrap() {
        counter1++;
        counter2++;
    }
    
    public static void main(String[] args) {
        System.out.println(counter1); // Output: 1
        System.out.println(counter2); // Output: 0
    }
}

Execution Flow:

1. Preparation: Allocate space for instance (null), counter1 (0), counter2 (0)
2. Initialization:
   • instance = new InitializationTrap() executes constructor: both counters become 1
   • counter1 remains 1 (no explicit assignment)
   • counter2 = 0 executes, overwriting the 1 with 0

Scenario B:

public class CorrectOrder {
    static int counter1;
    static int counter2 = 0;
    static CorrectOrder instance = new CorrectOrder();
    
    public CorrectOrder() {
        counter1++;
        counter2++;
    }
    
    public static void main(String[] args) {
        System.out.println(counter1); // Output: 1
        System.out.println(counter2); // Output: 1
    }
}

Execution Flow:

1. Preparation: All statics initialized to default values (0 or null)
2. Initialization:
   • counter1 remains default 0, then stays 0 (no assignment)
   • counter2 explicitly set to 0
   • Constructor executes: both increment to 1

Understanding this ordering prevents subtle bugs in static initialization sequences.