Access Modifiers in Java

🔐 Access Modifiers in Java

In object-oriented programming, controlling the visibility of classes, methods, and variables is critical for building secure and maintainable applications. This is where Access Modifiers in Java come into play. They determine how different parts of your code can be accessed from other parts of your project — or even from different packages. Let's break down the types of access modifiers and learn how to use them effectively.

📘 What are Access Modifiers?

Access modifiers are keywords in Java used to set the accessibility (or scope) of classes, constructors, methods, and variables. They help in enforcing **encapsulation**, one of the key principles of OOP. Java provides four access levels: public, private, protected, and **default** (no keyword).

🌍 public Access Modifier

When a class member is declared as public, it can be accessed from anywhere — inside the same class, from different classes, even across different packages.

public class Demo {
    public int number = 10;

    public void show() {
        System.out.println("Accessible everywhere.");
    }
}

🔒 private Access Modifier

The private modifier restricts access to within the same class only. This is commonly used for sensitive data and helper methods that should not be exposed externally.

public class Account {
    private double balance = 1000.0;

    private void displayBalance() {
        System.out.println("Balance: " + balance);
    }
}

Note: Private members are not accessible even by subclasses.

🧪 default (Package-Private) Access Modifier

When no access modifier is specified, the default access level is applied. This means the member is accessible only within the same package. It's often used when you want to allow sharing between closely related classes but not outside the package.

class Car {
    void engineStart() {
        System.out.println("Engine starting...");
    }
}

🛡️ protected Access Modifier

The protected modifier allows access within the same package and also by subclasses, even if they're in different packages. It’s commonly used in inheritance to expose internal functionality to child classes while hiding it from the rest.

public class Animal {
    protected void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void bark() {
        makeSound();  // Accessible because it's protected
    }
}

📊 Summary Table of Access Levels

💡 Best Practices

• Keep fields private and expose them via getters/setters.
• Use protected for extensibility through inheritance.
• Use default to expose functionality within the package.
• Public should be used for APIs or methods meant for wide access.

🚀 Conclusion

Mastering Access Modifiers in Java is vital for writing clean, secure, and maintainable code. They give you control over what’s exposed and what stays internal — an essential part of robust object-oriented design. By choosing the right access level for each class and member, you build better software that scales with confidence.