≪ View Page

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
programmierung:lokal-global-variables [2024/09/04 10:04] – sweprogrammierung:lokal-global-variables [2025/12/20 14:53] (current) – external edit 127.0.0.1
Line 1: Line 1:
-===== Lokale Variablen =====+# Gültigkeitsbereich (Scope)
  
-- **Definition**: Variablen, die innerhalb einer Methode oder eines Blocks deklariert werden.\\ +Der **Gültigkeitsbereich** oder **Scope** einer Variablen beschreibt, in 
-- **Sichtbarkeit**: Nur innerhalb der Methode oder des Blocks, in dem sie deklariert wurden.\\ +welchem Teil des Codes die Variable sichtbar und nutzbar ist. In Java 
-- **Lebensdauer**: Existieren nur während der Ausführung der Methode oder des Blocks.+gibt es verschiedene Arten von Gültigkeitsbereichen:
  
-===== Globale Variablen (Instanz- und Klassenvariablen) =====+1.  **Lokaler Scope**: Variablen, die innerhalb einer Methode oder eines 
 +    Blocks (z.B. einer Schleife) deklariert werden. 
 +2.  **Klassen-Scope**: Variablen, die als Instanzvariablen innerhalb 
 +    einer Klasse deklariert werden. 
 +3.  **Globaler Scope**: In Java gibt es keinen echten globalen Scope, da 
 +    alles innerhalb von Klassen definiert wird.
  
-- **Definition**: Variablen, die außerhalb von Methoden, aber innerhalb einer Klasse deklariert werden.\\ +**Beispiel mit `for`-Schleifen**
-  - **Instanzvariablen**: Werden ohne das Schlüsselwort `static` deklariert.\\ +
-  - **Klassenvariablen**: Werden mit dem Schlüsselwort `static` deklariert.\\ +
-- **Sichtbarkeit**: Abhängig von den Zugriffsmodifikatoren (`private`, `protected`, `public`), aber generell innerhalb der gesamten Klasse.\\ +
-- **Lebensdauer**: Existieren während der gesamten Lebensdauer der Instanz (bei Instanzvariablen) oder der Klasse (bei Klassenvariablen).\\+
  
-**Beispielcode** +In `for`-Schleifen ist der Scope der Schleifenvariablen auf den 
-<code java| download> +Schleifenblock beschränkt. Hier ein einfaches Beispiel:
-public class VariableExample { +
-    // Globale Variable (Instanzvariable) +
-    private int globalCounter = 0; +
- +
-    // Globale Variable (Klassenvariable) +
-    private static int globalStaticCounter = 0; +
- +
-    public void demonstrateLocalVariable() { +
-        // Lokale Variable +
-        int localCounter = 0;+
  
 +```java
 +public class ScopeExample {
 +    public static void main(String[] args) {
         for (int i = 0; i < 5; i++) {         for (int i = 0; i < 5; i++) {
-            localCounter++; +            System.out.println("i innerhalb der Schleife: " + i);
-            globalCounter++; +
-            globalStaticCounter++; +
-            System.out.println("Local Counter: " + localCounter); +
-            System.out.println("Global Counter: " + globalCounter); +
-            System.out.println("Global Static Counter: " + globalStaticCounter);+
         }         }
 +        // System.out.println(i); // Dies würde einen Fehler verursachen, da i außerhalb des Scopes ist.
     }     }
 +}
 +```
  
-    public static void main(String[] args) { +In diesem Beispiel ist die Variable `i` nur innerhalb der `for`-Schleife 
-        VariableExample example = new VariableExample(); +sichtbar. Wenn du versuchst, `i` außerhalb der Schleife zu verwenden, 
-        example.demonstrateLocalVariable();+erhältst du einen Kompilierungsfehler, weil `i` außerhalb ihres 
 +Gültigkeitsbereichs liegt.
  
-        // Zugriff auf die Klassenvariable ohne Instanz +**Verschachtelte `for`-Schleifen** 
-        for (int i = 0; i < 5; i++) { + 
-            globalStaticCounter++; +Auch in verschachtelten `for`-Schleifen hat jede Schleifenvariable 
-            System.out.println("Global Static Counter in main: " + globalStaticCounter);+ihren eigenen Scope: 
 + 
 +```java 
 +public class NestedLoopExample { 
 +    public static void main(String[] args) { 
 +        for (int i = 0; i < 3; i++) { 
 +            for (int j = 0; j < 2; j++) { 
 +                System.out.println("i: " + i + ", j: " + j); 
 +            }
         }         }
     }     }
 } }
-</code>+``` 
 + 
 +Hier haben `i` und `j` jeweils ihren eigenen Scope innerhalb der 
 +jeweiligen Schleifen. Du kannst `i` und `j` außerhalb ihrer Schleifen 
 +nicht verwenden. 
 + 
 +\<WRAP center round important 60%\> 
 + 
 +1.  **Deklaration innerhalb der Schleife**: Variablen, die innerhalb 
 +    einer `for`-Schleife deklariert werden, sind nur innerhalb dieser 
 +    Schleife sichtbar. 
 +2.  **Wiederverwendung von Variablennamen**: Du kannst denselben 
 +    Variablennamen in verschiedenen Schleifen verwenden, da jede 
 +    Schleife ihren eigenen Scope hat.
  
-**Erklärung**\\ +\</WRAP\>
-- **Lokale Variable** `localCounter` wird innerhalb der Methode `demonstrateLocalVariable` deklariert und ist nur dort sichtbar.\\ +
-- **Instanzvariable** `globalCounter` ist innerhalb der gesamten Klasse sichtbar und wird bei jeder Instanz der Klasse `VariableExample` separat gehalten.\\ +
-- **Klassenvariable** `globalStaticCounter` ist ebenfalls innerhalb der gesamten Klasse sichtbar, aber es gibt nur eine Kopie dieser Variable, die von allen Instanzen der Klasse geteilt wird.+