Java Basis-Sprachelemente

Allgemeines

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

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

• Klasse

Erklärvideos

• Java-Crashkurs Teil 1 (28min)
  In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.
  Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.
  • Programmiervorlage für den Taschenrechner
  • jdoodle online compiler
    
  • Cheat sheet für Teil 1 (PDF) zum Ausdrucken.

 

• Taschenrechner Fehlersuche zum Ausdrucken (PDF)
  • Java-Quelltext für die Fehlersuche
    Den Quelltext kann man in jdoodle packen und dann die Fehlermeldungen durchklicken!

 

• Java-Crashkurs Teil 2 (40min)
  In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.
  • Programmiervorlage für den Taschenrechner (mit allem für Teil 2)
  • jdoodle online compiler
    
  • Cheat sheet für Teil 2 (PDF) zum Ausdrucken.

 

• Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)
  (anhand eines Greenfoot-Szenarios)
  Arbeitsblatt zum Video (PDF).
  Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.
   

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.