Quelltext der Seite Kapitel 7: Objekte und Klassen

[[Informatik_10._Klasse_13-14|Zur Startseite]] - [[Kapitel_1:_Vorbereitende_Aufgaben_und_Einstieg|Kapitel 1]] - [[Kapitel_2:_Variablen_und_Datentypen|Kapitel 2]] - [[Kapitel_3:_Kontrollstrukturen|Kapitel 3]] - [[Kapitel_4:_Methoden|Kapitel 4]] - [[Kapitel_5:_Arrays|Kapitel 5]] - [[Kapitel_6:_Objektorientierung|Kapitel 6]]


Bisher haben wir vornehmlich Datentypen verwendet, die in JAVA vordefiniert sind (z.B.''int'', ''double'', ''String''). Die große Stärke einer objektorientierten Programmiersprache besteht darin, dass wir als Programmierer eigene Datentypen in Form von Klassen nach unseren Vorstellungen und Bedürfnissen erstellen können. Eine '''Klasse''' beschreibt entsprechend den '''Aufbau eines komplexen Datentyps'''. 

<br> 

Beispiele für Objekte der Klasse ''Rechteck'': 

[[Datei:Obj1.JPG]]

Wie wir bereits aus der 6.Klasse wissen, lassen sich diese Objekte der Klasse Rechteck auch in Form von '''Objektdiagrammen''' darstellen. 

[[Datei:Klass1.JPG]]

Diese Darstellung von Objekten beinhaltet neben dem Objektnamen, der nach einer Konvention immer klein geschrieben wird, die '''Attribute''' des Objekts und die jeweiligen '''Attributwerte'''. Sie definieren den '''Zustand''' des Objekts. Objekte mit den denselben Attributen sind '''Instanzen''' einer Klasse. Eine Klasse stellt einen Konstruktionsplan für bestimmte Objekte dar, der mit all seinen Informationen auch ohne diese Objekte existiert. Eine Klasse ist also keine Menge von Objekten! 

<br> 

Die Definition einer Klasse beinhaltet drei Bestandteile: 

<br> 

*Die Datenfelder bzw. Instanzvariablen speichern die Daten, die das jeweilge Objekt benutzt. 
*Die Konstruktoren erlauben es, neue Objekte zu erzeugen und diese in einen bestimmten Anfangszustand zu versetzen. 
*Die Methoden implementieren das Verhalten der Objekte.


<big>[[Exkurs: UML]]</big>


<br> Beispiel: Die Klasse ''Rechteck'' 

[[Datei:Klass2.JPG]]

Instanzvariablen und Methoden haben wir bereits kennengelernt. Neu sind die sogenannten Konstruktoren. 

<br> 

=== Konstruktor  ===

Eine Klasse kann keinen, einen oder mehrere unterschiedliche Konstruktoren besitzen. Sie dienen dazu, ein neu gebildetes Objekt einer Klasse in einen definierten Anfangszustand zu versetzen. Welcher dies ist hängt davon ab, welcher Konstruktor bei der Objektbildung aufgerufen wird. Ein leerer (Standard-) Konstruktor muss nicht angegeben werden, er wird bei Fehlen von der JVM (Java Virtual Machine) automatisch erzeugt. Aus diesem Grund hatten wir in unseren bisherigen Aufgaben keinen expliziten Konstruktor. 

'''Syntax:''' 
<pre> public nameDerKlasse(Parameter) {}
</pre> 
<br> '''Beispiel''': Konstruktoren der obigen Klasse ''Rechteck'': 

'''public Rechteck()''' weist dem Rechteck standardmäßig Werte zu. 
<pre>public Rechteck(){
breite = 10;
hoehe = 7;
}
</pre> 
Wir erhalten bei Aufruf des Konstruktors ein Rechteck der Größe 10x7. Die restlichen Werte werden von der JVM auf einen internen Standardwert gesetzt. 

<br> 

'''public Rechteck(breite, hoehe)''' gibt dem User die Möglichkeit, die Größe des Rechtecks selbst zu bestimmen. 

