# Lokale Variablen, Klassenvariablen, Instanzvariablen



## 777 (6. Nov 2005)

Hi Leute,
Es gibt ja bei Java 7 verschiedene Variablentypen. Drei davon haben wir jetzt in der Schule kennen gelernt. Hier eine Erklärung zu allen drei.





> 1. lokale Variablen: Sie existieren nur innerhalb des Blockes mit geschweiften Klammern, in dem sie deklariert sind. In der Praxis werden sie häufig in Methoden eingesetzt:
> 
> {
> 
> ...





Ist vielleicht als Code nen bisschen dämlich aber so isses übersichtlicher... okay

Nun versuch ich mal jede der drei Variablen mit eigenen Worten zu erklären und ich möchte halt nur gerne wissen ob das, was ich meine richtig ist... okay...



Lokale Variable: 

Diese Variable gillt alleine für den Klammerblock in dem sich sich befindet. Das kann eine Funktion oder auch eine Schleife sein. Außerhalb des Klammerpaares in dem sie declariert wurde zählt sie nichts!


Instanzvariable:

Erstellt man innerhalb eines Programmes eine Instanz so werden alle Variablen innerhalb der Klasse, in der sich die Instanz befindet zu "Instanzvariablen".  Auf diese kann aber nur innerhalb dieser Klasse zugegriffen werden, wenn man den Namen der Instanz davor schreibt. Zum beispiel würde: "Variablenname"=0 nicht funktionieren während: "Variablenname"."Instanzname"=0 funktionieren würde.


Klassenvariablen:
Auf dieser Variablen kann mit ihrem Namen zugegriffen werden, sie gelten immer und überall in der Klasse und werden durch das Schlüsselwort "static" davor gekennzeichnet.



Okay- vielleicht ein bisschen doof aber ich würde trotzdem gerne wissen ob ich alles richtig verstanden habe. Müssen nämlch ne Arbeit schreiben :-(

cya
David

PS:         :shock:  :shock:  :lol:  :lol:  :?  :?  8)  8)

_L-ectron-X hat mal den Code-Tag in einen Quote-Tag geändert, damit die Seitenansicht nicht über drei Monitore reicht. :wink: _


----------



## SnooP (6. Nov 2005)

Instanzvariablen hast du noch nicht verstanden... das mit dem Punkt was du dort beschreibst trifft auf die Klassenvariablen zu, da diese generell "nur" der Klasse insgesamt zugewiesen ist.
Klassenvariablen gelten also für alle ihre Objekte gleich... wenn du einer Klassenvariablen x den Wert 5 zuweist, dann ist in jedem Objekt diese Variable ebenfalls 5 - logisch, da die Variable nicht zu dem Objekt sondern zu der Klasse gehört...

Eine Instanzvariable hingegen gehört dem Objekt selbst, bei verschiedenen angelegten Objekten kann man für die Instanzvariable x unterschiedliche Werte zuweisen. Falls die Instanzvariable als public definiert wurde, kann man wie du glaub ich sagen wolltest mit "Instanzname.Variablenname" darauf zugreifen.

Also der Unterschied ist:
Klassenvariablen gehören zur Klasse und sind in jeder Instanz gleich,
Instanzvariablen gehören zu den Objekten und unterscheiden sich daduch von Objekt zu Objekt in ihren Werten (können sie zumindest).


----------



## Mag1c (6. Nov 2005)

Hi,

1. lokale Variablen sind relativ einfach zu verstehen. Sie existieren nur innerhalb des (Klammer-)Blocks, in dem sie definiert wurden. Methoden-Parameter sind auch lokale Variablen und existieren nur innerhalb der zugehörigen Methode.

2. Instanzvariablen sind an die Existenz einer Instanz (bzw Objekts) gebunden. Innerhalb der Instanz kann man beliebig auf diese Variable mit ihrem Namen zugreifen. Will man von außerhalb zugreifen, benötigt man eine Referenz auf die Instanz. Der Zugriff erfolgt dann mittels "referenz.variable" (sofern die Variable als public deklariert wurde. Ist sie private, kann man von außen nicht darauf zugreifen). Jede Instanz hat seine eigenen Instanzvariablen.

