Java Basis-Sprachelemente: Unterschied zwischen den Versionen

Aus SibiWiki
Zur Navigation springen Zur Suche springen
 
(71 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 2: Zeile 2:
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Informatik-EF]]
[[Kategorie:Informatik-EF]]
 
[[Kategorie:Informatik-Q1]]


=Allgemeines=
=Allgemeines=
Zeile 8: Zeile 8:


Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:
* [[Klasse_in_Java]]
* [[Klasse]]
==Erklärvideos==


= Anforderungen Zentralabitur =
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/>
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.
&nbsp;
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!
&nbsp;
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/>
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.
&nbsp;
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;


Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.
=lokale Variable=
* lokale Variablen müssen '''deklariert''' werden. <br/>Das heißt: Man legt fest, welchen '''Typ''' die Variable hat. <br/>Häufige Typen von Variablen sind:
** <code>int</code>: Für eine ganze Zahl.
** <code>double</code>: Für eine Kommazahl.
** <code>String</code>: Für einen Text
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen.
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.


'''Stand: 2012 (im April 2013 noch aktuell)'''
'''Beispiel:'''
<code>
    public int summeZahlenBis100Ausgeben()
    {
        // Deklaration der lokalen Variable zahl; zahl wird auf 1 gesetzt.
        '''int zahl = 1''';
        // Deklaration der lokalen Variable ergebnis; ergebnis wird auf 0 gesetzt.
        '''int ergebnis = 0''';
        // Schleife, mit der bis 100 gezählt wird.
        while( zahl <= 100) {
          // Ergebnis wird um zahl erhöht.
          '''ergebnis += zahl''';
          // zahl wird um 1 erhöht.
          '''zahl++''';
        }
        // ergebnis zurückgeben
        return ergebnis;
    }
</code>
 
= Wertzuweisungen =
Attributen und lokalen Variablen können Werte zugewiesen werden.
* Beispiel 1:
** <code>geschwindigkeit = 10;</code>
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.
* Beispiel 2:
** <code>geschwindigkeit = neueGeschwindigkeit;</code>
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.
* Beispiel 3:
** <code>geschwindigkeit = geschwindigkeit + 1;</code>
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!
* Allgemein:
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.
** '''rechts vom Gleichzeichen''' steht der neue Wert.
 
 
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.
 
* Beispiel 4:
** <code>geschwindigkeit '''+=''' 5;</code>
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.
* Beispiel 5:
** <code>geschwindigkeit'''++''';</code>
** '''<code>++</code>''' bedeutet: erhöhe um eins.
 
= Bedingungen (if-else) =
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.
 
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.
 
<code>
  public int bestimmeDieGroessere(int a, int b)
  {
    int ergebnis;
    '''if(a > b)'''
    {
        ergebnis = a;
    }
    '''else'''
    {
        ergebnis = b;
    }
    return ergebnis;
  }
</code>
 
'''VORSICHT:'''
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:
<code>
  // Wenn x gleich drei ist, ...
  if(x '''==''' 3)
  {
      ...
  }
</code>
 
= Schleifen (while, for, do-while) =
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.
== for-Schleife ==
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.
 
'''Beispiel:'''
 
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.
 
<code>
  '''for(int i=0; i<=333; i++)'''
  {
    System.out.println(3*i);
  }
</code>
 
'''Erläuterung:'''
 
* Die Klammer nach dem <code>for</code> hat drei Teile:
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.
 
==while-Schleife==
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.
 
