Mindannyian tudjuk, hogy az országoknak vannak határai és saját törvényeik. Az ország törvényei a határokon belül működnek. Az országban is vannak például olyan szervezetek, mint például iskolák vagy múzeumok, amelyek saját helyi szabályokkal rendelkeznek. Nem mondanak ellent az ország törvényeinek, csak a meghatározott szervezet keretein belül működnek. Ugyanez igaz a programozásra is. Tehát a programozásban, és különösen a Java nyelvben van egy "hatókör" kifejezés. A program azon területeire utal, ahol bizonyos adatok, például változók vagy módszerek működnek. Ebben a cikkben azt fogjuk kitalálni, hogy milyen hatókörei vannak a Java változóinak, és hogyan definiáljuk őket.
Java hatókör általában
Miért van szükség a változók és a módszerek hatókörének elkülönítésére? Az a tény, hogy néha a programok nagyon nagyok, és nehéz lehet követni egyik vagy másik változót. Ezenkívül a nagy projekteknél kívánatos a változók egyértelmű elnevezése, hogy világos legyen, mire valók. A Scope kifejezetten lehetővé teszi, hogy a program különböző részein különböző változók legyenek azonos névvel. Az ilyen kód könnyebben karbantartható és olvasható. A Java hatóköre meghatározza, hogy egy adott változó vagy metódus hol érhető el egy programban. Röviden:
A metódusban deklarált változó a deklaráció elejétől a metódus végéig látható (metódus hatóköre).
A kódblokkban deklarált változó a kódblokk végéig létezik.
A metódus argumentumainak számító változók a metódus végéig léteznek.
Az osztály/objektum változók a tartalmazó objektum élettartama alatt léteznek. Láthatóságukat speciális hozzáférésmódosítók szabályozzák.
A statikus osztályváltozók a program futása közben mindig léteznek. Láthatóságukat is hozzáférésmódosítók határozzák meg.
Módszer szintű hatókör
A metódusban deklarált változók, beleértve az argumentumokat is, nem érhetők el azon a metóduson kívül. A metódusokon belül deklarált összes változó látható a deklaráció elejétől a metódus végéig. Íme egy példa a metódus változó hatókörére:
public class JScopeTest1 {
public static void main(String[] args) {
System.out.println(myMethod(5));
System.out.println(myMethod(17));
}
public static int myMethod(int arg) {
int secondArg = 100; //local method variable
return secondArg + arg;
}
}
Itt van secondArg , egy lokális változó vagy metódus argumentum. Ezt a változót nem használhatjuk a myMethod metóduson kívül vagy a deklarálás előtt. Ha egy változó egy függvény argumentum, akkor a metódus teljes törzsében látható. A fenti példában két ilyen argumentum van: arg a myMethodban és args a main metódusban.
Osztályszintű hatókör
Osztályszintű hatókör (példányváltozók) – az osztályban deklarált bármely változó elérhető az adott osztály összes metódusához. A hozzáférés-módosítójától függően (pl. nyilvános vagy privát), néha az osztályon kívül is elérhető. Tehát ha egy változó egy osztályváltozó, akkor egy adott objektumhoz van kötve, és addig létezik, amíg van egy objektum ebből az osztályból. Ha nincs objektum, akkor nincs másolata a változónak. A változó az osztály összes metódusából látható, függetlenül attól, hogy előtte vagy utána deklarálva vannak. Minden objektumnak megvan a maga változója, amely független a többi objektumtól. A statikus metódusokból nem érhető el egy változó.
Kódpélda
public class Student {
//class level variables
public String surname;
String name;
String secondName;
private Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases
public Student(String surname, String name, String secondName, Date birthday ){
this.surname = surname;
this.name = name;
this.secondName = secondName;
this.birthday = birthday == null ? 0 : birthday.getTime();
}
@Override
public int hashCode(){
//TODO: check for nulls
//return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
return (surname + name + secondName + birthday).hashCode();
}
@Override
public boolean equals(Object other_) {
Student other = (Student)other_;
return (surname == null || surname.equals(other.surname) )
&& (name == null || name.equals(other.name))
&& (secondName == null || secondName.equals(other.secondName))
&& (birthday == null || birthday.equals(other.birthday));
}
}
Vezetéknév , név , második név és születésnap példányváltozók.
Blokk hatóköre
Ha egy változót definiálunk/deklarálunk valamelyik kódblokkban, akkor az adott kódblokk végéig létezik. Általában az ilyen változók a definiált kapcsos zárójelek között vannak. Nagyon gyakran a blokk hatóköre lehet ciklusváltozó. A for ciklusfeltételben deklarált változó nem érhető el a cikluson kívül, hacsak nem definiálta előzetesen.
public class JScopeTest2 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
int sum = 0;
sum = sum + i;
}
int sum = 1;
System.out.println(sum);
}
}
Mind az első összeg, mind az i változó a cikluson belül van deklarálva, és ezen a cikluson kívül nem léteznek. A második összeget azonban a cikluson kívül deklarálták, így ez a változó kerül kinyomtatásra.
Statikus változók
Ha egy változó statikusnak van deklarálva (a static kulcsszóval jelölve), akkor addig létezik, amíg az osztálya létezik. Általában a JVM az első használatkor betölt egy osztályt a memóriába, amikor a statikus változókat inicializálja.
import java.util.Date;
public class Student {
public static int today = 2022;
String surname;
String name;
String secondName;
Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases
public Student(String surname, String name, String secondName, Date birthday ){
this.surname = surname;
this.name = name;
this.secondName = secondName;
this.birthday = birthday == null ? 0 : birthday.getTime();
}
public static void main(String[] args) {
System.out.println(today);
}
}
Ne hozzon létre új tanulói osztályt a static today változó használatához . Itt a „2022” lesz kinyomtatva.
Hozzáférés módosítók
A Java 4 hozzáférés-módosítóval rendelkezik a metódushoz vagy változóhoz való hozzáférés korlátozására. Osztályokon belül használhatod őket, metódusokon belül nem.
private a leginkább korlátozó módosító. A metódusokhoz és változókhoz való hozzáférést arra az osztályra korlátozza, amelyben deklarálták. Ha nincs szükség bizonyos metódusok vagy változók használatára az osztályon kívül, használja a private értéket. Az osztályváltozók általában magánjellegűek a Java-ban.
Ha nincs megadva hozzáférés-módosító, akkor a metódus vagy változó elfogadja az alapértelmezett módosítót. alapértelmezés szerint csak az aktuális csomagból engedélyezi a hozzáférést.
A védett módosító csak az aktuális csomagon belül teszi lehetővé a metódushoz vagy változóhoz való hozzáférést, kivéve, ha a csomagon kívüli gyermekosztályon keresztül érhető el.
public a legkevésbé korlátozó módosító. Lehetővé teszi egy osztályhoz, metódushoz vagy változóhoz való hozzáférést nem csak a deklarált osztályból, hanem kívülről is. Ezt a módosítót nagyon gyakran használják.
GO TO FULL VERSION