Access Modifiers

Access modifiers control the visibility and accessibility of classes, methods, and fields.

Types of Access Modifiers

Modifier	Class	Package	Subclass	World
public	Yes	Yes	Yes	Yes
protected	Yes	Yes	Yes	No
default (no modifier)	Yes	Yes	No	No
private	Yes	No	No	No

Public

The public modifier makes a class, method, or field accessible from any other class:

public class User {
  public String username;

  public User(String username) {
    this.username = username;
  }

  public void display() {
    System.out.println(username);
  }
}

Protected

The protected modifier makes a method or field accessible within:

• The same class
• Classes in the same package
• Subclasses (even in different packages)

public class Person {
  protected String name;

  protected void showDetails() {
    System.out.println("Name: " + name);
  }
}

class Student extends Person {
  public void display() {
    // Can access protected members from parent
    showDetails();
    System.out.println("Student name: " + name);
  }
}

Default (Package-Private)

When no access modifier is specified, it defaults to “package-private”:

• Accessible within the same class and package
• Not accessible from outside the package

package com.example;

class Helper {
  void utility() {
    // Implementation
  }
}

// In the same package
class Main {
  void method() {
    Helper helper = new Helper();
    helper.utility(); // Accessible
  }
}

Private

The private modifier restricts access to within the same class only:

public class BankAccount {
  private double balance;

  public BankAccount(double initialAmount) {
    this.balance = initialAmount;
  }

  private void validateTransaction(double amount) {
    if (amount <= 0) {
      throw new IllegalArgumentException("Amount must be positive");
    }
  }

  public void deposit(double amount) {
    validateTransaction(amount);
    balance += amount;
  }

  public double getBalance() {
    return balance;
  }
}

Access Modifiers for Classes

• Classes can be declared as public or with default access (package-private)
• private and protected modifiers are not allowed for top-level classes
• Inner classes can use all access modifiers

public class PublicClass {
  // Accessible from anywhere
}

class PackageClass {
  // Accessible only within the same package
}

public class OuterClass {
  private class PrivateInnerClass {
    // Accessible only within OuterClass
  }

  protected class ProtectedInnerClass {
    // Accessible within OuterClass, same package, and subclasses of OuterClass
  }
}

Best Practices

1. Encapsulation: Make fields private and provide public getter/setter methods
2. Minimize Visibility: Use the most restrictive access modifier possible
3. Public APIs: Carefully design public interfaces as they become part of your API contract
4. Package Structure: Organize classes by functionality into packages to leverage package-private access
5. Protected for Extension: Use protected for members intended to be accessed or overridden by subclasses