≪ 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:08] – 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)
  
-===== Lokale Variablen =====+Der **Gültigkeitsbereich** oder **Scope** einer Variablen beschreibt, in 
 +welchem Teil des Codes die Variable sichtbar und nutzbar ist. In Java 
 +gibt es verschiedene Arten von Gültigkeitsbereichen:
  
-- **Definition**: Variablen, die innerhalb einer Methode oder eines Blocks deklariert werden.\\ +1.  **Lokaler Scope**: Variablen, die innerhalb einer Methode oder eines 
-- **Sichtbarkeit**: Nur innerhalb der Methode oder des Blocks, in dem sie deklariert wurden.\\ +    Blocks (z.B. einer Schleife) deklariert werden. 
-- **Lebensdauer**: Existieren nur während der Ausführung der Methode oder des Blocks. +2.  **Klassen-Scope**: Variablen, die als Instanzvariablen innerhalb 
-===== Globale Variablen (Instanz- und Klassenvariablen) =====+    einer Klasse deklariert werden. 
 +3.  **Globaler Scope**: In Java gibt es keinen echten globalen Scope, da 
 +    alles innerhalb von Klassen definiert wird.
  
-===== Globale Variablen (Instanz- und Klassenvariablen) =====+**Beispiel mit `for`-Schleifen**
  
-- **Definition**: Variablen, die außerhalb von Methoden, aber innerhalb einer Klasse deklariert werden. +In `for`-Schleifen ist der Scope der Schleifenvariablen auf den 
-   - **Instanzvariablen**: Werden ohne das Schlüsselwort `static` deklariert. +Schleifenblock beschränkt. Hier ein einfaches Beispiel:
-  - **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**+```java 
 +public class ScopeExample { 
 +    public static void main(String[] args) { 
 +        for (int i = 0; i < 5; i++) { 
 +            System.out.println("i innerhalb der Schleife: " + i); 
 +        } 
 +        // System.out.println(i); // Dies würde einen Fehler verursachen, da i außerhalb des Scopes ist. 
 +    } 
 +} 
 +```
  
-download+In diesem Beispiel ist die Variable `i` nur innerhalb der `for`-Schleife 
 +sichtbar. Wenn du versuchst, `i` außerhalb der Schleife zu verwenden, 
 +erhältst du einen Kompilierungsfehler, weil `i` außerhalb ihres 
 +Gültigkeitsbereichs liegt.
  
-<code java> +**Verschachtelte `for`-Schleifen**
-public class VariableExample { +
-    // Globale Variable (Instanzvariable) +
-    private int globalCounter = 0;+
  
-    // Globale Variable (Klassenvariable) +Auch in verschachtelten `for`-Schleifen hat jede Schleifenvariable 
-    private static int globalStaticCounter = 0; +ihren eigenen Scope:
- +
-    public void demonstrateLocalVariable() { +
-        // Lokale Variable +
-        int localCounter = 0; +
- +
-        for (int i = 0; i < 5; i++) { +
-            localCounter++; +
-            globalCounter++; +
-            globalStaticCounter++; +
-            System.out.println("Local Counter: " + localCounter); +
-            System.out.println("Global Counter: " + globalCounter); +
-            System.out.println("Global Static Counter: " + globalStaticCounter); +
-        } +
-    }+
  
 +```java
 +public class NestedLoopExample {
     public static void main(String[] args) {     public static void main(String[] args) {
-        VariableExample example = new VariableExample(); +        for (int i = 0; i < 3; i++) { 
-        example.demonstrateLocalVariable(); +            for (int j = 0; j < 2; j++) { 
- +                System.out.println("i: " + i + ", j: " + j); 
-        // Zugriff auf die Klassenvariable ohne Instanz +            }
-        for (int i = 0; i < 5; i++) { +
-            globalStaticCounter++; +
-            System.out.println("Global Static Counter in main: " + globalStaticCounter);+
         }         }
     }     }
 } }
 +```
 +
 +Hier haben `i` und `j` jeweils ihren eigenen Scope innerhalb der
 +jeweiligen Schleifen. Du kannst `i` und `j` außerhalb ihrer Schleifen
 +nicht verwenden.
  
-</code>+\<WRAP center round important 60%\>
  
-**Erklärung** \\ - **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.+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.
  
 +\</WRAP\>