'''Erklärvideo'''<br>
'''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)
 
'''Beispiel:'''<br/>
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <br/>
<code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, <br/>wie <code>zahl</code> kleiner als 1000 ist. <br/>D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.
<code>
  int zahl = 1;
  '''while(zahl < 1000)'''
  {
    System.out.println(zahl);
    // zahl verdoppeln
    zahl = zahl * 2;
  }
</code>
'''Erläuterung:'''
* Die Klammer nach dem <code>while</code> enthält die Bedingung: <br/>Wiederhole, solange zahl kleiner 1000 ist.
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben <br/>und dann mit <code>zahl = zahl * 2;</code> verdoppelt.


*  Klassendefinitionen
* Beziehungen zwischen Klassen
** gerichtetete Assoziation
** Vererbung
* Attribute und Methoden (mit Parametern und Rückgabewerten)
* Wertzuweisungen
* Verzweigungen (if, switch)
* Schleifen (while, for, do-while)


=  Klasse, Objekt, Klassendefinition =
=  Klasse, Objekt, Klassendefinition =
Zeile 32: Zeile 166:


* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.
* Beispiel: Es gibt eine Klasse <code>Crab</code>, von der man viele einzelne Objekte erzeugen kann.
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.
* Java: Definiton einer Klasse:
* Java: Definiton einer Klasse:
<code>  
<code>  
   <u>public class Crab</u>
   '''public class Baum'''
   {
   {
     // Attribute
     // Attribute
Zeile 49: Zeile 183:
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen. Für Namen eignet sich <code>String</code>.
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''
* Java:
* Java:
** Attribute werden direkt nach der Klassen-Deklaration notiert.
** Attribute werden direkt nach der Klassen-Deklaration notiert.
Zeile 56: Zeile 190:
'''Beispiel 1:'''
'''Beispiel 1:'''


Objekte der Klasse <code>Crab</code> können unterschiedliche Geschwindigkeiten haben.
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.


Dafür gibt es das Attribut <code>geschwindigkeit</code>
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.


<code>
<code>
  public class Crab
  public class Auto
  {
  {
   // Attribute
   // Attribute
   <u>private int geschwindigkeit;</u>
   '''private double tankstand;'''
            
            
   // Konstruktor
   // Konstruktor
Zeile 70: Zeile 204:
   // Methoden
   // Methoden
  }
  }
</code>
</code>




'''Beispiel 2:'''
'''Beispiel 2:'''


Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''


Objekte der Klasse <code>Baum</code> bestehen aus einen Quadrat (für den Stamm) und einem Kreis (für die Krone).
<code>
 
 
<code>
   public class Baum
   public class Baum
   {
   {
     // Attribute
     // Attribute
     <u>private Quadrat stamm;</u>
     '''private Quadrat stamm;'''
     <u>private Kreis krone;</u>
     '''private Kreis krone;'''
          
          
     // Konstruktor
     // Konstruktor
Zeile 90: Zeile 222:
     // Methoden
     // Methoden
   }
   }
</code>
</code>


= Konstruktor =
= Konstruktor =
'''Aufruf des Konstruktors:'''
'''Aufruf des Konstruktors:'''
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:
* Java: <code>Crab neueKrabbe = <u>new Crab()</u>;</code>
* Java: <code>Auto neuesAuto = '''new Auto()''';</code>
 


'''Deklaration des Konstruktors:'''
'''Deklaration des Konstruktors:'''
Zeile 103: Zeile 236:


Beispiel:
Beispiel:
<code>
 
   public class Crab
<code>
   public class Auto
   {
   {
     // Attribute
     // Attribute
     private int geschwindigkeit;   
     private int tankstand;   
      
      
     // Konstruktor
     // Konstruktor
     <u>public Crab()</u>
     '''public Auto()'''
     <u>{</u>
     '''{'''
       <u>turn(50);</u>
       '''tankstand = 5.0;'''
     <u>}</u>
     '''}'''
    
    
     // Methoden
     // Methoden
   }
   }
</code>
</code>




Dadurch wird jede Krabbe bei der Erzeugung um 50 Grad gedreht.
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.


== Konstruktor mit Parameter ==
== Konstruktor mit Parameter ==
Zeile 126: Zeile 260:


Beispiel:
Beispiel:
<code>
 
   public class Crab
<code>
   public class Auto
   {
   {
     // Attribute
     // Attribute
     private int geschwindigkeit;   
     private double tankstand;   
      
      
     // Konstruktor
     // Konstruktor
     <u>public Crab(int pGeschwindigkeit)</u>
     '''public Auto(<u>double pTankstand</u>)'''
     <u>{</u>
     '''{'''
       <u>geschwindigkeit = pGeschwindigkeit;</u>
       '''tankstand = <u>pTankstand</u>;'''
     <u>}</u>
     '''}'''
    
    
     // Methoden
     // Methoden
   }
   }
</code>
</code>
 


Dadurch muss man bei der Erzeugung der Krabbe die Geschwindigkeit festlegen.
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.


'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:


<code>Crab neueKrabbe = new Crab(3);</code>
<code>Auto neuesAuto = '''new Auto(7.0)''';</code>


Damit hat <code>neueKrabbe</code> die Geschwindigkeit 3.
Damit hat <code>neuesAuto</code> den Tankstand 7.0


= Methoden =
= Methoden =
Zeile 154: Zeile 290:


'''Beispiel:'''
'''Beispiel:'''
Für ein Objekt der Klasse Krabbe soll die Geschwindigkeit festgelegt werden können. Außerdem soll man die Geschwindigkeit auslesen können.
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.
<code>
<code>
   public class Crab
   public class Auto
   {
   {
     // Attribute
     // Attribute
     private int geschwindigkeit;   
     private double tankstand;   
      
      
     // Konstruktor
     // Konstruktor
     public Crab()
     public Auto()
     {
     {
       turn(50);
       tankstand = 5.0;
     }
     }
      
      
     // Methoden
     // Methoden
     <u>'''public void setzeGeschwindigkeit(int neueGeschwindigkeit)'''</u>
     '''public void tanken(double pLiter)'''
     <u>{</u>
     '''{'''
       <u>geschwindigkeit = neueGeschwindigkeit;</u>
       '''tankstand = tankstand + pLiter;'''
     <u>}</u>
     '''}'''
        
        
     <u>'''public int gibGeschwindigkeit()'''</u>    
     '''public double gibTankstand()'''   
     <u>{</u>
     '''{'''
         <u>return geschwindigkeit;</u>
         '''return tankstand;'''
     <u>}</u>
     '''}'''
   }
   }
</code>
</code>
 
== Methodendeklaration / Methodenkopf ==
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.
 
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.
 
'''Erklärvideo'''


== Methodendeklaration ==
'''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)
//TODO


