Private Field

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Syntax

private [non-access modifiers] DataType fieldName [= initialValue];

​

Visibility and Access Rules

• Enclosing Class: Fully accessible by any constructor, instance method, or static method within the exact same class.
• Nested Classes: Accessible to all inner and nested classes declared within the same enclosing top-level class. Conversely, the outer class can access private fields of its inner classes.
• Subclasses: Not inherited. An external subclass cannot access a parent class’s private field via this or super. However, if the subclass is declared as a nested class within the exact same top-level class as the parent, it retains access.
• Package-Private / External: Inaccessible to any other class, regardless of package structure.

​

Technical Characteristics

• Bytecode Representation: During compilation, the Java compiler flags private fields with the ACC_PRIVATE access flag (0x0002) within the field_info structure of the .class file.
• Memory Allocation: The private modifier does not affect memory allocation. Private instance fields are allocated on the Java Heap within the instantiated object’s memory layout. Private static fields are also allocated on the Java Heap, specifically as part of the java.lang.Class object associated with the declaring class (as of Java 8), not in the Metaspace.
• Independent Declaration: Because private fields are not inherited and are inaccessible to external subclasses, a subclass declaring a field with the exact same name as a private field in its superclass does not participate in shadowing or hiding. It simply creates a completely independent variable in the subclass’s memory layout.
• Reflection Bypass: At runtime, the access control of a private field can be bypassed using the Java Reflection API by invoking Field.setAccessible(true). However, in Java 9 and later, this is heavily restricted by the Java Platform Module System (JPMS) unless the module explicitly opens the package to the reflecting module.

​

Code Visualization

public class Alpha {
    // Private instance field
    private int internalState = 100;
    
    // Private static field
    private static final String IDENTIFIER = "ALPHA_NODE";

    // Access permitted: Same class
    public void mutateState(int delta) {
        this.internalState += delta; 
    }

    // Access permitted: Nested class
    public class Beta {
        public void readOuterState() {
            System.out.println(internalState); 
            System.out.println(IDENTIFIER);
        }
    }
    
    // Access permitted: Subclass nested within the same top-level class
    public class NestedSubclass extends Alpha {
        public void accessParentPrivate() {
            System.out.println(super.internalState);
        }
    }
}

// External subclass
class Gamma extends Alpha {
    public void attemptAccess() {
        // Compilation Error: internalState has private access in Alpha
        // System.out.println(this.internalState); 
    }
}

// External class
class Delta {
    public void attemptAccess() {
        Alpha instance = new Alpha();
        // Compilation Error: internalState has private access in Alpha
        // instance.internalState = 200; 
    }
}