Mi az láthatóság a Java programozás kontextusában?

A Java kontextusában (más néven láthatósági terület) a láthatóság meghatározza egy változó, metódus, konstruktor vagy osztály elérhetőségét a program más részeiről. Ezt a hozzáférési módosítók szabályozzák.

Java négy láthatósági szintet tartalmaz:

1. public: Bármilyen helyről elérhető a csomagon belül és kívül.
2. protected: A csomagon belül és az alosztályokban (még más csomagokban is) elérhető.
3. Alapértelmezett mód (default vagy package-private): Csak ugyanazon csomagon belül elérhető. Nincs kifejezetten megadva módosítóval.
4. private: Csak ugyanazon osztályon belül elérhető.

Módosító	Osztály	Csomag	Alosztály (más csomagban)	Bármely osztály (más csomagban)
public	Igen	Igen	Igen	Igen
protected	Igen	Igen	Igen	Nem
Alapértelmezett	Igen	Igen	Nem	Nem
private	Igen	Nem	Nem	Nem

A láthatósági módosítók használata fontos szerepet játszik az inkapszulációban és a hozzáférés szabályozásában a program elemeihez.

Példa a láthatósági módosítók használatára:

// Az A osztály a com.example.package1 csomagban
package com.example.package1;

public class ClassA {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // Alapértelmezett módosító
    private int privateVar;

    public void publicMethod() {
        // Hozzáférhet az összes változóhoz az osztályban
        System.out.println("Nyilvános metódus az ClassA-ban");
    }

    protected void protectedMethod() {
        System.out.println("Védett metódus az ClassA-ban");
    }

    void defaultMethod() {
        System.out.println("Alapértelmezett metódus az ClassA-ban");
    }

    private void privateMethod() {
        System.out.println("Privát metódus az ClassA-ban");
    }

    public void accessMembers() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4; // OK, az osztályon belül
        privateMethod(); // OK, az osztályon belül
    }
}

// A osztály ugyanabban a csomagban, mint az ClassA
package com.example.package1;

public class ClassB {
    public void accessClassAMembers(ClassA objA) {
        objA.publicVar = 10; // OK, public
        objA.protectedVar = 20; // OK, protected (azon csomag)
        objA.defaultVar = 30; // OK, default (azon csomag)
        // objA.privateVar = 40; // Hibás fordítás, private
        objA.publicMethod(); // OK, public
        objA.protectedMethod(); // OK, protected (azon csomag)
        objA.defaultMethod(); // OK, default (azon csomag)
        // objA.privateMethod(); // Hibás fordítás, private
    }
}

// Egy másik csomagban, a com.example.package2-ben, ClassC
package com.example.package2;
import com.example.package1.ClassA;

public class ClassC extends ClassA { // ClassC az osztálya ClassA-nak
    public void accessClassAMembersFromSubclass() {
        publicVar = 100; // OK, public
        protectedVar = 200; // OK, protected (alosztály, még más csomagban)
        // defaultVar = 300; // Fordítási hiba, default (más csomag)
        // privateVar = 400; // Fordítási hiba, private

        publicMethod(); // OK, public
        protectedMethod(); // OK, protected (alosztály, más csomag)
        // defaultMethod(); // Fordítási hiba, default (más csomag)
        // privateMethod(); // Fordítási hiba, private
    }
}

// Egy másik csomagban, a com.example.package2-ben, ClassD
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; // Fordítási hiba, protected (más csomag, nem alosztály)
        // objA.defaultVar = 3000; // Fordítási hiba, default (más csomag)
        // objA.privateVar = 4000; // Fordítási hiba, private

        objA.publicMethod(); // OK, public
        // objA.protectedMethod(); // Fordítási hiba, protected (más csomag, nem alosztály)
        // objA.defaultMethod(); // Fordítási hiba, default (más csomag)
        // objA.privateMethod(); // Fordítási hiba, private
    }
}

A láthatóság megértése segít megbízhatóbb és modulárisabb kódok létrehozásában, korlátozva a nem kívánt hozzáférést az osztályok belső részleteihez.