Datentypen, Variablen und Arrays: Wertebereiche, Namen und Gültigkeit

Datentypen, Variablen und Arrays: Wertebereiche, Namen und Gültigkeit

https://bildung.social/@oerinformatik/

https://oer-informatik.de/datentypen-variablen

Datentyp, Variable, Wertebereich, Typumwandlung, Überlauf, Array, Index, Gültigkeitsbereich, globale Variable, Namenskonvention, lowerCamelCase, Prüfungsvorbereitung

tl/dr; (ca. 23 min Lesezeit): Jede Variable hat einen Datentyp, und der Datentyp legt fest, wie viel Speicher sie belegt und welche Werte sie aufnehmen kann. Du lernst, wie Du Variablen deklarierst und initialisierst, wie Du den Wertebereich eines Ganzzahltyps berechnest und für eine Aufgabe den passenden, möglichst speichersparenden Datentyp auswählst. Außerdem geht es um Typumwandlungen (z. B. Nachkommastellen entfernen), um Arrays mit ihren Stärken und Schwächen, um den Gültigkeitsbereich lokaler und globaler Variablen und um Namenskonventionen wie lowerCamelCase [AI-Assisted]. (Zuletzt geändert am 28.10.2026)

Dieser Artikel ist Teil einer Artikelreihe zur prozeduralen Programmierung: Programmentwurf / Datentypen, Variablen und Arrays / Algorithmen mit Arrays / Übungsaufgaben zu Datentypen, Variablen und Arrays

Dieser Artikel baut auf der Kann-Liste des Artikels Programmentwurf: Pseudocode, Struktogramm und PAP auf.

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast. Hier klicken, um Kann-Liste ein- oder auszublenden

Ein Sensor meldet 23,7 °C, ein Akku 87 %, ein Türschild „Raum B.104“, ein Fahrradschloss „verriegelt: ja“. Für uns Menschen sind das einfach Angaben. Ein Programm muss aber für jeden dieser Werte wissen, wie viel Speicher er braucht, welche Werte erlaubt sind und was man mit ihm rechnen darf. Genau das legt der Datentyp fest. Wer Datentypen bewusst wählt, spart Speicher und Übertragungszeit, vermeidet Rundungs- und Überlauffehler und schreibt Code, den andere verstehen.

Die Mindmap zeigt die Themen dieses Artikels im Überblick:

Variablen: Deklaration, Initialisierung, Zuweisung

Eine Variable ist ein benannter Speicherplatz für einen Wert, der sich während des Programmablaufs ändern kann. Drei Begriffe werden oft verwechselt:

Eine Variable muss deklariert sein, bevor sie benutzt wird, und sie sollte initialisiert sein, bevor ihr Wert gelesen wird. In Java und C# meldet der Compiler einen Fehler, wenn Du eine lokale Variable liest, der noch nie ein Wert zugewiesen wurde. In C dagegen enthält eine nicht initialisierte Variable einen zufälligen Restwert aus dem Speicher – eine typische Fehlerquelle. In Python gibt es keine getrennte Deklaration: Eine Variable entsteht durch die erste Zuweisung.

