Java-Variablen

In diesem Artikel erklären wir allen Java-Lernenden, was Java-Variablen sind und wie man mit ihnen arbeitet.

Was ist eine Java-Variable?

Eine Variable in Java kann man sich als Box vorstellen. Diese „Box“ hat eine bestimmte Größe: den Speicher, der ihr zugewiesen ist. Wie viel Speicher zugewiesen wird, hängt vom Typ der Variablen ab, aber wir werden etwas später darüber sprechen. Gleichzeitig kann die Größe der Box selbst nach ihrer Erstellung nicht geändert werden, der Inhalt jedoch schon. Die Box ist möglicherweise leer. Sie können einen Wert darin „einfügen“ und dann einen anderen Wert extrahieren und einfügen. Somit ist eine Variable ein Feld, das Datenwerte während der Ausführung eines Java-Programms speichert. Diese Box verfügt über wichtige Funktionen:

es kann immer nur einen Wert enthalten (oder leer sein, dann enthält es den Standardwert),
Es hat einen Datentyp. Seine Größe hängt von der Art der Daten sowie davon ab, welcher bestimmte Speicherbereich ihnen zugewiesen ist (wo sie liegen).

So deklarieren Sie Variablen

Um Variablen in Java zu deklarieren, müssen Sie deren Typ und Namen angeben. Hier ist ein Beispiel für die Deklaration von drei Variablen:

int myInt;
String s;
Object variableName;

Hier sind int , String und Object der Datentyp und myInt , s , variableName sind Variablennamen. Der Datentyp muss entsprechend den Anforderungen des Programms ausgewählt werden, und es ist besser, einen Namen so zu wählen, dass klar ist, worum es geht. Natürlich ist es für Anfänger nicht so streng, aber in großen Projekten können Variablennamen wie „s“ die Lesbarkeit des Codes beeinträchtigen. Daher ist es besser, sich daran zu gewöhnen, Variablen so zu benennen, dass von Anfang an klar ist, wozu sie dienen. Natürlich im Rahmen des Zumutbaren.

So initialisieren Sie Variablen

Wenn Sie eine Variable deklarieren, weisen Sie ihr Speicher zu. Initialisierung bedeutet, dass Sie einen bestimmten Wert in das „Feld“ „eintragen“. Dies kann sofort bei der Deklaration der Variablen oder später erfolgen. Außerdem kann sich der Wert einer Variablen während der Programmausführung ändern. Beispiel:

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

Hier haben wir die Variable myInt in einer Zeile deklariert und initialisiert , ihr sofort Speicher zugewiesen (32 Bit für jede int-Zahl), ihr einen Namen gegeben und dann den Wert 5 im zugewiesenen Speicher abgelegt. Dann erklärten wir, dass wir Speicherplatz für die Zeichenfolge s zuweisen würden , und bereits ein separater Befehl fügte den Wert „init“ ein. Danach haben wir den String ausgedruckt und den Wert der Variablen s geändert . In diesem Programm haben wir die Zeilen ausgedruckt, und wenn Sie es ausführen, sehen Sie das folgende Ergebnis:

init init5

Datentypen von Variablen in Java: primitiv und nicht-primitiv

Datentypen von Variablen werden in Java in zwei Gruppen unterteilt:

Zu den primitiven Datentypen gehören Byte , Short , Int , Long , Float , Double , Boolean und Char
Nicht-primitive Datentypen wie String , Arrays und Classes

Hier ist ein Beispiel für die Arbeit mit Variablen:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

int , char , boolean und float sind Grundelemente. String ist nicht primitiv. Was ist mit der myStudent- Variable? Dies ist ein Objekt der vom Benutzer erstellten Klasse Student . Es wurde lediglich erstellt, um die Arbeit mit nicht-primitiven Variablen zu veranschaulichen. In Java sind sie in der Mehrzahl, da in dieser Programmiersprache fast alles ein Objekt ist. Zum Verständnis hier der Code der Student- Klasse:

import java.util.Date;

public class Student {
   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();
   }

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