== Methodenaufruf ==
'''Beispiel:'''
//TODO
<code>
  public class Automat  {
    //Attribute
    private int eingeworfen;
    private int preisstufe;
 
    //Konstruktor
    public Automat()
    {
        preisstufe = 0;
        eingeworfen = 0;
    }
       
    //Methoden
   
    '''public void preisstufeWaehlen(int pPreisstufe)'''
    {
        preisstufe = pPreisstufe;
    }
 
    '''public int gibPreisstufe()'''
    {
        int ergebnis = preisstufe;
        return ergebnis;
    }
 
    '''public void geldEinwerfen(int betragInCent)'''
    {
        eingeworfen = eingeworfen + betragInCent;
    }
 
    '''private double steuern(int betrag)'''
    {
        double ergebnis = betrag * 0.19;
        return ergebnis;
    }
   
    '''public int geldZurueckGeben()'''
    {
        int ergebnis = eingeworfen;
        eingeworfen = 0;
        return ergebnis;
    }
  }
</code>


===Bedeutung des Punktes ===
Der '''Methodenkopf''' ist immer gleich aufgebaut:
//TODO
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code>
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code>
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code>


== Parameter ==
== Parameter ==
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.
* Das ist hier der Fall bei der Methode <code>setzeGeschwindigkeit</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie groß die Geschwindigkeit sein soll.
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.
* Dafür haben Methoden <u>Parameter</u>, in diesem Fall <code>neueGeschwindigkeit</code>.
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von <u>Parameter-Typ</u>.
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.
** Der Parameter-Typ von <code>neueGeschwindigkeit</code> ist <code>int</code>, also eine ganze Zahl.
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>.  
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>.  
<code>
<code>
       Crab neueKrabbe = new Crab();
       Automat derAutomat = new Automat();
       // jetzt kommt der Methodenaufruf mit Parameterübergabe!
       // jetzt kommt der Methodenaufruf mit Parameterübergabe!
       neueKrabbe.setzeGeschwindigkeit(<u>10</u>);
       derAutomat.geldEinwerfen('''50''');
</code>
</code>
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!
== Rückgabetyp einer Methode ==
Für eine Methode wird immer der Rückgabetyp festgelegt.
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code>
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.
** Beispiel: <code>public '''int''' geldZurueckGeben()</code>
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''


