In Java, what is the difference among public, protected and package access data members?

Introduction / Context:
In Java, access modifiers control how fields and methods can be seen and used by other classes. Understanding the difference among public, protected and package access (also called default access) is essential for encapsulation, designing clean APIs and securing internal implementation details. This question tests your knowledge of how these three levels of access apply specifically to data members inside a class and how far they are visible across packages and subclasses.

Given Data / Assumptions:
- We are working with Java classes and objects in a typical multi package project.
- The data members in question are instance or static fields declared with public, protected or no explicit modifier (package access).
- We assume normal use of classes in the same package, different packages and subclass relationships.
- We focus on visibility rules, not on other modifiers like private, final or static.

Concept / Approach:
Java provides four basic access levels: public, protected, package access (no modifier) and private. Public gives the widest visibility, private the narrowest. Protected and package access are in the middle. The key idea is to reason about three axes of visibility: inside the same class, inside other classes in the same package and in classes that are subclasses located in other packages. By comparing where each modifier allows access, we can pick the option that describes the rules accurately and completely without contradictions.

Step-by-Step Solution:
Step 1: Recall that public members are visible from any other class, in any package, as long as the class itself is visible. Step 2: Remember that protected members are visible inside the same package and also in subclasses, even if the subclass is in a different package. Step 3: Package access (no modifier) means members are visible only to classes in the same package and are not visible in subclasses located in other packages. Step 4: Compare these rules with the wording of each option and look for one option that mentions all three levels correctly and in a single consistent sentence. Step 5: Option A states that public members are visible everywhere, protected members are visible in the same package and in subclasses, and package access members are visible only within the same package, which matches the Java rules exactly.

Verification / Alternative check:
A quick way to verify is to imagine three classes: one in the same package, one in a different package that is not a subclass, and one in a different package that extends the original class. For public, all three should have access. For protected, the same package class and the subclass in another package should have access, but the unrelated class in another package should not. For package access members, only the same package class should be able to access the field. These mental checks align perfectly with the description in option A, confirming it is correct.

Why Other Options Are Wrong:
Option B incorrectly claims that public and protected members are visible only within the same package, which contradicts the definition of public and protected.
Option C wrongly says that public members are visible only inside the same class and package access members are visible only in subclasses, both of which are incorrect.
Option D states that all three are visible everywhere without restriction, which ignores the stricter rules for protected and package access members.

Common Pitfalls:
A common mistake is to confuse protected with package access and assume they are equivalent. Another pitfall is to think that protected members are visible to all classes in other packages, which is not true; they are visible only to subclasses in those packages. Students also sometimes forget that the class visibility itself can further restrict access, even if a member is public. Carefully distinguishing the roles of public, protected and package access ensures better class design and prevents accidental exposure of internal state.

Final Answer:
The correct statement is public members are visible everywhere, protected members are visible in the same package and in subclasses, and package access members are visible only within the same package.