Java-Bereich

Wir alle wissen, dass Länder Grenzen und ihre eigenen Gesetze haben. Die Gesetze des Landes gelten innerhalb der Grenzen. Auch im Land gibt es beispielsweise Organisationen, wie Schulen oder Museen, die ihre eigenen lokalen Regeln haben. Sie widersprechen nicht den Gesetzen des Landes, sondern agieren nur im Rahmen der angegebenen Organisation. Das Gleiche gilt auch für die Programmierung. Daher gibt es in der Programmierung und insbesondere in der Java-Sprache den Begriff „Bereich“. Es bezieht sich auf Bereiche des Programms, in denen bestimmte Daten, wie zum Beispiel Variablen oder Methoden, funktionieren. In diesem Artikel werden wir herausfinden, welche Bereiche es für Variablen in Java gibt und wie man sie definiert.

Java Scope im Allgemeinen

Warum ist es notwendig, Bereiche von Variablen und Methoden zu trennen? Tatsache ist, dass Programme manchmal sehr groß sind und es schwierig sein kann, die eine oder andere Variable zu verfolgen. Darüber hinaus ist in großen Projekten eine eindeutige Benennung der Variablen wünschenswert, damit klar ist, wozu sie dienen. Mit Scope können Sie insbesondere verschiedene Variablen mit demselben Namen in verschiedenen Teilen des Programms verwenden. Ein solcher Code ist einfacher zu warten und zu lesen. Der Java-Bereich definiert, wo in einem Programm auf eine bestimmte Variable oder Methode zugegriffen werden kann. Knapp:

• Eine in einer Methode deklarierte Variable ist vom Anfang der Deklaration bis zum Ende der Methode (Methodenbereich) sichtbar.
• Eine in einem Codeblock deklarierte Variable existiert bis zum Ende dieses Codeblocks.
• Variablen, die Methodenargumente sind, bleiben bis zum Ende der Methode bestehen.
• Klassen-/Objektvariablen bestehen für die Lebensdauer des enthaltenden Objekts. Ihre Sichtbarkeit wird durch spezielle Zugriffsmodifikatoren reguliert.
• Statische Klassenvariablen sind ständig vorhanden, während das Programm ausgeführt wird. Ihre Sichtbarkeit wird auch durch Zugriffsmodifikatoren bestimmt.

Umfang der Methodenebene

Auf alle in einer Methode deklarierten Variablen, einschließlich Argumenten, kann außerhalb dieser Methode nicht zugegriffen werden. Alle in Methoden deklarierten Variablen sind vom Beginn ihrer Deklaration bis zum Ende der Methode sichtbar. Hier ist ein Beispiel für den Gültigkeitsbereich einer Methodenvariable:

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;
   }
}

Hier haben wir secondArg , eine lokale Variable oder ein Methodenargument. Wir können diese Variable nicht außerhalb der myMethod- Methode oder vor ihrer Deklaration verwenden. Wenn eine Variable ein Funktionsargument ist, ist sie im gesamten Körper dieser Methode sichtbar. Im obigen Beispiel haben wir zwei solcher Argumente: arg in myMethod und args in der Hauptmethode.

Umfang auf Klassenebene

Gültigkeitsbereich auf Klassenebene (Instanzvariablen) – Jede in einer Klasse deklarierte Variable ist für alle Methoden dieser Klasse verfügbar. Abhängig von seinem Zugriffsmodifikator (z. B. öffentlich oder privat) kann manchmal außerhalb der Klasse darauf zugegriffen werden. Wenn eine Variable also eine Klassenvariable ist, dann ist sie an ein bestimmtes Objekt gebunden und existiert, solange es ein Objekt dieser Klasse gibt. Wenn kein Objekt vorhanden ist, gibt es keine Kopie der Variablen. Die Variable ist für alle Methoden der Klasse sichtbar, unabhängig davon, ob sie davor oder danach deklariert werden. Jedes Objekt hat seine eigene Variable, unabhängig von anderen Objekten. Der Zugriff auf eine Variable aus statischen Methoden ist nicht möglich.

Codebeispiel

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));
   }
}

Nachname , Name , zweiterName und Geburtstag sind Instanzvariablen.

Blockumfang

Wenn eine Variable in einem Codeblock definiert/deklariert wird, dann existiert sie bis zum Ende dieses Codeblocks. Typischerweise stehen solche Variablen zwischen den geschweiften Klammern, in denen sie definiert sind. Sehr oft könnte der Blockbereich eine Schleifenvariable sein. Auf eine Variable, die in einer for- Schleifenbedingung deklariert ist, kann außerhalb der Schleife nicht zugegriffen werden, es sei denn, Sie haben sie zuvor definiert.

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);
   }
}

Sowohl die Variablen „first sum“ als auch „i“ werden innerhalb der Schleife deklariert und existieren nicht außerhalb dieser Schleife. Allerdings wurde die zweite Summe außerhalb der Schleife deklariert, sodass diese bestimmte Variable gedruckt wird.

Statische Variablen

Wenn eine Variable als statisch deklariert ist (markiert mit dem Schlüsselwort static), dann existiert sie, solange ihre Klasse existiert. Normalerweise lädt die JVM eine Klasse bei der ersten Verwendung in den Speicher, wenn statische Variablen initialisiert werden.

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);
   }

}

Sie sollten keine neue Instanz der Student- Klasse erstellen, um die statische Today- Variable zu verwenden. Hier wird „2022“ gedruckt.

Zugriffsmodifikatoren

Java verfügt über 4 Zugriffsmodifikatoren, um den Zugriff auf die Methode oder Variable einzuschränken. Sie können sie innerhalb von Klassen verwenden, nicht innerhalb von Methoden.

• private ist der restriktivste Modifikator. Es beschränkt den Zugriff auf Methoden und Variablen auf die Klasse, in der sie deklariert wurden. Wenn es nicht erforderlich ist, bestimmte Methoden oder Variablen außerhalb der Klasse zu verwenden, verwenden Sie private. Klassenvariablen sind in Java normalerweise privat.

• Wenn kein Zugriffsmodifikator angegeben ist, akzeptiert die Methode oder Variable den Standardmodifikator . Standardmäßig ist der Zugriff nur vom aktuellen Paket aus möglich.

• Der geschützte Modifikator ermöglicht den Zugriff auf eine Methode oder Variable nur innerhalb des aktuellen Pakets, es sei denn, der Zugriff erfolgt über eine untergeordnete Klasse außerhalb des Pakets.

• public ist der am wenigsten restriktive Modifikator. Es ermöglicht Ihnen den Zugriff auf eine Klasse, Methode oder Variable nicht nur von der Klasse aus, in der sie deklariert sind, sondern auch von außerhalb. Dieser Modifikator wird sehr oft verwendet.