== sondierende Methode / verändernde Methode ==
== sondierende Methode / verändernde Methode ==
* <u>sondierende Methode</u>: Dieser Methodentyp '''gibt eine Information über das Objekt zurück'''.
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.
** Beispiel: <code>public int gibGeschwindigkeit()</code>
** Beispiel: <code>public '''int''' gibPreisstufe()</code>
* <u>verändernde Methode</u>: Dieser Methodentyp '''verändert das Objekt'''.
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.
** Beispiel: <code>public void setzeGeschwindigkeit()</code>
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code>


== Rückgabetyp einer Methode ==
== Methodenaufruf ==
Für eine Methode wird immer der Rückgabetyp festgelegt.
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.
* <u><code>void</code></u>: Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).
** Beispiel: <code>public <u>void</u> setzeGeschwindigkeit(int neueGeschwindigkeit)</code>
* <u><code>int</code></u>: Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.
** Beispiel: <code>public <u>int</u> gibGeschwindigkeit()</code>
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Crab</code>) der Rückgabe-Typ einer Methode sein.
** Beispiel: <code>public <u>Crab</u> gibKopie()</code> : Diese Methode würde eine Kopie der Krabbe (also ein Objekt der Klasse <code>Crab</code>) zurückgeben.


= lokale Variablen =
'''VORSICHT:'''
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!
* Lokale Variablen kann man (im Gegensatz zu Attributen) nicht in der ganzen Klasse benutzen.
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.


'''Beispiel:'''
'''Beispiel:'''
<code>
 
   public class Crab
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.
<code>
  public class Rechner{
    public int groessteZahl(int z1, int z2, int z3, int z4)
    {
        int groessere12 = '''gibGroessereZahl(z1, z2);'''
        int groessere34 = '''gibGroessereZahl(z3, z4);'''
        int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''
        return ergebnis;
    }
    '''public int gibGroessereZahl(int a, int b)'''
    {
      int ergebnis;
      if(a > b)
      {
          return a;
      }
      else
      {
          return b;
      }
    }
  }
</code>
 
===Methoden für Objekte anderer Klassen aufrufen ===
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.
 
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code>
 
'''Beispiel :'''
<code>
   public class Baum
   {
   {
     ...
     // Attribute der Klasse Baum
    private Kreis krone;
     public void act()
    private Quadrat stamm;
 
    // Konstruktor der Klasse Baum
     public Baum()
     {
     {
         CrabWorld <u>cw</u> = (CrabWorld)getWorld();
         stamm = new Quadrat();
         Lobster <u>lo</u> = cw.getLobster();
         '''stamm.bewegeZuPosition(110,120)''';
         int <u>xLobster</u> = lo.getX();
         '''stamm.sichtbarMachen()''';
         int <u>yLobster</u> = lo.getY();
         krone = new Kreis();
         ...
         '''krone.bewegeZuPosition(100,100)''';
         // jetzt kann man xLobster und yLobster verwenden!
         '''krone.sichtbarMachen()''';
        // z.B. um die Krabbe in Richtung (xLobster, yLobster) zu steuern.
     }
     }
  }
  }
</code>
</code>
 
'''Erklärung:'''
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:
** Attributname -> Punkt -> Methodenname.
*
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode
 
= Beziehungen zwischen Klassen =
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''
 
'''"kennt"-Beziehung:'''
 
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/>
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]
 
'''Vererbung:'''<br/>
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]
 
=NullPointerException=
Die NullPointerException ist beim Programmieren die häufigste Exception.
 
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''


<code> cw, lo, xLobster, yLobster </code> sind '''lokale Variablen'''.
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.


= Wertzuweisungen =
'''Beispiel 1:'''<br/>
* Attributen und lokalen Variablen können Werte zugewiesen werden.
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.
* Beispiel 1:
<code>
** <code>geschwindigkeit = 10;</code>
  public class SchuelerVerwaltung{
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.
    private List<Schueler> schuelerListe;
* Beispiel 2:
 
** <code>geschwindigkeit = neueGeschwindigkeit;</code>
    public SchuelerVerwaltung(){
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.
      Schueler s1 = new Schueler("Gates","Bill");  
* Beispiel 3:
      <font color='red'>'''schuelerListe'''.append(s1);</font>
** <code>geschwindigkeit = geschwindigkeit + 1;</code>
    }
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,
}
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!
</code>
'''Erklärung 1:'''<br/>
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br/>Für ein Objekt, das den Wert <code>null</code>hat, führt der Aufruf einer Methode (in diesem Fall <code>schuelerListe.'''append(s1)'''</code>) zu einer NullpointerException.


