14.6. Access Control in Packages

Java uses access modifiers to control the visibility of classes, methods, and variables. The main access levels include:

1. Public: The class or member can be accessed from any other class.
2. Private: The class or member is accessible only within the class itself.
3. Protected: The class or member is accessible within the package and by subclasses.
4. Default (Package-Private): The class or member is accessible only within the same package (no modifier specified).

Access modifiers in Java determine how accessible a class, method, or variable is throughout the program. Understanding these modifiers helps developers effectively control which parts of their code can interact with each other.

• Public: Any class can access public members. For example, if a class has a public method, any other class in the application can call that method.
• Private: When a member is marked as private, only the defining class can access it. This is crucial for hiding internal implementation details and protecting data.
• Protected: This modifier allows members to be accessible within the same package and also by subclasses, even if they are in different packages. This supports inheritance while still restricting access from other classes.
• Default (Package-Private): If no modifier is specified, the member is accessible only to other classes in the same package, offering a way to keep members hidden.

Think of an office building as a Java package. Classes are the offices inside the building. A public member is like an open door that anyone can walk through. A private member is like a locked office door that only the employee can access. A protected member is like a door that can be accessed by employees in the same department (subclasses) and limited visitors (subclasses in different packages). Lastly, a default member can be accessed by any employee within the same building (package) only.

Example:

package com.example.util;
public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
    private static int multiply(int a, int b) {
        return a * b; // This can only be accessed within the MathUtils class
    }
}

In this example:

• The add() method is public and can be accessed from outside the MathUtils class.
• The multiply() method is private and can only be accessed within the MathUtils class.

The provided code snippet defines a class MathUtils in the package com.example.util. Within this class, there are two methods: add() and multiply().

• The add() method is declared as public, which means any class that imports MathUtils can call the method to add two numbers.
• The multiply() method is declared as private, which means it is shielded from outside access. This method can only be called within the MathUtils class itself, ensuring that no outside class can tamper with it directly. Thus, the internal workings of this utility remain secure and are not exposed.

Imagine a restaurant. The public methods in a class can be thought of as the menu items available to customers; anyone can order (access) them. In contrast, the private methods are like the kitchen’s recipe for a dish; only the chefs (the class itself) know how to prepare it, and customers have no access to that information. This ensures that the restaurant can maintain its unique taste and customer satisfaction by keeping its recipes secret.

--