3. Die Klassenvariablen (static) sind an die Existenz der Klasse gebunden. Innerhalb einer Instanz dieser Klasse kann man auf solche Variablen genauso zugreifen wie auf Instanzvariablen, also einfach mit dem Variablennamen. Von außerhalb braucht man den Klassennamen und den Variablennamen, also KlasseX.variable (auch hier geht das nur, wenn die Variable public ist).


```
public class KlasseA {

  public int instanzVariable;

  public static int klassenVariable;

  public void eineMethode (int parameter) {
    int lokaleVariable = instanzVariable + parameter;
    klassenVariable = lokaleVariable;
  }
}

public class KlasseB {

  public void nochEineMethode () {
    KlasseA referenzAufKlasseA = new KlasseA();

    referenzAufKlasseA.instanzVariable = 10;     // Zugriff auf Instanzvariable über Referenz

    referenzAufKlasseA.eineMethode(20);          // Methoden werden auch über Referenzen angesprochen

    System.out.println(KlasseA.klassenVariable); // Zugriff auf Klassenvariable über Klasse
  }
}
```

Gruß
Mag1c


----------



## 777 (6. Nov 2005)

Was ist ein Objekt?
Ne schleife? oder ne ifabfrage???
Danke für die ausfürhliche antwort...


----------



## Oni (6. Nov 2005)

was man noch sagen sollte, 
Instanzvariablen sollten immer private deklariert werden und man sollte mit getter /setter methoden auf sie zugreifen.


----------



## 777 (6. Nov 2005)

getter/setter??? :-O


----------



## bygones (6. Nov 2005)

sorry, aber nimm dir ein Anfänger Buch zur Hand und les dort in Ruhe nach - da werden dann alle Begriff gut und ausführlich geklärt..... mit jeder Erklärung unserer Seite kämen neue, dir unbekannte Begriffe hinzu.

Was für Bücher gut sind findest du im Unterforum und über die Bordsuche !!


----------



## L-ectron-X (6. Nov 2005)

Ich wollte schon sagen: "Verwirrt doch den jungen Schüler nicht."
Möge die Macht mit dir sein. :wink:


----------



## 777 (6. Nov 2005)

mhhh... aber bitte kann mir noch jemand sagen, was genau ein Objekt ist???


----------



## L-ectron-X (6. Nov 2005)

Auch hier Forumsuche!
Bsp.: http://www.java-forum.org/de/viewtopic.php?t=11696


----------



## Oni (6. Nov 2005)

Zitat aus dem Java Handbuch(das buch steht kostenlos zum download bereit).

und ich kann dir nur empfehlen es zu lesen.

----------
7.2.2 Objekte

Um von einer Klasse ein Objekt anzulegen, muß eine Variable vom Typ der Klasse deklariert und ihr mit Hilfe des new-Operators ein neu erzeugtes Objekt zugewiesen werden:

```
001 Auto meinKombi;
002 meinKombi = new Auto();

Listing 7.2: Erzeugen eines Objekts mit new
```

Die erste Anweisung ist eine normale Variablendeklaration, wie sie aus Kapitel 4 bekannt ist. Anstelle eines primitiven Typs wird hier der Typname einer zuvor definierten Klasse verwendet. Im Unterschied zu primitiven Datentypen wird die Objektvariable meinKombi als Referenz gespeichert. Die zweite Anweisung generiert mit Hilfe des new-Operators eine neue Instanz der Klasse Auto und weist sie der Variablen meinKombi zu.

In Java wird jede selbstdefinierte Klasse mit Hilfe des new-Operators instanziert. Mit Ausnahme von Strings und Arrays, bei denen der Compiler auch Literale zur Objekterzeugung zur Verfügung stellt, gilt dies auch für alle vordefinierten Klassen der Java-Klassenbibliothek.



