1. Privát hozzáférés módosító
2. Magánépítő szerepe
3. Alapértelmezett hozzáférés módosító
4. Védett hozzáférés módosító
5. Nyilvános hozzáférés módosító
6. Hozzáférés módosító metódus felülbírálással

A Java-ban kétféle módosító létezik: hozzáférés módosítók és hozzáférést tiltó módosítók .

A Java hozzáférés-módosítói egy mező, metódus, konstruktor vagy osztály elérhetőségét vagy hatókörét határozzák meg. A mezők, konstruktorok, metódusok és osztályok hozzáférési szintjét módosíthatjuk a hozzáférés módosító alkalmazásával.

Négyféle Java hozzáférés-módosító létezik:

Magán: A privát módosító hozzáférési szintje csak az osztályon belül van. Az osztályon kívülről nem érhető el.Alapértelmezett: Az alapértelmezett módosító hozzáférési szintje csak a csomagon belül van. A csomagon kívülről nem érhető el. Ha nem ad meg hozzáférési szintet, akkor ez lesz az alapértelmezett.Védett: A védett módosító hozzáférési szintje a csomagon belül és a csomagon kívül található gyermekosztályon keresztül. Ha nem a gyermek osztályt csinálja, akkor a csomagon kívülről nem érhető el.Nyilvános: A nyilvános módosító hozzáférési szintje mindenhol megtalálható. Elérhető az osztályon belülről, az osztályon kívülről, a csomagon belül és a csomagon kívülről.

Számos nem hozzáférés-módosító létezik, például statikus, absztrakt, szinkronizált, natív, volatile, tranziens stb. Itt csak a hozzáférés-módosítókat fogjuk megtanulni.

A Java hozzáférés-módosítók megértése

Ismerjük meg a Java hozzáférés-módosítóit egy egyszerű táblázat segítségével.

1) Privát

A privát hozzáférés módosító csak az osztályon belül érhető el.

blokkolt számok

A privát hozzáférés módosító egyszerű példája

Ebben a példában két A és Simple osztályt hoztunk létre. Egy osztály privát adattagot és privát metódust tartalmaz. Ezeket a privát tagokat az osztályon kívülről érjük el, ezért fordítási idő hiba történt.

 class A{ private int data=40; private void msg(){System.out.println('Hello java');} } public class Simple{ public static void main(String args[]){ A obj=new A(); System.out.println(obj.data);//Compile Time Error obj.msg();//Compile Time Error } } 

A magánépítő szerepe

Ha bármely osztálykonstruktort priváttá tesz, akkor az adott osztály példányát nem hozhatja létre az osztályon kívülről. Például:

 class A{ private A(){}//private constructor void msg(){System.out.println('Hello java');} } public class Simple{ public static void main(String args[]){ A obj=new A();//Compile Time Error } } 

Megjegyzés: Egy osztály nem lehet privát vagy védett, kivéve a beágyazott osztályt.

2) Alapértelmezett

Ha nem használ semmilyen módosítót, akkor a rendszer a következőként kezeli alapértelmezett alapértelmezés szerint. Az alapértelmezett módosító csak a csomagon belül érhető el. A csomagon kívülről nem érhető el. Több hozzáférést biztosít, mint a privát. De inkább korlátozó, mint védett, és nyilvános.

csonkolja és törölje a különbséget

Példa az alapértelmezett hozzáférés-módosítóra

Ebben a példában két csomagot hoztunk létre pack és mypack. Az A osztályt a csomagján kívülről érjük el, mivel az A osztály nem publikus, így a csomagon kívülről nem érhető el.

 //save by A.java package pack; class A{ void msg(){System.out.println('Hello');} } 

 //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A();//Compile Time Error obj.msg();//Compile Time Error } } 

A fenti példában az A osztály hatóköre és a hozzá tartozó msg() metódus az alapértelmezett, így a csomagon kívülről nem érhető el.

3) Védett

A védett hozzáférés módosító elérhető a csomagon belül és a csomagon kívül, de csak örökléssel.

A védett hozzáférés módosító az adattagon, metóduson és konstruktoron alkalmazható. Az osztályban nem alkalmazható.

Több hozzáférést biztosít, mint az alapértelmezett módosító.

Példa védett hozzáférés-módosítóra

powershell kisebb vagy egyenlő

Ebben a példában létrehoztuk a két csomag csomagot és a mypack csomagot. Az A osztályú csomagcsomag nyilvános, így a csomagon kívülről is elérhető. De ennek a csomagnak az msg metódusa védettnek van deklarálva, így az osztályon kívülről csak örökléssel érhető el.

 //save by A.java package pack; public class A{ protected void msg(){System.out.println('Hello');} } 

 //save by B.java package mypack; import pack.*; class B extends A{ public static void main(String args[]){ B obj = new B(); obj.msg(); } } 

 Output:Hello 

4) Nyilvános

A nyilvános hozzáférés módosító mindenhol elérhető. A legszélesebb hatókörrel rendelkezik az összes többi módosító közül.

Példa a nyilvános hozzáférés módosítójára

 //save by A.java package pack; public class A{ public void msg(){System.out.println('Hello');} } 

 //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A(); obj.msg(); } } 

 Output:Hello 

Java hozzáférés-módosítók módszerfelülbírálással

Ha bármelyik metódust felülbírálja, a felülbírált metódus (azaz az alosztályban deklarált) nem lehet szigorúbb.

 class A{ protected void msg(){System.out.println('Hello java');} } public class Simple extends A{ void msg(){System.out.println('Hello java');}//C.T.Error public static void main(String args[]){ Simple obj=new Simple(); obj.msg(); } } 

Az alapértelmezett módosító inkább korlátozó, mint védett. Ezért van egy fordítási idő hiba.