* Allgemein:
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.
<code>
** '''rechts vom Gleichzeichen''' steht der neue Wert.
    schuelerListe = new List<>();
</code>
'''Beispiel 2: Abituraufgabe'''<br/>
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:


= Verzweigungen (if, switch) =
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)
TODO
entstehen kann.''
= Schleifen (while, for, do-while) =
<code>
TODO
  public Team wasErmittleIch(Team pTeam, int pX) {
= Beziehungen zwischen Klassen =
    List<Team> auswahl = filtereTeams(pTeam, pX);
TODO
    auswahl.toFirst();
== gerichtetete Assoziation ==
    int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>;
TODO
    Team g = auswahl.getContent();
== Vererbung ==
    int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte);
TODO
    auswahl.next();
    ...
  }
</code>
'''Erklärung 2:'''<br/>
An den roten Stellen kann es zu einer NullpointerException kommen:
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.
* Wenn <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.

Aktuelle Version vom 11. September 2024, 07:09 Uhr


Allgemeines

Hier werden die grundlegenden Sprachelemente von Java im Detail erklärt.

Wer wissen möchte, wie eine ganze Klasse aussieht:

Erklärvideos

 

 

 

lokale Variable

  • lokale Variablen müssen deklariert werden.
    Das heißt: Man legt fest, welchen Typ die Variable hat.
    Häufige Typen von Variablen sind:
    • int: Für eine ganze Zahl.
    • double: Für eine Kommazahl.
    • String: Für einen Text
  • Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.
  • Lokale Variablen kann man (im Gegensatz zu Attributen) nicht in der ganzen Klasse benutzen.
  • Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.
    • U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.

Beispiel:


    public int summeZahlenBis100Ausgeben()
    {
       // Deklaration der lokalen Variable zahl; zahl wird auf 1 gesetzt.
       int zahl = 1;
       // Deklaration der lokalen Variable ergebnis; ergebnis wird auf 0 gesetzt.
       int ergebnis = 0;
       // Schleife, mit der bis 100 gezählt wird.
       while( zahl <= 100) {
          // Ergebnis wird um zahl erhöht.
          ergebnis += zahl;
          // zahl wird um 1 erhöht.
          zahl++;
       }
       // ergebnis zurückgeben
       return ergebnis;
    }

Wertzuweisungen

Attributen und lokalen Variablen können Werte zugewiesen werden.

  • Beispiel 1:
    • geschwindigkeit = 10;
    • Damit wird dem Attribut geschwindigkeit der Wert 10 zugewiesen.
  • Beispiel 2:
    • geschwindigkeit = neueGeschwindigkeit;
    • Damit wird dem Attribut geschwindigkeit der Wert neueGeschwindigkeit zugewiesen.
  • Beispiel 3:
    • geschwindigkeit = geschwindigkeit + 1;
    • Damit wird dem Attribut geschwindigkeit der Wert geschwindigkeit+1 zugewiesen,
    • d.h. die Geschwindigkeit wird um 1 erhöht!
  • Allgemein:
    • links vom Gleichzeichen steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.
    • rechts vom Gleichzeichen steht der neue Wert.


Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem += und ++.

  • Beispiel 4:
    • geschwindigkeit += 5;
    • += bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.
  • Beispiel 5:
    • geschwindigkeit++;
    • ++ bedeutet: erhöhe um eins.

Bedingungen (if-else)

Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.

Es passiert folgendes: Wenn (if) a größer als b ist, dann wird ergebnis auf a gesetzt, sonst (else) auf b.


 public int bestimmeDieGroessere(int a, int b)
 {
    int ergebnis;
    if(a > b)
    {
       ergebnis = a;
    }
    else
    {
       ergebnis = b;
    }
    return ergebnis;
 }

VORSICHT: Gleichheit überprüft man mit doppeltem Gleichzeichen:


  // Wenn x gleich drei ist, ...
  if(x == 3)
  {
     ...
  }

Schleifen (while, for, do-while)

Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.

for-Schleife

Die for-Schleife ist eine Zählschleife. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine Zählvariable, die häufig i heißt, aber jeder andere Name ist auch denkbar.