Variablentypen in Java: lokal, Instanz und statisch

In Java gibt es drei verschiedene Arten von Variablen. Wir haben sie wie folgt aufgelistet:

Lokale Variablen
Instanzvariablen
Statische Variablen

Lokale Variablen

Eine im Hauptteil der Methode deklarierte Variable wird als lokale Variable bezeichnet. Außerdem werden lokale Variablen innerhalb von Konstruktoren und Blöcken deklariert. Sie können lokale Variablen nur innerhalb der Methode, des Konstruktors oder Blocks verwenden, in der sie erstellt wurden, und die anderen Methoden in der Klasse wissen nicht einmal, dass die Variable existiert. Daher werden lokale Variablen erstellt, wenn die Methode, der Konstruktor oder der Block eingegeben wird, und die Variable wird zerstört, sobald die Methode, der Konstruktor oder der Block nicht funktioniert. Eine lokale Variable kann nicht mit dem Schlüsselwort static definiert werden . Mehr noch: Sie können keine Zugriffsmodifikatoren für lokale Variablen verwenden. Hier ist ein Beispiel:

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

Hier ist myOtherString eine lokale Variable. Sie können es nicht von der anderen Methode außer myMethod verwenden . Lokale Variablen können keine Standardwerte haben. Wenn mindestens eine lokale Variable im Programm nicht initialisiert ist, funktioniert das Programm nicht ordnungsgemäß. Nehmen wir eine kleine Änderung in einem der vorherigen Beispiele vor und „vergessen“, die Variable myBool zu initialisieren:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

Wenn wir versuchen, das Programm auszuführen, wird eine Fehlermeldung ausgegeben:

Fehler:(10, 50) Java: Variable myBool wurde möglicherweise nicht initialisiert

Instanzvariablen

Eine innerhalb der Klasse, aber außerhalb des Körpers einer Methode, eines Konstruktors oder eines Blocks deklarierte Variable wird als Instanzvariable bezeichnet. Instanzvariablen werden erstellt, wenn ein Objekt mit dem Schlüsselwort new erstellt wird . Es wird zerstört, wenn das Objekt zerstört wird. Es kann nicht als statisch deklariert werden, Sie können jedoch Zugriffsmodifikatoren für Instanzvariablen verwenden. Instanzvariablen sind für alle Methoden, Konstruktoren und Blöcke in der Klasse sichtbar. Normalerweise sind Instanzvariablen privat, Sie können jedoch die Sichtbarkeit für Unterklassen ändern. Instanzvariablen haben im Gegensatz zu lokalen Variablen Standardwerte. Für alle primitiven Zahlentypen ist der Standardwert 0, für boolesche Werte ist er falsch und für Objektreferenzen ist er null. Werte können während der Deklaration oder innerhalb des Konstruktors zugewiesen werden. Hier ist ein Beispiel:

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

Statische Variablen

Eine als statisch deklarierte Variable wird als statische Variable bezeichnet. Java bietet Ihnen die Möglichkeit, solche Variablen außerhalb einer Methode, eines Konstruktors oder eines Blocks zu deklarieren. Es kann nicht lokal sein, sie gehören zur Klasse, nicht zu Instanzen. Das bedeutet, dass eine einzelne Kopie einer statischen Variablen einmal erstellt und von allen Instanzen der Klasse gemeinsam genutzt wird. Die Speicherzuweisung für statische Variablen erfolgt nur einmal, wenn die Klasse in den Speicher geladen wird. Sie können eine beliebige Sichtbarkeit haben, normalerweise werden sie jedoch als öffentlich deklariert. Sie verfügen auch über Standardwerte wie Instanzvariablen.

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Im obigen Beispiel haben wir eine separate Storage- Klasse erstellt, die Variablen count und sum dorthin verschoben und sie als statisch deklariert. Auf öffentliche statische Variablen kann von jeder Programmmethode aus zugegriffen werden (und nicht nur von einer Methode). Um das Gelernte zu vertiefen, empfehlen wir Ihnen, sich eine Videolektion aus unserem Java-Kurs anzusehen