Access Control in Java

Access control in Java is a mechanism that controls the visibility and accessibility of class members (fields, methods, and constructors) and class inheritance. It allows developers to specify which class members are visible to other classes and which are not. This is an important aspect of object-oriented programming as it helps to protect the internal state of a class from being accessed or modified by external classes.

Java provides four access modifiers: public, private, protected, and the default (no keyword). These access modifiers can be applied to class members as well as class inheritance.

public

The public modifier allows a class member to be accessed by any other class, regardless of the package in which it is defined.

private

The private modifier allows a class member to be accessed only by other members of the same class. This is the most restrictive access modifier and is used to protect the internal state of a class.

protected

The protected modifier allows a class member to be accessed by other classes in the same package or by subclasses of the class in which it is defined. This is useful when creating a class hierarchy and we want to allow subclasses to access certain class members of the superclass.

default

The default modifier, also known as package-private, allows a class member to be accessed by any class in the same package, but not by classes in other packages.

It’s important to note that the access control modifiers apply to the class members and not the class itself. A class can be declared public, but its members can still have different levels of access control.

Following is an example of how access control modifiers can be used in a Java class:

public class MyClass {
    private int privateField;
    protected int protectedField;
    public int publicField;
    int defaultField;

    private void privateMethod() {
        // code goes here
    }

    protected void protectedMethod() {
        // code goes here
    }

    public void publicMethod() {
        // code goes here
    }

    void defaultMethod() {
        // code goes here
    }
}

In this example, the privateField can only be accessed by other members of the MyClass class, the protectedField can be accessed by other members of the MyClass class and by subclasses of MyClass, the publicField can be accessed by any class, and the defaultField can be accessed by any class in the same package. The same access control rules apply to the methods in this class.

It’s important to use access control in Java appropriately to ensure that the internal state of a class is protected and to prevent unintended modification. By using the correct access modifier, we can create a well-structured and maintainable codebase.