Ebben az oktatóanyagban példák segítségével megismerhetjük a Java Access Modifier programot, annak típusait és használatát.
Mik azok a hozzáférés-módosítók?
A Java-ban hozzáférés-módosítókat használnak az osztályok, interfészek, változók, módszerek, konstruktorok, adattagok és a beállító módszerek hozzáférhetőségének (láthatóságának) beállítására. Például,
class Animal ( public void method1() (… ) private void method2() (… ) )
A fenti példában 2 metódust deklaráltunk: method1 () és method2 (). Itt,
- A method1 is
public- Ez azt jelenti, hogy más osztályok is elérhetik. - A method2 is
private- Ez azt jelenti, hogy más osztályok nem férhetnek hozzá.
Jegyezze fel a kulcsszót publicés private. Ezek a Java hozzáférés-módosítói. Láthatóság-módosítóként is ismertek.
Megjegyzés : A getters módszerek hozzáférés-módosítóját nem lehet beállítani.
Az Access Modifier típusai
Mielőtt megismerné a hozzáférés-módosítók típusait, győződjön meg arról, hogy ismeri a Java csomagokat.
Négy hozzáférés-módosító kulcsszó van a Java-ban, ezek a következők:
| Módosító | Leírás |
| Alapértelmezett | a nyilatkozatok csak a csomagon belül láthatók (private private) |
| Magán | a deklarációk csak az osztályon belül láthatók |
| Védett | a deklarációk a csomagban vagy az összes alosztályon belül láthatók |
| Nyilvános | nyilatkozatok mindenütt láthatók |
Alapértelmezett hozzáférés-módosító
Ha nem határozunk meg kifejezetten hozzáférés-módosítót az osztályokhoz, módszerekhez, változókhoz stb., Akkor alapértelmezés szerint az alapértelmezett hozzáférés-módosítót vesszük figyelembe. Például,
package defaultPackage; class Logger ( void message()( System.out.println("This is a message"); ) )
Itt a Logger osztály rendelkezik az alapértelmezett hozzáférés-módosítóval. Az osztály pedig látható minden olyan osztály számára, amely az defaultPackage csomaghoz tartozik. Ha azonban megpróbáljuk a Logger osztályt egy másik osztályban használni az defaultPackage-en kívül, akkor fordítási hibát kapunk.
Privát hozzáférés módosító
A változók és metódusok deklarálásakor privateaz osztályon kívül nem lehet hozzájuk hozzáférni. Például,
class Data ( // private variable private String name; ) public class Main ( public static void main(String() main)( // create an object of Data Data d = new Data(); // access private variable and field from another class d.name = "Programiz"; ) )
A fenti példában deklaráltunk egy privát változó nevet és egy privát metódust display(). A program futtatásakor a következő hibát kapjuk:
Main.java:18: error: name has private access in Data d.name = "Programiz"; ^
A hiba azért keletkezik, mert megpróbáljuk elérni a Data osztály privát változóját és privát metódusát a Main osztályból.
Kíváncsi lehet, mi van, ha hozzáférnünk kell ezekhez a privát változókhoz. Ebben az esetben használhatjuk a getters and setters módszert. Például,
class Data ( private String name; // getter method public String getName() ( return this.name; ) // setter method public void setName(String name) ( this.name= name; ) ) public class Main ( public static void main(String() main)( Data d = new Data(); // access the private variable using the getter and setter d.setName("Programiz"); System.out.println(d.getName()); ) )
Kimenet :
A neve Programiz
A fenti példában van egy privát változó, amelynek neve van. Annak érdekében, hogy a változót a külső osztályból lehessen elérni, módszereket használtunk: getName()és setName(). Ezeket a módszereket Java-ban getternek és setter-nek hívják.
Itt a setter metódust ( setName()) használtuk a változó értékének hozzárendeléséhez, a getter metódust ( getName()) pedig a változó eléréséhez.
A thissetName () belsejében használt kulcsszót használtuk az osztály változójára. Ha többet szeretne megtudni erről a kulcsszóról, keresse fel a Java this Keyword webhelyet.
Megjegyzés : Nem nyilváníthatjuk privátnak az osztályokat és az interfészeket a Java-ban. A beágyazott osztályokat azonban privátnak nyilváníthatjuk. Ha többet szeretne megtudni, látogasson el a Java beágyazott és belső osztályára.
Védett hozzáférés-módosító
A metódusok és az adattagok deklarálásakor protectedhozzáférhetünk hozzájuk ugyanabban a csomagban, mint alosztályokból. Például,
class Animal ( // protected method protected void display() ( System.out.println("I am an animal"); ) ) class Dog extends Animal ( public static void main(String() args) ( // create an object of Dog class Dog dog = new Dog(); // access protected method dog.display(); ) )
Kimenet :
Állat vagyok
A fenti példában van egy védett módszerünk, amelyet display()az Animal osztályon belül nevezünk el. Az Animal osztályt a Dog osztály örökli. Ha többet szeretne megtudni az öröklésről, látogasson el a Java öröklődésre.
We then created an object dog of the Dog class. Using the object we tried to access the protected method of the parent class.
Since protected methods can be accessed from the child classes, we are able to access the method of Animal class from the Dog class.
Note: We cannot declare classes or interfaces protected in Java.
Public Access Modifier
When methods, variables, classes, and so on are declared public, then we can access them from anywhere. The public access modifier has no scope restriction. For example,
// Animal.java file // public class public class Animal ( // public variable public int legCount; // public method public void display() ( System.out.println("I am an animal."); System.out.println("I have " + legCount + " legs."); ) ) // Main.java public class Main ( public static void main( String() args ) ( // accessing the public class Animal animal = new Animal(); // accessing the public variable animal.legCount = 4; // accessing the public method animal.display(); ) )
Output:
I am an animal. I have 4 legs.
Here,
- The public class Animal is accessed from the Main class.
- The public variable legCount is accessed from the Main class.
- The public method
display()is accessed from the Main class.
Access Modifiers Summarized in one figure
Az összes hozzáférés-módosító hozzáférhetősége a Java-ban
A hozzáférés-módosítókat főként kapszulázásra használják. Segíthetek nekünk annak ellenőrzésében, hogy a program mely része érheti el az osztály tagjait. Így megakadályozható az adatokkal való visszaélés. Ha többet szeretne megtudni a tokozásról, látogasson el a Java beágyazás oldalára.