Beispiel:

Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.


 for(int i=0; i<=333; i++)
 {
    System.out.println(3*i);
 }

Erläuterung:

  • Die Klammer nach dem for hat drei Teile:
    • Deklaration und Initialisierung der Zählvariable i: i startet bei 0.
    • Schleifenbedingung: Die Schleife wird so lange wiederholt, wie i <= 333 ist.
    • Veränderung bei jedem Schleifendurchlauf: i wird bei jedem Schleifendurchlauf um eins erhöht. (i++ bedeutet dasselbe wie i = i+1). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.
    • Im Schleifenrumpf wird mit System.out.println(i); jeweils das Dreifache von i an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.

while-Schleife

Die while-Schleife ist eine bedingteSchleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die Schleifenbedingung, erfüllt ist.

Erklärvideo
Erklärvideo zu while-Schleifen (11:49min)
(anhand eines Greenfoot-Szenarios)

Beispiel:
Die folgende while-Schleife beginnt bei zahl = 1.
zahl wird dann so lange an die Konsole ausgegeben und verdoppelt,
wie zahl kleiner als 1000 ist.
D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.

 int zahl = 1;
 while(zahl < 1000)
 {
    System.out.println(zahl);
    // zahl verdoppeln
    zahl = zahl * 2;
 }

Erläuterung:

  • Die Klammer nach dem while enthält die Bedingung:
    Wiederhole, solange zahl kleiner 1000 ist.
  • Im Schleifenrumpf wird dann zahl an die Konsole ausgegeben
    und dann mit zahl = zahl * 2; verdoppelt.


Klasse, Objekt, Klassendefinition

Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.

Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: Klasse in Java

  • Von einer Klasse können viele Objekte erzeugt werden.
  • Beispiel: Es gibt eine Klasse Baum, von der man viele einzelne Objekte erzeugen kann.
  • Java: Definiton einer Klasse:
 
 public class Baum
 {
    // Attribute
         
    // Konstruktor
         
    // Methoden
 }

Attribute

  • Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.
  • Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den Attribut-Wert haben.
    • Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.
  • Attribute haben einen Attribut-Typ. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa int für ganze Zahlen oder double für Kommazahlen. Für Namen eignet sich String.
    Detaillierte Infos zu den Java-Datentypen finden sich hier: Java_Basis-Datentypen
  • Java:
    • Attribute werden direkt nach der Klassen-Deklaration notiert.
    • Attribute sind in der Regel private, d.h. sie können nicht ohne Weiteres von Außen verändert werden.

Beispiel 1:

Objekte der Klasse Auto können unterschiedlichen Tankstand haben.

Dafür gibt es das Attribut tankstand. Dieses hat den Datentyp double, weil es eine Kommazahl sein kann.


public class Auto
{
  // Attribute
  private double tankstand;
         
  // Konstruktor
   
  // Methoden
}


Beispiel 2:

Objekte der Klasse Baum bestehen aus einem Quadrat (für den Stamm) und einem Kreis (für die Krone).
Die Klassen Quadrat und Kreis müssen natürlich schon im Projekt enthalten sein!!


 public class Baum
 {
   // Attribute
   private Quadrat stamm;
   private Kreis krone;
        
   // Konstruktor
      
   // Methoden
 }

Konstruktor

Aufruf des Konstruktors:

  • Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:
  • Java: Auto neuesAuto = new Auto();


Deklaration des Konstruktors:

  • In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.
  • Der Konstruktor heißt genauso wie die Klasse.
  • Der Konstruktor hat keinen Rückgabetyp, also auch kein void.

Beispiel:


 public class Auto
 {
   // Attribute
   private int tankstand;   
    
   // Konstruktor
   public Auto()
   {
     tankstand = 5.0;
   }
  
   // Methoden
 }


Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.

Konstruktor mit Parameter

Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.

Beispiel:


 public class Auto
 {
   // Attribute
   private double tankstand;   
    
   // Konstruktor
   public Auto(double pTankstand)
   {
     tankstand = pTankstand;
   }
  
   // Methoden
 }


Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.

Aufgerufen wird dieser Konstruktor dann z.B. so:

Auto neuesAuto = new Auto(7.0);

Damit hat neuesAuto den Tankstand 7.0

Methoden

