Vi vet alla att länder har gränser och sina egna lagar. Landets lagar verkar inom gränserna. Även i landet finns det till exempel organisationer, som skolor eller museer, som har sina egna lokala regler. De strider inte mot landets lagar, utan verkar bara inom ramen för den angivna organisationen. Detsamma gäller i programmering. Så i programmering, och särskilt i Java-språk, finns det en term "omfattning". Det hänvisar till områden i programmet där vissa data, såsom variabler eller metoder, fungerar. I den här artikeln ska vi ta reda på vilka omfattningar som är för variabler i Java och hur man definierar dem.
Java Scope i allmänhet
Varför är det nödvändigt att separera omfattningen av variabler och metoder? Faktum är att ibland är program väldigt stora och det kan vara svårt att spåra en eller annan variabel. Dessutom är det i stora projekt önskvärt med tydlig namngivning av variabler så att det tydligt framgår vad de är till för. Scope låter dig specifikt ha olika variabler med samma namn i olika delar av programmet. Sådan kod är lättare att underhålla och läsa. Java scope definierar var en viss variabel eller metod är tillgänglig i ett program. I korthet:
En variabel som deklareras i en metod är synlig från början av deklarationen till slutet av metoden (metodomfång).
En variabel som deklareras i ett kodblock existerar till slutet av det kodblocket.
Variabler som är metodargument existerar till slutet av metoden.
Klass-/objektvariabler existerar under det innehållande objektets livstid. Deras synlighet regleras av speciella åtkomstmodifierare.
Statiska klassvariabler existerar hela tiden programmet körs. Deras synlighet bestäms också av åtkomstmodifierare.
Metodnivå Omfattning
Alla variabler som deklareras i en metod, inklusive argument, är inte tillgängliga utanför den metoden. Alla variabler som deklareras i metoder är synliga från början av deras deklaration till slutet av metoden. Här är ett exempel på metodvariabel omfattning:
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;
}
}
Här har vi secondArg , en lokal variabel eller metodargument. Vi kan inte använda denna variabel utanför myMethod- metoden eller innan den deklarerades. Om en variabel är ett funktionsargument är den synlig i hela kroppen av denna metod. I exemplet ovan har vi två sådana argument: arg i myMethod och args i huvudmetod.
Klassnivå Omfattning
Klassnivåomfattning (instansvariabler) — alla variabler som deklareras i en klass är tillgängliga för alla metoder i den klassen. Beroende på dess åtkomstmodifierare (dvs. offentlig eller privat), kan den ibland nås utanför klassen. Så om en variabel är en klassvariabel, så är den bunden till ett specifikt objekt och existerar så länge det finns ett objekt av denna klass. Om det inte finns något objekt, så finns det ingen kopia av variabeln. Variabeln är synlig från alla metoder i klassen, oavsett om de deklareras före eller efter den. Varje objekt har sin egen variabel oberoende av andra objekt. Tillgång till en variabel från statiska metoder är inte möjlig.
Kodexempel
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));
}
}
Efternamn , namn , andranamn och födelsedag är instansvariabler.
Block Omfattning
Om en variabel definieras/deklareras i något kodblock, så existerar den till slutet av det kodblocket. Typiskt finns sådana variabler mellan de lockiga hängslen där de definieras. Mycket ofta kan blockomfattning vara en loopvariabel. En variabel som deklareras i ett for loop-villkor är inte tillgänglig utanför loopen, om du inte definierat den i förväg.
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);
}
}
Både första summa- och i-variabler deklareras inuti loopen och existerar inte utanför denna loop. Den andra summan deklarerades dock utanför loopen så just denna variabel kommer att skrivas ut.
Statiska variabler
Om en variabel deklareras som statisk (markerad med nyckelordet static), så existerar den så länge dess klass existerar. Vanligtvis laddar JVM en klass i minnet vid första användningen, när statiska variabler initieras.
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);
}
}
Du bör inte skapa en ny instans av Student -klassen för att använda variabeln static today . Här kommer "2022" att tryckas.
Åtkomstmodifierare
Java har 4 åtkomstmodifierare för att begränsa åtkomsten till metoden eller variabeln. Du kan använda dem i klasser, inte inuti metoder.
privat är den mest restriktiva modifieraren. Det begränsar åtkomsten till metoder och variabler till den klass de deklarerades. Om det inte finns något behov av att använda vissa metoder eller variabler utanför klassen, använd privat. Klassvariabler är vanligtvis privata i Java.
Om ingen åtkomstmodifierare anges, kommer metoden eller variabeln att acceptera standardmodifieraren . standard tillåter endast åtkomst från det aktuella paketet.
protected modifier tillåter åtkomst till en metod eller variabel endast från det aktuella paketet, såvida det inte nås via en underordnad klass utanför paketet.
public är den minst restriktiva modifieraren. Det låter dig komma åt en klass, metod eller variabel inte bara från klassen de deklareras, utan även utifrån. Denna modifierare används väldigt ofta.
GO TO FULL VERSION