In Java gibt es zwei Arten von Daten (oder Variablen): Primitive und Nicht-Primitive (auch Referenzen genannt).

Die primitiven Typen haben ihre Literalwerte im Stack, dem temporären und kurzfristigen Speicher, gespeichert, der von der Java Virtual Machine (JVM) verwaltet wird. [Lesen Sie hier mehr über Speichertypen]

Primitive Variablen werden in vier Gruppen unterteilt:

1. Ganzzahltypen: werden zum Speichern von Ganzzahlen (ohne Dezimalteil) verwendet. Sie sind: Byte, Short, Int, Long. Die lange Zahl hat zur Unterscheidung den Buchstaben „L“ oder „l“ am Ende der Zahl.

2. Gleitkommatypen: : Wird zum Speichern von Zahlen mit einem Dezimalteil (reelle Zahlen) verwendet. Sie sind: Float, Double. Der Float hat am Ende der Zahl zur Unterscheidung den Buchstaben „F“ oder „f“.

3. Zeichentyp: Wird zum Speichern einzelner Zeichen (z. B. Buchstaben, Ziffern oder Symbole) verwendet: char. Sie werden mit einfachen Anführungszeichen '' anstelle von doppelten "" initialisiert.

4. Boolescher Typ: Wird zum Speichern logischer Werte (wahr oder falsch) verwendet: bool

In der folgenden Tabelle finden Sie den Wertebereich, den jeder Typ zusätzlich zu seinen „Standard“-Werten unterstützt:

Im wissenschaftlichen Format stellt E einen Exponenten dar. Beispielsweise entspricht 1,23E 10 1,23 x 10^10

Was ist ein Standardwert? Dies ist der Wert, den die Variable annimmt, wenn sie nicht initialisiert wurde. Um diesen Wert anzunehmen, muss er jedoch global oder konstant (endgültig) sein.

public final boolean isTrue;

In dieser Codezeile wurde die Variable „isTrue“ nicht initialisiert, aber der Compiler zeigt keinen Fehler an, da er den Standardwert „false“ für die boolesche Variable betrachtet.

Hier eine wichtige Warnung: Wenn der Gültigkeitsbereich der Variablen lokal ist, das heißt, wenn sie innerhalb einer Funktion deklariert wurde, sind wir Programmierer gezwungen, ihr einen Wert zuzuweisen. Andernfalls tritt ein Kompilierungsfehler auf.

public void teste(){
        int i = 2;
        int j;

        if (i 



Obwohl wir in diesem Beispiel wissen, dass „2 


  
  
  Speicheradressen


Der zweite Datentyp in Java heißt Referenz. Diese Variablen speichern eine Referenz, also die Speicheradresse eines Objekts, anstatt seinen Wert direkt zu speichern, wie es bei primitiven Typen der Fall ist. Diese Speicherung erfolgt im Heap-Speicher.

Referenztypen sind im Allgemeinen Klassen, Schnittstellen, Aufzählungen und Objekte. 

Hier ein Nachtrag. Der String, den wir häufig in unseren Codes verwenden, ist eine Klasse und kein primitiver Typ. Beachten Sie, dass sogar der Name großgeschrieben wird, ebenso wie die Namenskonvention für Klassen in Java.

Der String verfügt sogar über Methoden wie length(), die die Größe des darin gespeicherten Textes zurückgibt, charAt(int index), die den Index eines Zeichens im Text zurückgibt, oder substring(int beginIndex, int endIndex), der einen Teil einer Zeichenfolge zurückgibt.

Aber wenn Sie die Bearbeitung primitiver Daten einfacher machen möchten, ermöglicht Java dies auch. Zu diesem Zweck verfügt es über die Wrapper-Klasse, die bereits über eine Reihe integrierter Methoden für die Arbeit mit den Grundtypen verfügt.

Wrapper haben grundsätzlich denselben Namen wie die primitive Variable, allerdings mit großgeschriebenem Anfangsbuchstaben: 

• Byte zu Byte
• Kurz für kurz
• Ganzzahl zu int
• Lang zu lang
• Float zu Float
• Verdoppeln, um zu verdoppeln
• Zu charakterisierendes Zeichen
• Boolescher Wert zu Boolescher Wert

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao  0) {
            System.out.println(num1   " é maior que "   num2);
        } else {
            System.out.println(num1   " é igual a "   num2);
        }
    }
}

In diesem Beispielcode wird der int-Wrapper verwendet, um eine Zeichenfolge in eine Zahl umzuwandeln (Integer.parse) und sie dann mit einer anderen Zahl zu vergleichen (Integer.compare).

Ein String hat jedoch eine Besonderheit, die andere Klassen nicht haben. Es ist unveränderlich.

Lassen Sie uns anhand dieses einfachen Beispiels nachdenken:

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

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

Beachten Sie in diesem Fall, dass Änderungen in „text2“ keine Änderungen in „text1“ widerspiegeln, obwohl der String „text2“ auf „text1“ verweist. Wenn nun beim Objekt „test2“, das auf „test1“ zeigte, eine Eigenschaft geändert wurde, spiegelte sich diese Änderung auch in „test1“ wider.

Hey, aber speichern Referenzvariablen nicht Speicheradressen anstelle von Literalwerten? Ja. Sie speichern es. Was passiert ist, dass die Java-Sprachentwickler die Entscheidung getroffen haben, String-Variablen unveränderlich zu lassen. Dies bedeutet, dass der Wert eines String-Objekts, sobald er festgelegt ist, nicht indirekt von einem anderen Objekt geändert werden kann.

Im Beispiel ändern wir daher nicht den Wert des Objekts, auf das text1 zuvor verwiesen hat (da String unveränderlich ist). Stattdessen erstellen wir ein neues String-Objekt mit dem Wert „Weird“ und lassen text1 auf dieses neue Objekt verweisen. Während text2 immer noch auf das ursprüngliche „Hello“-Objekt verweist und deshalb den Wert „Hello“ behält.

Kurz gesagt, das Zuweisen eines neuen Werts zu einer Zeichenfolge ändert nicht den Wert des vorhandenen Objekts, sondern lediglich den Verweis auf ein neues Objekt.

Objekte benutzerdefinierter Klassen, wie z. B. TestClass, sind veränderbar. Sowohl test1- als auch test2-Referenzen verweisen auf dasselbe Objekt, sodass sich die Änderung des Status eines von ihnen auf das andere auswirkt.