Ce este vizibilitatea în contextul programării Java…

În contextul Java (cunoscut și ca scop) vizibilitatea determină accesibilitatea unei variabile, metode, constructor sau clasă din alte părți ale programului. Este controlată de modificatorii de acces.

Java are patru niveluri de vizibilitate:

public: Accesibil de oriunde în interiorul și în afara pachetului.
protected: Accesibil în același pachet și în subclase (chiar și în pachete diferite).
Modul implicit (default sau package-private): Accesibil doar în interiorul aceluiași pachet. Nu este specificat explicit printr-un modificator.
private: Accesibil doar în interiorul aceleiași clase.

Modificator	Clasă	Pachet	Subclasă (în afara pachetului)	Orice clasă (în afara pachetului)
`public`	Da	Da	Da	Da
`protected`	Da	Da	Da	Nu
Default	Da	Da	Nu	Nu
`private`	Da	Nu	Nu	Nu

Utilizarea modificatorilor de vizibilitate joacă un rol important în încapsulare și controlul accesului la elementele programului.

Exemplu de utilizare a modificatorilor:

// Clasa A în pachetul com.example.package1
package com.example.package1;

public class ClassA {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // Modificator implicit
    private int privateVar;

    public void publicMethod() {
        // Poate accesa toate variabilele clasei ClassA
        System.out.println("Metodă publică în ClassA");
    }

    protected void protectedMethod() {
        System.out.println("Metodă protected în ClassA");
    }

    void defaultMethod() {
        System.out.println("Metodă implicită în ClassA");
    }

    private void privateMethod() {
        System.out.println("Metodă privată în ClassA");
    }

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, în interiorul clasei
        privateMethod(); // OK, în interiorul clasei
    }
}

// Clasa B în același pachet 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 (același pachet)
        objA.defaultVar = 30; // OK, implicit (același pachet)
        // objA.privateVar = 40; // Eroare de compilare, private
        objA.publicMethod(); // OK, public
        objA.protectedMethod(); // OK, protected (același pachet)
        objA.defaultMethod(); // OK, implicit (același pachet)
        // objA.privateMethod(); // Eroare de compilare, private
    }
}

// Clasa C într-un alt pachet com.example.package2
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC este o subclasă a ClassA
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, public
        protectedVar = 200; // OK, protected (subclasă, chiar și în alt pachet)
        // defaultVar = 300; // Eroare de compilare, implicit (alt pachet)
        // privateVar = 400; // Eroare de compilare, private

        publicMethod(); // OK, public
        protectedMethod(); // OK, protected (subclasă, chiar și în alt pachet)
        // defaultMethod(); // Eroare de compilare, implicit (alt pachet)
        // privateMethod(); // Eroare de compilare, private
    }
}

// Clasa D într-un alt pachet com.example.package2 (NU subclasă a 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; // Eroare de compilare, protected (alt pachet, nu subclasă)
        // objA.defaultVar = 3000; // Eroare de compilare, implicit (alt pachet)
        // objA.privateVar = 4000; // Eroare de compilare, private

        objA.publicMethod(); // OK, public
        // objA.protectedMethod(); // Eroare de compilare, protected (alt pachet, nu subclasă)
        // objA.defaultMethod(); // Eroare de compilare, implicit (alt pachet)
        // objA.privateMethod(); // Eroare de compilare, private
    }
}

Înțelegerea vizibilității ajută la crearea unui cod mai fiabil și modular, limitând accesul nedorit la detaliile interne ale claselor.

Ce este vizibilitatea în contextul programării Java?