Sobes.tech
Junior

What is visibility in the context of Java programming?

sobes.tech AI

Answer from AI

Visibility in Java (also called scope) determines the accessibility of variables, methods, constructors, or classes from other parts of the program. It is controlled by access modifiers.

Java has four levels of visibility:

  1. public: Accessible from anywhere inside and outside the package.
  2. protected: Accessible within the same package and in subclasses (even in other packages).
  3. Default (package-private): Accessible only within the same package. Not explicitly specified by a modifier.
  4. private: Accessible only within the same class.
Modifier Class Package Subclass (outside package) Any class (outside package)
public Yes Yes Yes Yes
protected Yes Yes Yes No
Default Yes Yes No No
private Yes No No No

Applying visibility modifiers plays an important role in encapsulation and access control.

Example of using modifiers:

// Class A in package com.example.package1
package com.example.package1;

public class ClassA {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // Default modifier
    private int privateVar;

    public void publicMethod() {
        // Can access all variables of ClassA
        System.out.println("Public method in ClassA");
    }

    protected void protectedMethod() {
        System.out.println("Protected method in ClassA");
    }

    void defaultMethod() {
        System.out.println("Default method in ClassA");
    }

    private void privateMethod() {
        System.out.println("Private method in ClassA");
    }

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, access within class
        privateMethod(); // OK, access within class
    }
}
// Class B in the same package com.example.package1
package com.example.package1;

public class ClassB {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 10; // OK, public
        objA.protectedVar = 20; // OK, protected (same package)
        objA.defaultVar = 30; // OK, default (same package)
        // objA.privateVar = 40; // Compilation error, private
        objA.publicMethod(); // OK, public
        objA.protectedMethod(); // OK, protected (same package)
        objA.defaultMethod(); // OK, default (same package)
        // objA.privateMethod(); // Compilation error, private
    }
}
// Class C in another package com.example.package2
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC is a subclass of ClassA
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, public
        protectedVar = 200; // OK, protected (subclass, even in another package)
        // defaultVar = 300; // Compilation error, default (different package)
        // privateVar = 400; // Compilation error, private

        publicMethod(); // OK, public
        protectedMethod(); // OK, protected (subclass, even in another package)
        // defaultMethod(); // Compilation error, default (different package)
        // privateMethod(); // Compilation error, private
    }
}
// Class D in another package com.example.package2 (NOT a subclass of ClassA)
package com.example.package2;
import com.example.package1.ClassA;

public class ClassD {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 1000; // OK, public
        // objA.protectedVar = 2000; // Compilation error, protected (different package, not a subclass)
        // objA.defaultVar = 3000; // Compilation error, default (different package)
        // objA.privateVar = 4000; // Compilation error, private

        objA.publicMethod(); // OK, public
        // objA.protectedMethod(); // Compilation error, protected (different package, not a subclass)
        // objA.defaultMethod(); // Compilation error, default (different package)
        // objA.privateMethod(); // Compilation error, private
    }
}

Understanding visibility helps create more reliable and modular code, limiting unwanted access to internal class details.

What is visibility in the context of Java… - sobes.tech