Java Basis-Sprachelemente: Unterschied zwischen den Versionen
(102 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
[[Kategorie:Informatik]] | [[Kategorie:Informatik]] | ||
[[Kategorie:Informatik-Abitur]] | [[Kategorie:Informatik-Abitur]] | ||
[[Kategorie:Informatik-EF]] | |||
[[Kategorie:Informatik-Q1]] | |||
=Allgemeines= | |||
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt. | |||
''' | Wer wissen möchte, wie eine '''ganze Klasse''' aussieht: | ||
* [[Klasse]] | |||
==Erklärvideos== | |||
* | * '''[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. | ||
* | ** '''[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. | ||
* | | ||
* Wertzuweisungen | * '''[[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! | ||
| |||
* '''[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. | |||
| |||
* '''[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/> | |||
=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. | |||
'''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. | |||
= 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 <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann. | |||
* Java: Definiton einer Klasse: | |||
<code> | |||
'''public class Baum''' | |||
{ | |||
// Attribute | |||
// Konstruktor | |||
// Methoden | |||
} | |||
</code> | |||
= 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 <u>Attribut-Wert</u> haben. | |||
** 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 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: | |||
** Attribute werden direkt nach der Klassen-Deklaration notiert. | |||
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden. | |||
'''Beispiel 1:''' | |||
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben. | |||
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann. | |||
<code> | |||
public class Auto | |||
{ | |||
// Attribute | |||
'''private double tankstand;''' | |||
// Konstruktor | |||
// Methoden | |||
} | |||
</code> | |||
'''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!!'' | |||
<code> | |||
public class Baum | |||
{ | |||
// Attribute | |||
'''private Quadrat stamm;''' | |||
'''private Kreis krone;''' | |||
// Konstruktor | |||
// Methoden | |||
} | |||
</code> | |||
= Konstruktor = | |||
'''Aufruf des Konstruktors:''' | |||
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.: | |||
* Java: <code>Auto neuesAuto = '''new Auto()''';</code> | |||
'''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 <code>void</code>. | |||
Beispiel: | |||
<code> | |||
public class Auto | |||
{ | |||
// Attribute | |||
private int tankstand; | |||
// Konstruktor | |||
'''public Auto()''' | |||
'''{''' | |||
'''tankstand = 5.0;''' | |||
'''}''' | |||
// Methoden | |||
} | |||
</code> | |||
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: | |||
<code> | |||
public class Auto | |||
{ | |||
// Attribute | |||
private double tankstand; | |||
// Konstruktor | |||
'''public Auto(<u>double pTankstand</u>)''' | |||
'''{''' | |||
'''tankstand = <u>pTankstand</u>;''' | |||
'''}''' | |||
// Methoden | |||
} | |||
</code> | |||
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen. | |||
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so: | |||
<code>Auto neuesAuto = '''new Auto(7.0)''';</code> | |||
Damit hat <code>neuesAuto</code> 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 <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können. | |||
<code> | |||
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;''' | |||
'''}''' | |||
} | |||
</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''' | |||
'''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.) | |||
'''Beispiel:''' | |||
<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> | |||
Der '''Methodenkopf''' ist immer gleich aufgebaut: | |||
# '''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 == | |||
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können. | |||
* 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 '''Parameter''', in diesem Fall <code>betragInCent</code>. | |||
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''. | |||
** 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>. | |||
<code> | |||
Automat derAutomat = new Automat(); | |||
// jetzt kommt der Methodenaufruf mit Parameterübergabe! | |||
derAutomat.geldEinwerfen('''50'''); | |||
</code> | |||
* 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 (=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''' gibPreisstufe()</code> | |||
* '''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 preisstufeWaehlen('''int pPreisstufe''')</code> | |||
== 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 <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; | |||
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()'''; | |||
} | |||
} | |||
</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!!!''' | |||
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde. | |||
'''Beispiel 1:'''<br/> | |||
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt. | |||
<code> | |||
public class SchuelerVerwaltung{ | |||
private List<Schueler> schuelerListe; | |||
public SchuelerVerwaltung(){ | |||
Schueler s1 = new Schueler("Gates","Bill"); | |||
<font color='red'>'''schuelerListe'''.append(s1);</font> | |||
} | |||
} | |||
</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. | |||
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt: | |||
<code> | |||
schuelerListe = new List<>(); | |||
</code> | |||
'''Beispiel 2: Abituraufgabe'''<br/> | |||
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.'' | |||
<code> | |||
public Team wasErmittleIch(Team pTeam, int pX) { | |||
List<Team> auswahl = filtereTeams(pTeam, pX); | |||
auswahl.toFirst(); | |||
int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>; | |||
Team g = auswahl.getContent(); | |||
int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte); | |||
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
- 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.
- Taschenrechner Fehlersuche zum Ausdrucken (PDF)
- Java-Quelltext für die Fehlersuche
Den Quelltext kann man in jdoodle packen und dann die Fehlermeldungen durchklicken!
- Java-Quelltext für die Fehlersuche
- Java-Crashkurs Teil 2 (40min)
In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.
- 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 WertneueGeschwindigkeit
zugewiesen.
- Beispiel 3:
geschwindigkeit = geschwindigkeit + 1;
- Damit wird dem Attribut
geschwindigkeit
der Wertgeschwindigkeit+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 wiei = 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 voni
an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.
- Deklaration und Initialisierung der Zählvariable
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 mitzahl = 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 oderdouble
für Kommazahlen. Für Namen eignet sichString
.
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:
- Zugriffsmodifikator:
public
oderprivate
.- Auf
public
-Methoden darf man auch von außen zugreifen; sie sind öffentlich. - 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.
- Auf
- Rückgabetyp:
void
für nichts bzw. ein Datentyp (wie z.B.int
) 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
public void geldEinwerfen(int betragInCent)
gibt nichts zurück.void
ist das Schlüsselwort für nichts. - Die Methode
public int summe(int a, int b)
gibtint
zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein return-Statement, z.B.:return ergebnis;
- 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.
int
) und dann der Parameter-Name angegeben. - Mehrere Parameter werden durch Komma getrennt, z.B.
public int summe(int a, int b)
- Methoden ohne Parameter haben leere Klammern, z.B.:
public int geldZurueckGeben()
- Bei den Parametern wird erst der Parameter-Typ (z.B.
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
istint
, also eine ganze Zahl. - Detaillierte Infos zu den Java-Datentypen finden sich hier: Java_Basis-Datentypen
- Der Parameter-Typ von
- 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)
- Beispiel:
int
: Wenn die Methode eine ganze Zahl (int
) zurückgibt.- Beispiel:
public int geldZurueckGeben()
- Beispiel:
- 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 KlasseAutomat
) zurückgeben.
- Beispiel:
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()
- Beispiel:
- 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)
- Beispiel:
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 TypQuadrat
; deshalb verfügtstamm
über die MethodesichtbarMachen()
.- 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 null
hat, 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 Wertnull
hat, kann man fürpTeam
nicht die MethodeberechnePunkte()
aufrufen. - Wenn
auswahl
eine leere Liste ist: dann hat die lokale Variableg
den Wertnull
, und man kann fürg
dann nicht die MethodeberechnePunkte()
aufrufen.