<br> 
<pre>public Rechteck(int breite, int hoehe){
this.breite = breite;
this.hoehe = hoehe;
}
</pre> 
Hier werden nach Aufruf des Konstruktors den Instanzvariablen die entsprechenden Werte der Parameter zugewiesen. Das Schlüsselwort '''this''' liefert innerhalb eines Objekts immer eine Referenz auf das Objekt selbst, d.h. es steht in der bekannten Punktschreibweise an der Stelle des Objektnamens einfach das Wort '''this'''. 

<br> 

'''public Rechteck(breite, hoehe, fuellfarbe)''' gibt dem User die Möglichkeit, neben der Größe des Rechtecks auch noch dessen Füllfarbe festzulegen. 

<br> 
<pre>public Rechteck(int breite, int hoehe, String fuellfarbe){
this.breite = breite;
this.hoehe = hoehe;
this.fuellfarbe = fuellfarbe
}
</pre> 
<br> 

Konstruktoren können also mit unterschiedlichen Parameterlisten deklariert sein. Man spricht hier vom '''Überladen''' des Konstruktors.


==== Konstruktoraufruf  ====

Neue Instanzen einer Klasse werden mit dem Operator '''''new''''' erzeugt. 
<pre>Rechteck rechteck1 = new Rechteck();

Rechteck rechteck2 = new Rechteck(12,8);

Rechteck rechteck3 = new Rechteck(15,4,"rot");
</pre> 
Die drei erzeugten Rechtecke sind vom Typ Rechteck; d.h. sie sind Instanzen der Klasse Rechteck.<br> ''rechteck1'' wird mit dem Standardkonstruktor erzeugt und hat die Größe 10x7.<br> ''rechteck2'' wird vom User auf die Größe 12x8 festgelegt<br> ''rechteck3'' bekommt vom User die Größe 15x4 und die Füllfarbe ''rot'' zugewiesen. 

Hier sollte nun deutlich werden, dass das erzeugte Objekt eine Variable ist, die nach dem Plan der Klasse ''Rechteck'' aufgebaut ist. Erst wenn das Objekt erzeugt wurde, kann mittels Punktschreibweise auch auf die Eigenschaften des Objekts zugegriffen werden. Beispiel:<br> 

rechteck1.breite = 10; 

rechteck3.fuellfarbe = "rot" 

<br> 

<big>[[Aufgaben 7.1.]]</big>


===Getter- und Setter-Methoden===

Will man von außen auf ''private'' gesetzte Attribute zugreifen, ist dies nur indirekt möglich. Wir nutzen dazu Methoden, die das betreffende Objekt veranlassen, Werte zurückzugeben bzw. zu verändern. Zur Rückgabe von Werten nutzt man sogenannte '''sondierende Methoden''' oder '''Getter-Methoden'''. Üblicherweise verwendet man als Namen für eine derartige Methode den Bezeichner ''getAttributname''. 

Soll der Benutzer auch schreibenden Zugriff auf die Attribute haben, dann erstellt man sogenannte '''Setter-Methoden''', die von außen einen Wert übernehmen und dem auf ''private'' gesetzten Attribut zuweisen. Als Bezeichner verwendet man analog zu den Getter-Methoden ''setAttributname''. Beispiel:

<pre>
public class Rechteck {

private int laenge;
private int breite;

public Rechteck(int laenge, int breite){
this.laenge=laenge;
this.breite=breite;
}

public int getLaenge(){
   return laenge;
}

public int getBreite(){
   return breite;
}

public void setLaenge(int l){
   laenge=l;
}

public void setBreite(int b){
   breite=b;
}
}
</pre>

Setter- und Getter-Methoden müssen natürlich auf ''public'' gesetzt werden, um die ihnen zugedachte Aufgabe zu erfüllen.