Wie bei primitiven Variablen lassen sich beide Anweisungen auch kombinieren. Das nachfolgende Beispiel deklariert und initialisiert die Variable meinKombi:

 Tip 


```
001 Auto meinKombi = new Auto();
```

Listing 7.3: Kombinierte Deklaration und Initialisierung einer Objektvariablen

Nach der Initialisierung haben alle Variablen des Objekts zunächst Standardwerte. Referenztypen haben den Standardwert null, die Standardwerte der primitiven Typen können Tabelle 4.1 entnommen werden. Der Zugriff auf sie erfolgt mit Hilfe der Punktnotation Objekt.Variable. Um unser Auto-Objekt in einen 250 PS starken Mercedes 600 des Baujahrs 1972 zu verwandeln, müßten folgende Anweisungen ausgeführt werden:

```
001 meinKombi.name = "Mercedes 600";
002 meinKombi.erstzulassung = 1972;
003 meinKombi.leistung = 250;
```

Listing 7.4: Zuweisen von Werten an die Variablen eines Objekts

Ebenso wie der schreibende erfolgt auch der lesende Zugriff mit Hilfe der Punktnotation. Die Ausgabe des aktuellen Objektes auf dem Bildschirm könnte also mit den folgenden Anweisungen erledigt werden:

```
001 System.out.println("Name........: "+meinKombi.name);
002 System.out.println("Zugelassen..: "+meinKombi.erstzulassung);
003 System.out.println("Leistung....: "+meinKombi.leistung);
```


----------



## SnooP (6. Nov 2005)

Jetzt wirds langsam komplizierter  ... das ist das so schöne Geheimnis der Objektorientierung, die jetzt am Anfang des Programmierenlernens noch nicht soo das Thema ist... trotzdem wage ich eine kleine Erklärung 

Stelle dir die reale Welt vor - man ist als Mensch gewohnt in Objekten zu denken: Tische, Stühle... und unethischerweise auch Personen etc... solche Objekte haben die Eigenschaft, dass man sie oft zu einer so genannten Klasse zusammenfassen kann, also eine Art allgemeingültige Struktur der alle zugehörigen Objekte unterliegen...

Bleistift: Es gibt die unterschiedlichsten Personen die sich alle in einer vielzahl von Attributen unterscheiden - dennoch unterliegen sie alle einem bestimmten Grundmuster - jeder Mensch hat (zumindest meistens) zwei Arme, Augen, Beine etc.
Diese Grundstruktur ist in einer Klasse Person zusammengefasst, während Objekte vom Typ dieser Klasse Person lediglich verschiedene Ausprägungen dieser Klasse sind (Instanzen - oder besser Exemplare, das Wort Instanz ist im Deutschen imho hier nicht wirklich treffend).
Ein Objekt vom Typ Person könnte jetzt also die Augenfarbe definieren oder auch andere Attribute konkretisieren, wie etwa den Namen einer Person. Alle Attribute, die bereits von der Klasse vorgegeben wurden.

Jetzt das ganze umgewandelt in die Java-Welt:


```
public class Person {
  //Ein einfaches Personenklassenbeispiel mit lediglich zwei Attributen

   private static int anzPersonen;

   private int alter;
   private String name;

   //Beispiel einer get/set Methode:
   
   public void setAlter(int alter) {
      this.alter = alter;   //das Schlüsselwort this bezieht sich auf das aktuelle Objekt 
      //(dient hier zur Unterscheidung zwischen der lokalen 
      //Methodenvariable alter und der Instanzvariablen alter)
   }

   public int getAlter() {
      return this.alter;
   }

   public static int anzahlAllerPersonen() {
       return anzPersonen;
   }


   //Der sog. Konstruktor wird aufgerufen bei der Verwendung von "new Person(alter, name)"
   public Person (int alter, String name) {
      //das ist eine Klassenvariable die bei der Erstellung des Objekts Person erhöht wird:
      anzPersonen++;   
      this.alter = alter;
      this.name = name;
   }

   public static void main (String[] args) {
       Person p1 = new Person(56, "Horst");
       Person p2 = new Person(32, "Dieter");
       //...
       System.out.println("Alter von Person 1: "+p1.getAlter());

       System.out.println("Es wurden "+Person.anzahlAllerPersonen()+" Objekte erstellt");
   }
}
```

