Methoden

Klassendefinitionen in
Java
ein kleines Beispiel
Die Klasse Jabberwocky
Das ist ein
Jabberwocky
Das ist ein
Frühstück
Die Klasse Jabberwocky
Klasse Jabberwocky
+ zaehne : int
+ hungrig : boolean
+ laune : int
+ farbe : int
Der Name der Klasse
}
Die Variablen
der Klasse
<< Konstruktor >>
+ Jabberwocky(Color f, int z )
<< Methoden >>
+ bauernfressen ( int x )
+ zahnverlieren ( )
+ launewechseln ( int y )
Der Konstruktor der Klasse
}
Der Methoden
der Klasse
Die Klasse Jabberwocky
Klasse Jabberwocky
Im Javaprogramm:
+ zaehne : int
+ hungrig : boolean
+ laune : int
+ farbe : int
Jabberwocky Karl, Erwin; // zwei Drachen !!
.....
Karl = new Jabberwocky(Color.yellow,12);
<< Konstruktor >>
+Jabberwocky(Color f, int z)
...
<< Methoden >>
+ bauernfressen ( int x )
+ zahnverlieren ( )
Erwin = new Jabberwocky(Color.green,23);
+ launewechseln ( int y )
Nun existiert Karl - er ist gelb und hat 12 Zähne
und es existiert Erwin - er ist grün und hat 23 Zähne
Die Klasse Jabberwocky
Die Klassendefiniton in Java:
Klasse Jabberwocky
+ zaehne : int
+ hungrig : boolean
+ laune : int
class Jabberwocky
{
int
zaehne;
boolean hungrig;
int
laune;
// je größer die Zahl, desto besser die Laune
Color
farbe;
+ farbe : int
<< Konstruktor >>
//********************** Konstruktor *********
+ Jabberwocky(Color f, int z ) public Jabberwocky (Color f, int z)
{
<< Methoden >>
farbe=f;
// Farbe, die bei new Jabberwocky angegeben
+ bauernfressen ( int x )
war
+ zahnverlieren ( )
zaehne=z; // hole die Zahnzahl
}
+ launewechseln ( int y )
//********************** Methoden *********
public void bauernfressen ( int x )
{
laune = laune + x;
// mit jedem Bauern wird die Laune besser
}
...................
// und so weiter ....
Die Klasse Jabberwocky
Und weiter im Javaprogramm....
......
// nun steht Erwin vor einigen Bauern ... was wird er tun ?
if ( Erwin.laune <2 )
{
Erwin.hungrig = true;
Erwin.bauernfressen(3); // womit Erwins Laune um 3 Punkte steigt
Erwin.hungrig=false;
// kein Hunger mehr
}
.........
// oder die beiden Drachen treffen sich:
if (( Erwin.laune <2 ) && (Karl.laune > 5))
{
Erwin.farbe=Color.white;
// er wird vor Neid ganz blass...
Karl.zaehne=Karl.zaehne - 5; // haut ihm 5 Zähne weg....
Karl.laune=Karl.laune-12;
//... das macht echt miese Stimmung
}
UML Unified Modeling Language
Auto
Moped
Mofa
+ raeder : int
+ raeder : int
+ raeder : int
+ leistung : int
+ leistung : int
+ leistung : int
+ farbe : Color
+ farbe : Color
+ farbe : Color
- tachostand : int
+ hubraum : int
<< Konstruktor >>
<< Konstruktor >>
<< Konstruktor >>
+ Auto (int r,int l, Color f )
+ Moped (int r, int l ,Color f )
<< Methoden >>
<< Methoden >>
+ starten ( )
+ starten ( )
+ bremsen ( )
+ bremsen ( )
+ ueberholen ( Moped m )
+ ueberholen ( Mofa m )
+ Mofa (int r, int l, Color f )
<< Methoden >>
+ starten ( )
+ bremsen ( )
meinMofa = new Mofa (2,5,Color.blue);
ein neues Mofa mit 2 Rädern, 5
PS und schön blau
einAuto = new Auto (4,110,Color.red);
meinMoped = new Moped (2,25,Color.green);
ein neues Auto mit 4 Rädern, ein neues Moped mit 2 Rädern,
110 PS und schön rot
25 PS und schön grün
Was würde wohl : meinAuto.ueberholen(deinMoped) sein ?
UML Oberklassen und Vererbung
KFZ
+ raeder : int
Die Klassen
Auto, Moped und Mofa sind
von KFZ “abgeleitet”.
Es sind Unterklassen, die
alle Attribute und Methoden
der Oberklasse erben.
Die Oberklasse
+ leistung : int
+ farbe : Color
<< Konstruktor >>
+ KFZ (int r, int l, Color f )
<< Methoden >>
+ starten ( )
+ bremsen ( )
Vererbungspfeile
Auto
- tachostand : int
<< Konstruktor >>
+ Auto (int r, int l, Color f )
<< Methoden >>
+ ueberholen ( Moped m )
Moped
+ hubraum : int
<< Konstruktor >>
+ Moped (int r, int l, Color f )
<< Methoden >>
+ ueberholen ( Mofa m )
Mofa
<< Konstruktor >>
+ Mofa (int r, int l, Color f )
<< Methoden >>
Nur Attribute und Methoden, die speziell hier gebraucht werden, werden auch hier
definiert.
UML Oberklassen und Vererbung
Bei der Definition der Unterklasse wird nun deutlich
gemacht, dass geerbt wird:
public class Moped extends KFZ
{
.......hier alle Attribute und Methoden, die nicht in der Oberklasse enthalten sind
}
Die Unterklassen ( Subklassen ) sollten / können einen eigenen Konstruktor
haben.
Mit dem Befehlswort “super” kann aber der Konstruktor der Oberklasse
aufgerufen werden.
z.B.
public Moped (int x, int y, Color f)
{ super(x,y,f );
}
// Konstruktor der Klasse Moped
ruft des Konstruktor von KFZ auf und erzeugt dennoch ein neues Moped, wenn
meinMoped = new Moped(2,5,Color.blue);
UML Oberklassen und Vererbung
Oberklasse
Schulklasse
Attribute
Attribute
Methoden
Methoden
Klasse 1
Klasse 2
Attribute
Attribute
Methoden
Methoden
1..30
Schüler
Attribute
In einigen Lehrbüchern findet man
eine andere Pfeildarstellung für die
Vererbung
Methoden
Ist eine Klasse vollständig in einer
andern Klasse enthalten, wird der
Pfeil durch eine Raute ersetzt.
UML Oberklassen und Vererbung
Schulklasse
Attribute
1
Tafel
1
Methoden
Raum
Attribute
Attribute
Methoden
Methoden
1..30
Schüler
Attribute
Methoden
Die Oberklasse enthalt noch weitere
Unterklassen vollständig