Java | Access modifiers (public, private, protected)

In Java, access modifiers are used to define the scope and accessibility of variables, methods, and classes. There are four access modifiers in Java: public, private, protected, and the default (package-private) access modifier.

Here is a breakdown of each access modifier and how they work in Java:

public: This access modifier makes the variable, method, or class accessible to all classes and packages.

public class MyClass {
    public int myPublicVariable = 1;
    
    public void myPublicMethod() {
        System.out.println("This is a public method.");
    }
}

private: This access modifier makes the variable, method, or class accessible only within the same class.

public class MyClass {
    private int myPrivateVariable = 2;
    
    private void myPrivateMethod() {
        System.out.println("This is a private method.");
    }
}

protected: This access modifier makes the variable, method, or class accessible within the same class and subclasses.

public class MyClass {
    protected int myProtectedVariable = 3;
    
    protected void myProtectedMethod() {
        System.out.println("This is a protected method.");
    }
}

Default (package-private) access modifier: If you do not specify an access modifier, the default access modifier is used. This makes the variable, method, or class accessible within the same package.

class MyClass {
    int myDefaultVariable = 4;
    
    void myDefaultMethod() {
        System.out.println("This is a default method.");
    }
}

It’s important to note that access modifiers only apply to class members, not to classes themselves. In addition, it is considered good practice to use access modifiers to encapsulate your code and prevent unintended access or modification.

Here is an example of how access modifiers can be used in a class:

public class MyMainClass {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();

        // Accessing public members
        int publicVariable = myObject.myPublicVariable;
        myObject.myPublicMethod();

        // Accessing private members
        // This will produce a compile error
        // int privateVariable = myObject.myPrivateVariable;
        // myObject.myPrivateMethod();

        // Accessing protected members
        int protectedVariable = myObject.myProtectedVariable;
        myObject.myProtectedMethod();

        // Accessing default members
        // This will produce a compile error
        // int defaultVariable = myObject.myDefaultVariable;
        // myObject.myDefaultMethod();
    }
}

In this example, we create an instance of the MyClass class and demonstrate how each access modifier can be used to access its members. Note that attempting to access a private or default member outside of its class will result in a compile error.

Access modifiers are an essential part of object-oriented programming, as they allow you to control access to class members and enforce encapsulation. Proper use of access modifiers can also make code more secure and easier to maintain, as it limits the scope of variables and methods to only what is necessary.

One common practice in Java is to use private access modifiers for variables and methods that are only used internally within a class, and public access modifiers for variables and methods that are used by other classes. This allows you to create a public interface for your class while keeping the implementation details private.

In addition to the access modifiers discussed here, there are also access modifiers for classes themselves, which determine the accessibility of the class itself. These access modifiers are public and default, and function in a similar way to the access modifiers for class members.

It’s important to note that access modifiers can be overridden by inheritance. When a subclass inherits a member from a superclass, it can use the same access modifier or choose to make it more accessible (e.g. protected to public), but it cannot make it less accessible (e.g. public to private).

In summary, access modifiers are an important part of Java programming and are used to control the scope and accessibility of variables, methods, and classes. By using access modifiers correctly, you can create well-structured and maintainable code, while also ensuring that your code is secure and properly encapsulated.

Leave a Reply Cancel reply