Bis hierher ist eigentlich noch nicht klar, warum wir den direkten Lese- bzw. Schreibzugriff auf die Attribute kontrollieren sollten. Die Stärke dieses Verfahrens zeigt sich dann, wenn es für den Zugriff Beschränkungen gibt. So kann beispielsweise die Eingabe auf einen bestimmten Wertebereich beschränkt werden und im Fall einer unerlaubten Eingabe die Eingabe verweigert werden. Beispiel: Um zu vermeiden, dass ein Objekt der obigen Klasse '''Rechteck''' einen bestimmten Wert für die Länge bzw. Breite überschreitet, kann man die Methode mit einer bedingten Anweisung versehen:

<pre>
public void setLaenge(int l){
if(l>=100){System.out.println("Unzulaessiger Wert !");}else{
   laenge=l;}
}

public void setBreite(int b){
if(b>=100){System.out.println("Unzulaessiger Wert !");}else{
   breite=b;
}
}
</pre>


<big>[[Aufgaben 7.2.]]</big>

=== Klassenvariablen und Klassenmethoden ===

Bis jetzt kennen wir bei Variablen zwei Typen: '''Lokale Variablen''', wie wir sie beispielsweise in Schleifen als Zählvariablen verwenden, und '''Instanzvariablen'''. Innerhalb der Klasse ''Kreis'', die sozusagen den Datentyp ''Kreis'' definiert, haben wir beispielsweise ''Radius'', ''Fuellfarbe'' oder ''Linienstärke'' als Instanzvariablen. Jede Variable wird für sich separat für eine Instanz (also ein aus der Klasse erzeugtes Objekt) angelegt, d.h. jede Instanz hat eine eigene Kopie der Variablen. Die Methoden beziehen sich auf die jeweils angelegte Instanz.

Damit alle Objekte einer Klasse eine bestimmte Variable gemeinsam verwenden können, gibt es die sog. '''Klassenvariablen'''. Analog dazu benutzt man '''Klassenmethoden''' für Operationen, die sich nicht auf ein bestimmtes Objekt, sondern auf die Klasse an sich beziehen. Variablen und Methoden werden mit dem Schlüsselwort '''''static''''' an die jeweilige Klasse gebunden. Der Zugriff auf statische Variablen erfolgt über '''Klassenname.Variablenname''', der Zugriff auf statische Methoden über '''Klassenname.Methodennname'''

Folgendes Beispiel soll das Konzept verdeutlichen:

In einer Klasse '''InstanzenZaehler''' wird eine statische Variable '''''zaehler''''' angelegt, in der die Anzahl der erzeugten Instanzen der Klasse abgespeichert wird. Über eine statische Getter-Methode kann der aktuelle Wert des Zählers abgefragt werden. In einer zweiten Klasse '''ZaehlerTest''' werden drei Instanzen der Klasse '''InstanzenZaehler''' erzeugt und als Kontrolle ihre jeweilige Rangzahl ausgegeben. Am Ende wird über die Methode '''getZaehler()''' die Anzahl der erzeugten Instanzen abgefragt.

<pre>
public class InstanzenZaehler {
   
// Klassenvariable
    static int zaehler = 0;

// Instanzvariable
    int nummer;
    
// Konstruktor 
    public InstanzenZaehler() {
        zaehler= zaehler+1;
        nummer = zaehler;
    }

// Klassenmethode
    static int getZaehler() {
       return zaehler;
    }
}


public class ZaehlerTest{

public void zaehlerTest(){
    System.out.println("Klassenvariable zaehler:"+ InstanzenZaehler.getZaehler());
        
        InstanzenZaehler inst_1 = new InstanzenZaehler();
        InstanzenZaehler inst_2 = new InstanzenZaehler();
        InstanzenZaehler inst_3 = new InstanzenZaehler();
    
        System.out.println("Instanzvariable nummer im 1. Objekt: "+ inst_1.nummer);
        System.out.println("Instanzvariable nummer im 2. Objekt: "+ inst_2.nummer);
        System.out.println("Instanzvariable nummer im 3. Objekt: "+ inst_3.nummer);

        System.out.println("Klassenvariable zaehler: " + InstanzenZaehler.getZaehler());
   
}
}

</pre>


<big>[[Aufgaben 7.3.]]</big>