This article explores three foundational Java concepts: the toString() method, the super keyword, and integration with native code via the native modifier.

Native Method Integration

In Java, a method declared with the native modifier and terminated by a semicolon indicates that its implementation resides outside the JVM—typically in platform-specific native code (e.g., C or C++ libraries). On Windows, such implementations are often packaged in .dll files; on Linux/macOS, they appear as .so or .dylib files. The JVM uses the Java Native Interface (JNI) to bridge calls between Java bytecode and these external binaries.

Customizing Object Representation with toString()

The toString() method is inherited from java.lang.Object, making it available to every class by default. Its standard implementation returns a string composed of the class name and the hexadecimal representation of the object’s hash code:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

When an object reference is passed directly to System.out.println(), the JVM implicitly invokes toString(). Thus, the following two statements are functionally equivalent:

• System.out.println(obj.toString());
• System.out.println(obj);

Overriding toString() enhances readability during debugging and logging. For example:

class EventTimestamp {
    private int hour;
    private int minute;
    private int second;

    public EventTimestamp() { this(0, 0, 0); }
    public EventTimestamp(int h, int m, int s) {
        this.hour = h; this.minute = m; this.second = s;
    }

    @Override
    public String toString() {
        return String.format("%02d:%02d:%02d", hour, minute, second);
    }
}

// Usage
EventTimestamp now = new EventTimestamp(14, 35, 42);
System.out.println(now); // Output: 14:35:42

Understanding super for Inheritance Control

The super keyword provides access to members of the immediate superclass. Like this, it appears in instance methods and constructors—but never in static contexts.

Key distinctions between this and super:

• this() delegates to another constructor within the same class; super() delegates to a constructor in the parent class.
• super.fieldName or super.methodName() is required when a subclass declares a field or method with the same name as one in its superclass—and the superclass version must be explicitly accessed.
• If no explicit this(...) or super(...) appears as the first statement in a constructor, the compiler inserts super() (i.e., a call to the superclass’s no-argument constructor).
• this(...) and super(...) cannot coexist in the same constructor.

Crucially, super is not an object reference—it does not hold memory addresses or point to instances. Instead, it serves as a syntactic mechanism to resolve bindings to superclass members at compile time. Attempting to print super directly results in a compilation error, confirming its not an expression yielding a value.