Eine Konstante ist ein benannter Wert, der sich nach der Initialisierung nicht mehr ändern darf, z. B. final int MAX_RAEUME = 8; (Java) oder const int MaxRaeume = 8; (C#). Python kennt keine echten Konstanten; Großbuchstaben (MAX_RAEUME = 8) signalisieren nur, dass der Wert nicht geändert werden soll. Konstanten machen Code lesbarer („magische Zahlen“ wie 8 oder 0.19 bekommen einen Namen) und lassen sich an einer Stelle ändern.

Statisch und dynamisch typisiert: In Java, C# und C steht der Datentyp bei der Deklaration fest und wird vom Compiler geprüft (statische Typisierung). In Python hängt der Typ am Wert und kann sich bei einer neuen Zuweisung ändern (dynamische Typisierung). Python ist dadurch kürzer zu schreiben, Typfehler fallen aber erst zur Laufzeit auf.

Einfache Datentypen im Überblick

Die folgende Tabelle zeigt die wichtigsten einfachen (primitiven) Datentypen. Die Größen gelten für Java und C#; in C hängen sie teilweise von der Plattform ab (dort sorgen Typen wie int8_t, uint16_t oder int32_t aus stdint.h für feste Größen).

Achtung bei byte: In Java ist byte vorzeichenbehaftet (−128 … 127), in C# ist byte vorzeichenlos (0 … 255) und sbyte vorzeichenbehaftet. Lies bei Aufgaben deshalb immer die mitgelieferte Typtabelle. Gibt eine Aufgabe eigene Größen vor (z. B. char mit 1 Byte wie in C), gelten diese.

Die Grafik stellt die Ganzzahltypen aus der Tabelle nebeneinander: Jedes zusätzliche Byte vervielfacht den Wertebereich.

Python kommt mit wenigen Typen aus: int (Ganzzahl beliebiger Größe, kein Überlauf), float (entspricht double), bool, str (Zeichenkette; ein einzelnes Zeichen ist eine Zeichenkette der Länge 1) und decimal.Decimal für exakte Dezimalzahlen. Speichersparende Typen wie byte gibt es nur über Bibliotheken (z. B. bytearray, array, NumPy).

Neben den einfachen Datentypen gibt es zusammengesetzte Datentypen: Ein Array fasst mehrere Werte desselben Typs zusammen, eine Struktur bzw. Klasse mehrere Werte unterschiedlichen Typs. Ein Datum lässt sich z. B. als Klasse mit den drei ganzzahligen Attributen tag, monat und jahr realisieren – in der Praxis nutzt Du aber den fertigen Datumstyp der Sprache (LocalDate in Java, DateTime/DateOnly in C#, datetime.date in Python).

Wertebereiche von Ganzzahlen berechnen

Mit n Bits lassen sich 2^n verschiedene Werte darstellen. Wie diese Werte verteilt werden, hängt davon ab, ob der Typ ein Vorzeichen hat:

• ohne Vorzeichen (unsigned): von 0 bis 2^n - 1
• mit Vorzeichen (signed, Zweierkomplement): von -2^{n-1} bis 2^{n-1} - 1

Beim Zweierkomplement bleibt die Null auf der positiven Seite. Deshalb gibt es eine negative Zahl mehr als positive: Ein vorzeichenbehaftetes Byte reicht von −128 bis +127.

Beispiel: Wertebereich von int (4 Byte, mit Vorzeichen)

\begin{aligned} \text{Geg.:}\quad & 4\ \text{Byte} = 32\ \text{Bit, mit Vorzeichen}\\ \text{Ges.:}\quad & \text{kleinster und größter Wert}\\ \text{kleinster Wert} &= -2^{n-1} = -2^{31} = \underline{\underline{-2.147.483.648}}\\ \text{größter Wert} &= 2^{n-1} - 1 = 2^{31} - 1 = \underline{\underline{2.147.483.647}} \end{aligned}

Merke Dir als Faustregel: int reicht für Werte bis gut 2 Milliarden, short bis gut 32.000, ein vorzeichenloses Byte bis 255.

Überlauf: Wird der größte Wert eines Typs überschritten, „springt“ der Wert in Java, C# und C (bei vorzeichenlosen Typen und in der Praxis meist auch bei vorzeichenbehafteten) an den Anfang des Wertebereichs. Ein byte b in Java mit dem Wert 127 wird nach b++ (bzw. b += 1) zu −128, ein byte in C# mit 255 wird nach b++ zu 0. Der Compiler warnt dabei nicht; das Programm rechnet einfach falsch weiter. In C# lässt sich mit checked erzwingen, dass ein Überlauf eine Ausnahme auslöst; in Java gibt es dafür Math.addExact(). Python-Ganzzahlen laufen nicht über.

Am Zahlenring für 4 Bit lässt sich der Überlauf ablesen: Dieselben 16 Bitmuster werden ohne Vorzeichen als 0 bis 15 und mit Vorzeichen als −8 bis 7 gedeutet. Wer über den größten Wert hinaus weiterzählt, landet am Anfang des Wertebereichs.

Den passenden Datentyp wählen

Bei der Auswahl helfen vier Fragen:

1. Ganzzahl oder Kommazahl? Zählwerte, Prozent ohne Nachkommastellen, Schrittzahlen, IDs → Ganzzahl. Messwerte mit Nachkommastellen → Gleitkommazahl.
2. Welcher Bereich? Kleinster und größter möglicher Wert bestimmen den Typ. Gibt es negative Werte (z. B. Außentemperatur)?
3. Welche Genauigkeit? float genügt für einen Messwert wie 23,74 °C. Für Geldbeträge ist Gleitkomma ungeeignet, weil Dezimalbrüche wie 0,10 binär nicht exakt darstellbar sind (0.1 + 0.2 ergibt 0.30000000000000004). Nutze decimal/BigDecimal oder rechne in Cent mit einer Ganzzahl.
4. Wie oft kommt der Wert vor? Bei einer einzelnen Variable sind 3 Byte Unterschied egal. Bei Millionen von Messwerten, beim Übertragen über ein Funknetz oder auf einem Mikrocontroller mit wenigen Kilobyte RAM zählt jedes Byte.

Beispiele (Größen wie in der Tabelle oben, „möglichst speichersparend“):

Das letzte Beispiel zeigt eine wichtige Regel: Nicht alles, was aus Ziffern besteht, ist eine Zahl. Postleitzahlen, Telefonnummern, Artikelnummern mit führenden Nullen oder IBANs sind Zeichenketten, weil man mit ihnen nicht rechnet und weil Formatzeichen erhalten bleiben müssen.

Wenn die Grenze eines Typs knapp ist, rechne nach. Ein Zähler, der die Millisekunden seit dem Programmstart in einem int speichert, erreicht seinen größten Wert nach 2.147.483.647\ \text{ms} : 1.000 : 86.400 \approx 24{,}86 Tagen. Ein Server, der länger läuft, braucht dafür long.

Typumwandlung und Nachkommastellen entfernen

Werte verschiedener Typen werden oft ineinander umgewandelt:

• implizit (automatisch): wenn kein Informationsverlust droht, z. B. int → long oder int → double.
• explizit (Cast): wenn Information verloren gehen kann, z. B. double → int. Hier musst Du die Umwandlung ausdrücklich hinschreiben.

Soll ein Wert wie 24,8 ohne Nachkommastellen dargestellt werden, gibt es mehrere Wege – mit unterschiedlichen Ergebnissen:

Auch eine Ganzzahldivision liefert ein Ergebnis ohne Nachkommastellen: Teilst Du eine Ganzzahl durch eine andere Ganzzahl, schneiden Java, C# und C die Nachkommastellen ab (7 / 2 ergibt 3). Den Rest liefert der Modulo-Operator (7 % 2 ergibt 1). Wer das vergisst, bekommt z. B. bei summe / anzahl einen abgeschnittenen Mittelwert. Soll das Ergebnis Nachkommastellen behalten, muss mindestens ein Operand eine Gleitkommazahl sein. Mehr zum Runden in Algorithmen findest Du im Artikel Algorithmen mit Arrays.

Python Java all none

import math

differenz = 24.8
print(int(differenz))         # 24  (Typumwandlung, schneidet ab)
print(math.trunc(differenz))  # 24  (abschneiden)
print(round(differenz))       # 25  (runden; Achtung: Python rundet .5 auf die gerade Zahl)
print(math.floor(differenz))  # 24  (abrunden)
print(math.ceil(differenz))   # 25  (aufrunden)
print(f"{differenz:.0f}")     # 25  (nur Ausgabe formatieren)

summe = 7
anzahl = 2
print(summe // anzahl)        # 3   (Ganzzahldivision)
print(summe % anzahl)         # 1   (Rest, Modulo)
print(summe / anzahl)         # 3.5 (in Python liefert / immer float)

double differenz = 24.8;
System.out.println((int) differenz);          // 24  (Cast, schneidet ab)
System.out.println(Math.round(differenz));    // 25  (runden, liefert long)
System.out.println(Math.floor(differenz));    // 24.0 (abrunden, bleibt double)
System.out.println(Math.ceil(differenz));     // 25.0 (aufrunden, bleibt double)
System.out.printf("%.0f%n", differenz);       // 25  (nur Ausgabe formatieren)

int summe = 7;
int anzahl = 2;
System.out.println(summe / anzahl);           // 3   (Ganzzahldivision)
System.out.println(summe % anzahl);           // 1   (Rest, Modulo)
System.out.println((double) summe / anzahl);  // 3.5 (ein Operand als double)

In C# sehen die Aufrufe ähnlich aus: (int)differenz, Math.Truncate(differenz), Math.Round(differenz), Math.Floor() und Math.Ceiling().

Zeichen und Zeichenketten

Ein Zeichen (char) speichert in Java und C# genau eine UTF-16-Codeeinheit und damit die meisten Unicode-Zeichen, z. B. eine Bewertungsstufe 'A' bis 'F'. Zeichen außerhalb dieses Bereichs, z. B. viele Emojis, belegen zwei char. Intern ist es eine Zahl (der Zeichencode), deshalb kann man mit Zeichen vergleichen und rechnen: 'D' - 'A' ergibt 3. Eine Zeichenkette (String) speichert eine Folge von Zeichen beliebiger Länge. In Java und C# ist sie ein Objekt mit Methoden wie length() bzw. Length; ihr Speicherbedarf hängt von der Länge ab. In Datenbanken entspricht das CHAR(n) (feste Länge) bzw. VARCHAR(n) (variable Länge bis n Zeichen). Wie Du Zeichenketten zerlegst und prüfst, zeigt der Artikel Zeichenketten und Prüfziffern.

Arrays: viele Werte unter einem Namen

Ein Array (Feld) speichert mehrere Werte desselben Datentyps hintereinander im Speicher. Jedes Element erreichst Du über seinen Index. In fast allen Sprachen beginnt der Index bei 0: Ein Array mit 24 Elementen hat die Indizes 0 bis 23.

Arrays deklarieren

Die Schreibweise unterscheidet sich je nach Sprache. In C und C++ folgt die Anzahl der Elemente in eckigen Klammern auf den Namen: zuerst der Datentyp der Elemente, dann der Bezeichner, dann die Größe. Soll für jede Stunde eines Tages festgehalten werden, ob ein Fenster offen war, braucht man 24 Wahrheitswerte:

bool fensterOffen[24];

Python Java all none

# Python nutzt Listen; sie wachsen bei Bedarf und dürfen gemischte Typen enthalten.
fenster_offen = [False] * 24          # 24 Elemente, alle False
akkustand = [87, 64, 100, 12]         # mit Werten initialisiert

akkustand[0] = 85                     # erstes Element (Index 0) ändern
print(len(akkustand))                 # 4  (Anzahl der Elemente)
print(akkustand[-1])                  # 12 (letztes Element)

# Für speichersparende Felder fester Typen gibt es das Modul array:
from array import array
werte = array('B', [87, 64, 100, 12]) # 'B' = vorzeichenloses Byte (0 ... 255)

boolean[] fensterOffen = new boolean[24];  // 24 Elemente, alle false
int[] akkustand = {87, 64, 100, 12};       // mit Werten initialisiert

akkustand[0] = 85;                         // erstes Element (Index 0) ändern
System.out.println(akkustand.length);      // 4  (Anzahl der Elemente)
System.out.println(akkustand[akkustand.length - 1]); // 12 (letztes Element)
// akkustand[4] = 50;  -> ArrayIndexOutOfBoundsException

In C# lautet die Deklaration wie in Java (bool[] fensterOffen = new bool[24];, Länge mit fensterOffen.Length), in C wie oben gezeigt (bool fensterOffen[24]; mit stdbool.h).

Index oder Nummer?

Sind Dinge von 1 an nummeriert (Ladeplatz 1 bis 8, Türschild 1 bis 12, Messwert 1 bis 200), liegt Nummer k im Array beim Index k - 1. Messwert Nr. 7 steht also in messwert[6], und einen gefundenen Index musst Du für die Ausgabe um 1 erhöhen. Dieser Versatz ist einer der häufigsten Fehler in Aufgaben zu Arrays.

Das Schema zeigt auch, warum der Zugriff über den Index so schnell ist: Weil alle Elemente gleich groß sind und direkt hintereinander liegen, ergibt sich die Adresse eines Elements aus Startadresse + Index · Elementgröße.

Liefert eine Methode einen Wert, kann ihr Aufruf direkt rechts von der Zuweisung stehen. Eine Methode, die die Temperatur eines der sechs Sensoren einer Wetterstation zurückgibt, wird z. B. so deklariert und in einer Schleife genutzt:

Python Java all none

# Deklaration: Name, Parameter mit Datentyp, Rückgabetyp nach ->
def lese_temperatur(sensor_nr: int) -> float: ...

# Aufruf: Sensor k (1 bis 6) landet beim Index k - 1
temperatur = [0.0] * 6
for k in range(1, 7):
    temperatur[k - 1] = lese_temperatur(k)

// Deklaration: Rückgabetyp, Name, Parameter mit Datentyp
double leseTemperatur(int sensorNr) { ... }

// Aufruf: Sensor k (1 bis 6) landet beim Index k - 1
double[] temperatur = new double[6];
for (int k = 1; k <= temperatur.length; k++) {
    temperatur[k - 1] = leseTemperatur(k);
}

Die Deklaration (der Methodenkopf) nennt den Datentyp des Rückgabewerts, den Namen der Methode und die Parameter jeweils mit ihrem Datentyp. Liefert die Methode nichts zurück, steht in Java void (in Python -> None). In Python sind die Typangaben : int und -> float Typhinweise: Sie dokumentieren die erwarteten Datentypen, werden beim Ausführen aber nicht geprüft.

Wann ist ein Array die richtige Wahl?

Braucht ein Programm eine veränderliche Anzahl von Elementen, sind dynamische Listen besser geeignet (ArrayList in Java, List<T> in C#, list in Python). Sie vergrößern sich bei Bedarf, belegen dafür aber etwas mehr Speicher. Für Werte unterschiedlichen Typs, die zusammengehören (Name, Raum, Akkustand eines Türschilds), nimmst Du eine Klasse bzw. Struktur und bei Bedarf ein Array oder eine Liste von Objekten.

Ein zweidimensionales Array entspricht einer Tabelle mit Zeilen und Spalten, z. B. int[][] belegung = new int[5][8]; für 5 Zeitslots in 8 Räumen. Der Zugriff erfolgt mit zwei Indizes: belegung[slot][raum].

Gültigkeitsbereich: lokale und globale Variablen

Der Gültigkeitsbereich (Scope) einer Variablen legt fest, in welchem Teil des Programms sie bekannt ist. Die Lebensdauer gibt an, wie lange ihr Speicher belegt ist.

• Eine lokale Variable wird innerhalb einer Methode oder eines Blocks (z. B. einer Schleife) deklariert. Sie ist nur dort bekannt und verschwindet, wenn der Block verlassen wird. Die Laufvariable i einer for-Schleife ist ein typisches Beispiel.
• Eine globale Variable wird außerhalb aller Methoden deklariert und ist im ganzen Programm (bzw. Modul) ansprechbar. In Java und C# gibt es keine echten globalen Variablen; ihnen entsprechen öffentliche statische Attribute (public static).
• Dazwischen liegen Attribute eines Objekts: Sie gelten in allen Methoden der Klasse und leben so lange wie das Objekt.

Warum unterscheidet man das? Lokale Variablen strukturieren das Programm und verhindern Fehler: Eine Variable, die nur in einer Methode gilt, kann nicht versehentlich von einer anderen Stelle verändert werden. Gleiche Namen (z. B. i oder summe) dürfen in verschiedenen Methoden vorkommen, ohne sich zu stören. Methoden, die nur mit Parametern und lokalen Variablen arbeiten, lassen sich einzeln testen und wiederverwenden. Globale Variablen erzeugen dagegen versteckte Abhängigkeiten: Wer den Fehler sucht, muss jede Stelle im Programm prüfen, die die Variable ändern könnte. Bei parallel laufenden Programmteilen (Threads) können gleichzeitige Zugriffe sogar zu falschen Werten führen. Deshalb gilt: so lokal wie möglich, Werte über Parameter und Rückgabewerte weitergeben, und für unveränderliche Werte Konstanten verwenden.

Python Java all none

GRENZWERT = 5000            # globale Konstante (nur lesen)
anzahl_meldungen = 0        # globale Variable (besser vermeiden)

def zaehle_niedrige(werte):
    anzahl = 0              # lokale Variable, nur in dieser Funktion bekannt
    for wert in werte:      # auch wert ist lokal
        if wert < GRENZWERT:
            anzahl = anzahl + 1
    return anzahl           # Ergebnis über den Rückgabewert weitergeben

def melde():
    global anzahl_meldungen # ohne diese Zeile wäre anzahl_meldungen hier lokal
    anzahl_meldungen = anzahl_meldungen + 1

print(zaehle_niedrige([7200, 4100, 12500, 3800, 6400]))  # 2
# print(anzahl)  -> NameError: anzahl ist außerhalb der Funktion unbekannt

public class Schrittzaehler {
    static final int GRENZWERT = 5000;   // Konstante, in der ganzen Klasse bekannt
    static int anzahlMeldungen = 0;      // entspricht einer globalen Variablen (besser vermeiden)

    static int zaehleNiedrige(int[] werte) {
        int anzahl = 0;                  // lokale Variable, nur in dieser Methode bekannt
        for (int i = 0; i < werte.length; i++) {  // i ist nur in der Schleife bekannt
            if (werte[i] < GRENZWERT) {
                anzahl = anzahl + 1;
            }
        }
        return anzahl;                   // Ergebnis über den Rückgabewert weitergeben
    }

    public static void main(String[] args) {
        System.out.println(zaehleNiedrige(new int[] {7200, 4100, 12500, 3800, 6400}));  // 2
        // System.out.println(anzahl);  -> Compilerfehler: anzahl ist hier unbekannt
    }
}

Verdecken: Wird in einer Methode eine lokale Variable mit demselben Namen wie eine globale Variable (oder ein Attribut) deklariert, verdeckt die lokale die äußere. Zuweisungen ändern dann nur die lokale Variable – ein häufiger Grund für „Warum bleibt mein Zähler 0?“.

Zwei Variablen tauschen

Sollen die Werte zweier Variablen getauscht werden (z. B. beim Sortieren), brauchst Du eine Hilfsvariable. Schreibst Du einfach a = b; b = a;, ist der alte Wert von a nach der ersten Zuweisung verloren und beide Variablen enthalten den Wert von b. Richtig ist:

Python Java all none

hilf = a
a = b
b = hilf

int hilf = a;
a = b;
b = hilf;

Python erlaubt zusätzlich die Kurzform a, b = b, a.

Namenskonventionen

Bezeichner (Namen von Variablen, Methoden, Klassen …) sollen aussagekräftig sein: temperaturAussen statt t, anzahlTeilnehmende statt x2. Kurze Namen wie i oder j sind nur für Laufvariablen üblich. Außerdem hat jede Sprache Schreibkonventionen:

Weitere Regeln: Bezeichner beginnen nicht mit einer Ziffer, enthalten keine Leer- und Sonderzeichen und keine reservierten Wörter (class, int, for). Umlaute sind in Java und Python zwar erlaubt, werden in Teams aber meist vermieden. Wichtiger als jede einzelne Regel ist, dass ein Projekt einheitlich schreibt; dazu legen Teams einen Styleguide fest.

Arraydaten in Dateien speichern: CSV

Arrays existieren nur, solange das Programm läuft. Sollen Messwerte dauerhaft gespeichert oder an ein anderes Programm übergeben werden, ist eine CSV-Datei (comma-separated values) eine naheliegende Lösung: je Datensatz eine Zeile, die Werte durch ein Trennzeichen getrennt.

Vergleiche mit JSON, XML und Datenbanken findest Du im Artikel Datenaustauschformate.

Typische Fehler

• Index und Nummer verwechselt: Element Nummer 7 steht bei Index 6; ein Array der Länge 24 endet bei Index 23. i <= laenge statt i < laenge greift über das Ende hinaus.
• Wertebereich falsch angegeben: Beim vorzeichenbehafteten Typ ist der positive Bereich um eins kleiner als der negative (−128 … 127, nicht −128 … 128).
• Zu kleiner Typ: 1.000 passt nicht in ein Byte, eine Dateigröße in Byte schnell nicht mehr in int. Überläufe melden sich nicht.
• Ganzzahldivision übersehen: summe / 8 mit zwei int-Werten schneidet ab; preis * 1.19 braucht als Ziel eine Gleitkommavariable.
• Gleitkomma für Geld: Rundungsfehler; besser decimal oder Cent als Ganzzahl.
• Zahlentyp für „Nummern“: Postleitzahlen und Telefonnummern verlieren als Zahl ihre führende Null.
• Variable vor der Initialisierung gelesen oder in einer Methode lokal neu deklariert, obwohl die äußere Variable gemeint war.
• Tausch ohne Hilfsvariable: Nach a = b; b = a; haben beide denselben Wert.

Leitfragen

1. Worin unterscheiden sich Deklaration, Initialisierung und Zuweisung? Antwort

Die Deklaration macht eine Variable mit Namen und Datentyp bekannt und reserviert Speicher. Die Initialisierung ist die erste Wertzuweisung (oft direkt bei der Deklaration). Jede weitere Wertvergabe ist eine Zuweisung; siehe Abschnitt „Variablen“.

2. Wie berechnest Du den Wertebereich eines Ganzzahltyps mit 16 Bit mit und ohne Vorzeichen? Antwort

Ohne Vorzeichen: 0 bis 2^{16} - 1 = 65.535. Mit Vorzeichen (Zweierkomplement): -2^{15} = -32.768 bis 2^{15} - 1 = 32.767; siehe Abschnitt „Wertebereiche“.

3. Welchen Datentyp wählst Du für einen ganzzahligen Prozentwert, und warum? Antwort

Einen vorzeichenlosen 1-Byte-Typ (z. B. byte in C#): Der Bereich 0 … 255 reicht für 0 … 100 %, negative Werte sind ausgeschlossen, und es wird nur ein Viertel des Speichers von int belegt; siehe Abschnitt „Den passenden Datentyp wählen“.

4. Nenne zwei Möglichkeiten, eine Kommazahl ohne Nachkommastellen darzustellen, und ihren Unterschied. Antwort

Typumwandlung (Cast) bzw. Abschneiden liefert für 24,8 den Wert 24; Runden liefert 25. Weitere Wege: ab- oder aufrunden, Ganzzahldivision mit Modulo, nur die Ausgabe formatieren; siehe Abschnitt „Typumwandlung“.

5. Welche Eigenschaften von Arrays sprechen für, welche gegen ihre Verwendung? Antwort

Dafür: schneller Zugriff über den Index, geringer Speicherbedarf, gut für Schleifen. Dagegen: feste Länge mit sofort belegtem Speicher, nur ein Datentyp, Einfügen und Löschen in der Mitte aufwendig, Laufzeitfehler bei falschem Index; siehe Abschnitt „Wann ist ein Array die richtige Wahl?“.

6. Warum sollen globale Variablen vermieden werden? Antwort

Globale Variablen können von jeder Stelle des Programms verändert werden. Das erzeugt versteckte Abhängigkeiten, erschwert Fehlersuche, Test und Wiederverwendung und kann bei parallelen Zugriffen zu falschen Werten führen. Lokale Variablen gelten nur in ihrem Block und können nicht versehentlich von außen geändert werden; siehe Abschnitt „Gültigkeitsbereich“.

7. Wie schreibst Du eine Variable und eine Klasse nach der Camel-Case-Konvention? Antwort

Variable in lowerCamelCase, z. B. int anzahlTeilnehmende; Klasse in UpperCamelCase, z. B. class TuerschildSteuerung; siehe Abschnitt „Namenskonventionen“.

8. Nenne je ein Argument für und gegen das Speichern von Messwerten in einer CSV-Datei. Antwort

Dafür: einfache, plattformunabhängige Textdatei, die fast jedes Programm lesen kann. Dagegen: nicht einheitlich genormt (Trennzeichen, Dezimalzeichen, Kodierung) und ohne Datentypen; siehe Abschnitt „CSV“.

Links und weitere Informationen

• Übungen: Übungsaufgaben zu Datentypen, Variablen und Arrays

• verwandte Artikel: Programmentwurf: Pseudocode, Struktogramm und PAP, Algorithmen mit Arrays, Datentypen in Python, Zeichenketten und Prüfziffern, Speicherbedarf berechnen, Datenaustauschformate

• Sprachdokumentation: Java Tutorial: Primitive Data Types (Oracle), Integrale numerische Typen in C# (Microsoft Learn), Python-Dokumentation: Built-in Types, PEP 8 – Style Guide for Python Code

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Datentypen, Variablen und Arrays: Wertebereiche, Namen und Gültigkeit” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/datentypen-variablen veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/programmierung/programmiergrundlagen. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 28.10.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]