Understanding Encapsulation and Interfaces in Java

Objects represent concrete entities while classes define their types; an object contains state (data members) and behavior (methods). Inside an object, this accesses its members, and outside you use object.field or object.method().

Encapsulation and Interfaces

Encapsulation hides implementation details and exposes only a limited external interface, similar to how a flashlight hides its internal circuitry and offers only a switch and a charging port for user interaction, thereby improving usability and safety.

In Java, encapsulation is achieved through access modifiers:

public : member is visible externally and forms part of the class's interface.

private : member is hidden from external code and can only be used internally.

protected : (related to inheritance, discussed later).

The following code demonstrates these concepts:

public class Test {
    public static void main(String[] args) {
        Human aPerson = new Human(160);
        System.out.println(aPerson.getHeight());
        aPerson.growHeight(170);
        System.out.println(aPerson.getHeight());
        aPerson.repeatBreath(100);
    }
}

class Human {
    /** constructor */
    public Human(int h) {
        this.height = h;
        System.out.println("I'm born");
    }
    /** accessor */
    public int getHeight() {
        return this.height;
    }
    /** mutator */
    public void growHeight(int h) {
        this.height = this.height + h;
    }
    /** encapsulated, for internal use */
    private void breath() {
        System.out.println("hu...hu...");
    }
    /** call breath() */
    public void repeatBreath(int rep) {
        int i;
        for(i = 0; i < rep; i++) {
            this.breath();
        }
    }
    private int height; // encapsulated, for internal use
}

Only the public methods getHeight(), growHeight() and repeatBreath() are accessible from outside the Human class; the private field height and method breath() remain hidden.

If an external class tries to access aPerson.height, the compiler reports an error such as:

Test.java:6: height has private access in Human
System.out.println(aPerson.height);
               ^
1 error

This demonstrates why data members should generally be declared private and accessed through public getters/setters, protecting the internal state and allowing the class designer to enforce invariants.

Class Visibility

In a single .java file, only one class may be declared public. Other classes without the keyword have package‑level visibility, a topic covered in the package discussion.

Exercise

Encapsulate a Torch class that represents a flashlight. The public interface should include methods to turn the torch on/off and to charge it, while the internal state (e.g., battery level) remains private.

Summary

Encapsulation uses private and public modifiers to hide internal details and expose a clean interface, enhancing both usability and safety of Java classes.

Encapsulation and interfaces

private, public access modifiers

Original source: cnblogs.com/vamei/archive/2013/03/27/2982209.html