Das Konzept dahinter ist für den Anfang nicht leicht zu verstehen. Dabei ist am Anfang am leichtesten noch nachzuvollziehen, dass durch die Kapselung von Aufgaben (Methoden) und Daten (in den Attributen oder Instanzvariablen) in einer Klasse die vielbeschworene Wiederverwendbarkeit erleichtert wird. Die Objekte die man aus den Klassen erzeugen kann ermöglichen, dass sich für verschiedene Aufgaben andere Ausprägungen zu unterschiedlichen Ergebnissen aus strukturell gleichen Berechnungen ergeben können...

Hinter Objektorientierung verbirgt sich dann noch erheblich mehr... Stichworte sind Vererbung, Typen, Schnittstellen, Polymorphie, etc... - das ist aber für den Anfang wirklich etwas zu viel... Sprich - merk dir erstmal obiges, ansonsten versuche dich in einfachen Programmieraufgaben die irgendwas berechnen oder umsetzen sollen und übe dich in ifs und diversen Schleifen - das ist erstmal das wichtigste Handwerkszeug für einen Programmierer, danach kannste dann voll einsteigen


----------



## 777 (6. Nov 2005)

Das ist zu hoch für mich :-(


----------



## SnooP (6. Nov 2005)

wie gesacht... das ist am Anfang nicht soo einfach... muss man sich erst am besten eher abstrakt klarmachen. Am Anfang sind andere Dinge auch erstmal wichtiger... nicht zuletzt deswegen wird bei uns an der Uni auch erstmal bewusst ohne Objekte programmiert, bis die Leute das Handwerkszeug drauf haben - dann kanns richtig losgehen


----------



## 777 (6. Nov 2005)

Wie lang wird das noch dauern, bis ich "richtig durchsteigen" kann???
Mich würde ohnehin einmal interessieren, wann man bestimmte Programmierpsrachen so drauf hat, dass man schon was guteszustande bringen kann.
Wie lange brauche ich zum Beispiel für Java, C, C++, PHP, HTML und Assembler. Das lern ich nämlich grad alles auf einmal in der Schule 
David


----------



## SnooP (6. Nov 2005)

Das ist unsinnig... wichtig ist Programmieren zu lernen und nicht eine spezielle Sprache... wenn man das kann, dann kann man ohne Umstände Java, C, C++ oder PHP programmieren... das Einarbeiten in die speziellen Sprachkonzepte oder die jeweilige Syntax dauert dann nicht lange... - von daher - es geht ums Programmieren-Denken  ... dabei hilft am Anfang erstmal eine Sprache gut zu lernen, wie etwa Java...

Assembler hat imho in der Schule nicht wirklich was zu tun.. damit kann dort doch sowieso niemand was anfangen und bringt auch nur einen superkleinen Teil von Leuten später was... ich hab z.B. Assembler praktisch nie angewendet - nur nen theoretischen Assembler-Dialekt kurz angelernt, um das Prinzip zu verstehen - obwohl ich dann später im Studium sogar technische Informatik als Vertiefung hatte...

Um eine Programmiersprache gut zu können, brauchst du in etwa nen Jahr intensives Beschäftigen damit, wenn du vorher noch nie programmiert hast.. danach ist man einigermaßen fit... dann ist man aber auch noch kein Programmierer  ... wenn man dann das erste Mal nen Programm geschrieben hat mit ~10.000 Zeilen Code, dann kommt man in den Bereich wo man sagen kann - okay... ich hab ein wenig Programmiererfahrung...
Beim zweiten Projekt in der Größenordnung merkt man dann, was man alles inzwischen besser kann 

Wichtig beim Programmieren-Lernen ist halt das ständige üben...


----------