In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.

Beispiel: Für ein Objekt der Klasse Auto soll es die Methode tanken geben. Außerdem soll man den Tankstand mit der Methode gibTankstand() auslesen können.


 public class Auto
 {
   // Attribute
   private double tankstand;   
    
   // Konstruktor
   public Auto()
   {
     tankstand = 5.0;
   }
    
   // Methoden
   public void tanken(double pLiter)
   {
      tankstand = tankstand + pLiter;
   }
     
   public double gibTankstand()   
   {
       return tankstand;
   }
 }

Methodendeklaration / Methodenkopf

Methoden werden durch den Methodenkopf (auch: die Methodensignatur) deklariert.

D.h. für Objekte der Klasse kann man dann die Methode aufrufen.

Erklärvideo

Erklärvideo zu Methodensignaturen (11:42min).
(Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)

Beispiel:


 public class Automat  {
    //Attribute
    private int eingeworfen;
    private int preisstufe;
 
    //Konstruktor
    public Automat()
    {
       preisstufe = 0;
       eingeworfen = 0;
    }
       
    //Methoden
   
    public void preisstufeWaehlen(int pPreisstufe)
    {
       preisstufe = pPreisstufe;
    }
 
    public int gibPreisstufe()
    {
       int ergebnis = preisstufe;
       return ergebnis;
    }
 
    public void geldEinwerfen(int betragInCent)
    {
       eingeworfen = eingeworfen + betragInCent;
    }
 
    private double steuern(int betrag)
    {
       double ergebnis = betrag * 0.19;
       return ergebnis;
    }
   
    public int geldZurueckGeben()
    {
       int ergebnis = eingeworfen;
       eingeworfen = 0;
       return ergebnis;
    }
 }

Der Methodenkopf ist immer gleich aufgebaut:

  1. Zugriffsmodifikator: public oder private.
    1. Auf public-Methoden darf man auch von außen zugreifen; sie sind öffentlich.
    2. Auf private-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.
  2. Rückgabetyp: void für nichts bzw. ein Datentyp (wie z.B. int) oder auch eine Klasse.
    1. Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.
    2. Die Methode public void geldEinwerfen(int betragInCent) gibt nichts zurück. void ist das Schlüsselwort für nichts.
    3. Die Methode public int summe(int a, int b) gibt int zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein return-Statement, z.B.: return ergebnis;
  3. Methodenname: Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen klein zu schreiben.
  4. Parameter: In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).
    1. Bei den Parametern wird erst der Parameter-Typ (z.B. int) und dann der Parameter-Name angegeben.
    2. Mehrere Parameter werden durch Komma getrennt, z.B. public int summe(int a, int b)
    3. Methoden ohne Parameter haben leere Klammern, z.B.: public int geldZurueckGeben()

Parameter

  • Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.
  • Das ist hier der Fall bei der Methode geldEinwerfen: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.
  • Dafür haben Methoden Parameter, in diesem Fall betragInCent.
  • Bei Parametern muss immer der Typ festgelegt werden; man spricht von Parameter-Typ.
    • Der Parameter-Typ von betragInCent ist int, also eine ganze Zahl.
    • Detaillierte Infos zu den Java-Datentypen finden sich hier: Java_Basis-Datentypen
  • Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den Parameter übergeben.

     Automat derAutomat = new Automat();
     // jetzt kommt der Methodenaufruf mit Parameterübergabe!
     derAutomat.geldEinwerfen(50);

  • Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur (). Das ist wichtig, um sie von Attribute zu unterscheiden!

Rückgabetyp einer Methode

Für eine Methode wird immer der Rückgabetyp festgelegt.

  • void: Wenn die Methode nichts zurückgibt (bei einer verändernden Methode).
    • Beispiel: public void geldEinwerfen(int betragInCent)
  • int: Wenn die Methode eine ganze Zahl (int) zurückgibt.
    • Beispiel: public int geldZurueckGeben()
  • Statt int kann auch jeder andere Typ oder auch eine Klasse (z.B. Automat) der Rückgabe-Typ einer Methode sein.
    • Beispiel: public Automat gibKopie() : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse Automat) zurückgeben.

Detaillierte Infos zu den Java-Datentypen finden sich hier: Java_Basis-Datentypen

sondierende Methode / verändernde Methode

  • sondierende Methode (=get-Methode): Dieser Methodentyp gibt eine Information über das Objekt zurück. Diese Methode braucht einen Rückgabetyp (d.h. nicht void) und ein return-Statement.
    • Beispiel: public int gibPreisstufe()
  • verändernde Methode (=set-Methode): Dieser Methodentyp verändert das Objekt. Häufig hat dieser Methodentyp einen (oder mehrere) Parameter. Sie hat zumeist den Rückgabetyp void, denn sie gibt in der Regel nichts zurück.
    • Beispiel: public void preisstufeWaehlen(int pPreisstufe)

Methodenaufruf

Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.

VORSICHT: Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!

Beispiel:

Im Beispiel ruft die Methode groessteZahl dreimal die Methode gibGroessereZahl auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. groessere12 gespeichert, um damit weiter zu rechnen.


 public class Rechner{
   public int groessteZahl(int z1, int z2, int z3, int z4)
   {
       int groessere12 = gibGroessereZahl(z1, z2);
       int groessere34 = gibGroessereZahl(z3, z4);
       int ergebnis = gibGroessereZahl(groessere12, groessere34);
       return ergebnis;
   }

   public int gibGroessereZahl(int a, int b)
   {
      int ergebnis;
      if(a > b)
      {
         return a;
      }
      else
      {
         return b;
      }
   }
 }

Methoden für Objekte anderer Klassen aufrufen

Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe delegiert.

WICHTIG: Das wesentliche Syntax-Element ist der Punkt!
Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).
Z.B. stamm.bewegeZuPosition(110,120);

Beispiel :


 public class Baum
 {
    // Attribute der Klasse Baum
    private Kreis krone;
    private Quadrat stamm;
 
    // Konstruktor der Klasse Baum
    public Baum()
    {
       stamm = new Quadrat();
       stamm.bewegeZuPosition(110,120);
       stamm.sichtbarMachen();
       krone = new Kreis();
       krone.bewegeZuPosition(100,100);
       krone.sichtbarMachen();
    }
 }

Erklärung:

  • stamm ist ein Objekt vom Typ Quadrat; deshalb verfügt stamm über die Methode sichtbarMachen().
  • Im Konstruktor von Baum wird diese Methode mithilfe des Punktes aufgerufen:
    • Attributname -> Punkt -> Methodenname.

Ein Objekt der Klasse Haus ruft in einem Objekt der Klasse Quadrat die Methode

Beziehungen zwischen Klassen

Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.

"kennt"-Beziehung:

Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:
Szenario Roller (Quelltext)

Vererbung:
Szenario Buch - Fachbuch - Hörbuch

NullPointerException

Die NullPointerException ist beim Programmieren die häufigste Exception.

Die NullpointerException wird auch im Abitur abgefragt!!!

Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.

Beispiel 1:
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.

 public class SchuelerVerwaltung{
   private List<Schueler> schuelerListe;
 
   public SchuelerVerwaltung(){
     Schueler s1 = new Schueler("Gates","Bill"); 
     schuelerListe.append(s1);
   }
}

Erklärung 1:
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut schuelerListe noch gar nicht erzeugt wurde - es ist null.
Für ein Objekt, das den Wert nullhat, führt der Aufruf einer Methode (in diesem Fall schuelerListe.append(s1)) zu einer NullpointerException.

Man kann die NullPointerException vermeiden, indem man vor der roten Zeile einfügt:

   schuelerListe = new List<>();

Beispiel 2: Abituraufgabe
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:

Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException) entstehen kann.

 public Team wasErmittleIch(Team pTeam, int pX) {
   List<Team> auswahl = filtereTeams(pTeam, pX);
   auswahl.toFirst();
   int punkte = pTeam.berechnePunkte();
   Team g = auswahl.getContent();
   int d = Math.abs(g.berechnePunkte() - punkte);
   auswahl.next();
   ...
 }

Erklärung 2:
An den roten Stellen kann es zu einer NullpointerException kommen:

  • Wenn pTeam den Wert null hat, kann man für pTeam nicht die Methode berechnePunkte() aufrufen.
  • Wenn auswahl eine leere Liste ist: dann hat die lokale Variable g den Wert null, und man kann für g dann nicht die Methode berechnePunkte() aufrufen.