1 Klassen anlegen und Objekte erzeugen

Werkzeugkiste Java
1
1
Klassen anlegen und Objekte erzeugen
Klassengrundgerüst
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Klassenkommentar
/* *
* Write a description of class Testklasse here .
*
* @author ( your name )
* @version ( a version number or a date )
*/
public class Testklasse
{
// instance variables - replace the example below with your own
private int x ;
Klassendefinition
/* *
* Constructor for objects of class Testklasse
*/
public Testklasse ()
{
// initialise instance variables
x = 0;
}
Deklaration der
Instanzvariablen
Konstruktor
/* *
* An example of a method - replace this comment with your own
*
* @param y
a sample parameter for a method
* @return
the sum of x and y
*/
public int sampleMethod ( int y )
{
// put your code here
return x + y ;
}
Methodenkommentar
Methodendefinition
}
Klassendeklaration
• einfach
public class NameDerKlasse
{
// Deklaration der Instanzvariablen
private Datentyp1 attribut1 ;
private Datentyp2 attribut2 ;
// Konstruktoren
// Methodendefinitionen
}
• als Unterklasse einer Oberklasse
public class NameDerKlasse extends Oberklasse
{
// Deklaration der zusaetzlichen Instanzvariablen
private Datentyp1 neuesAttribut1 ;
private Datentyp2 neuesAttribut2 ;
// Konstruktoren
// Methodendefinitionen
}
Werkzeugkiste Java
2
Konstruktor
• Eine Klasse kann auch mehrere Konstruktoren unterschiedlicher Signatur besitzen.
• einfach
public NameDerKlasse ()
{
// Initialisierung der Instanzvariablen
attribut1 = einStandardwert1 ;
attribut2 = einStandardwert2 ;
}
• mit Parameter
public NameDerKlasse ( Datentyp1 einStartwert1 , Datentyp2 einStartwert2 )
{
// Initialisierung der Instanzvariablen
// mit den angegebenen Startwerten
attribut1 = einStartwert1 ;
attribut2 = einStartwert2 ;
}
• bei einer Unterklasse einer Oberklasse
public NameDerKlasse ( Datentyp1 einStartwertVererbt , Datentyp2 einStartwertNeu )
{
// Konstruktoraufruf der Oberklasse
super ( einStartwertVererbt );
// Initialisierung der zusaetzlichen Instanzvariablen
neuesAttribut1 = einStartwertNeu ;
neuesAttribut2 = einStandardwert ;
}
Objekterzeugung
einObjekt = new NameDerKlasse ();
einObjekt = new NameDerKlasse ( einStartwert1 , einStartwert2 );
2
Accessoren – Zugriff auf Instanzvariablen
Get-Methode mit Rückgabeoperator return
public Datentyp gibAttribut1 ()
{
return attribut1 ;
}
Set-Methode mit Wertzuweisung =
public void setzeAttribut1 ( Datentyp einWert )
{
attribut1 = einWert ;
}
Werkzeugkiste Java
3
3
Methoden und Nachrichten
Methodengrundgerüst
• ohne Ergebnisrückgabe
public void methodenname ( Datentyp1 einWert1 , Datentyp2 einWert2 )
{
// Methodenkommentar
// Deklaration von Hilfsvariablen ohne Sichtbarkeit
Datentyp hilfsvariable ;
anweisungen ;
}
• mit Ergebnisrückgabe
public Ergebnistyp methodenname ( Datentyp1 einWert1 , Datentyp2 einWert2 )
{
// Methodenkommentar
// Deklaration von Hilfsvariablen ohne Sichtbarkeit
Datentyp hilfsvariable ;
anweisungen ;
// Ergebnisrueckgabe
return ergebnis ;
}
Nachrichten (Methodenaufrufe)
// ohne Parameter
einObjektname . tuEtwas ();
// mit Angabe von Parametern
einObjektname . tuEtwasMit ( einWert );
einObjektname . tuEtwasMit ( einWert , einWeitererWert );
4
Operatoren
Logik (Wahrheitswerte)
&& und
||
oder
!
nicht
Rechenoperationen
+ Addition
− Subtraktion
∗
Multiplikation
/
Division
% Divisionsrest (modulo)
5
Textoperationen
+ Konkatenierung (Aneinanderhängen)
Vergleiche (liefern true oder false)
== gleicher Wert
! = ungleicher Wert
< kleiner als
<= kleiner oder gleich
> größer als
>= größer oder gleich
Datentypen
int (ganze Zahl) 347
double (Gleitkommazahl) 3.14, 2.7e12
boolean (Wahrheitswert) true, false, !true, !false (logische Negation)
char (Schriftzeichen) ’M’, ’a’, ’ ’
String (Zeichenkette) "eine Zeichenkette"
Werkzeugkiste Java
4
Typumwandlung
in eine Zeichenkette: "" + einWert (Konkatenierung mit der leeren Zeichenkette)
in eine Gleitkommazahl: (double)einWert
Array (Feld)
DATENTYP ist z.B. int, String oder Name einer Klasse und legt fest, von welcher
Art die Einträge des Feldes sein dürfen.
// Deklaration
private DATENTYP [] einFeld ;
// Initialisierung eines Feldes mit 20 Eintraegen
einFeld = new DATENTYP [20];
einFeld . length // Laenge des Feldes
einFeld [ i ] // Eintrag an der Stelle i ( Index )
einFeld [0] // erster Eintrag
einFeld [ einFeld . length - 1] // letzter Eintrag
6
Einbinden externer Module
import-Anweisung gleich zu Beginn des gesamten Java-Quelltextes
import java . paket . Klasse ;
Listen ArrayList<DATENTYP>
DATENTYP ist z.B. int, String oder Name einer Klasse und legt fest, von welcher
Art die Elemente der Liste sein dürfen.
import java . util . ArrayList ;
// Deklaration
private ArrayList < DATENTYP > eineListe ;
// Initialisierung der Liste
eineListe = new ArrayList < DATENTYP >;
eineListe . size (); // Laenge der Liste
eineListe . add ( einElement );
eineListe . get ( einIndex ); // Element an der Stelle einIndex
eineListe . set ( einIndex , einNeuesElement ); // ersetze Element an einIndex
eineListe . indexOf ( einElement ); // Index des Elementes
7
Schlüsselwörter
this das aktuelle Objekt selbst
super verweist auf die Oberklasse
null nichts, leerer Wert
void Nichtstyp zur Kennzeichnung von Methoden ohne Rückgabewert
8
Sichtbarkeit von Attributen und Methoden
private nur für Objekte der Klasse selbst
protected nur für Objekte dieser Klasse und ihrer Unterklassen
public für Objekte aller Klassen
Werkzeugkiste Java
9
5
Kontrollstrukturen
Sequenz
einObjekt . tuEtwas ();
einObjekt . tuEtwasAnderes ();
Befehlsblock eine Folge von Nachrichten, eingeschlossen durch geschweifte Klammern
einseitige Verzweigung
if ( eineBedingung )
{ einObjekt tuEtwas (); };
Existenztest
if ( einObjekt != null ) { einAnderesObjekt . tuEtwas (); };
zweiseitige Verzweigung
if ( eineBedingung )
{ einObjekt . tuEtwas (); }
else
{ einAnderesObjekt . tuEtwas (); };
Mehrfachverzweigung
if ( eineBedingung )
{ einObjekt . tuEtwas (); }
else if ( eineWeitereBedingung )
{ einObjekt . tuEtwasAnderes (); }
else
{ einAnderesObjekt . tuEtwas (); };
Zählschleife
for ( Initialisierung , Abbruchbedingung , Schritt )
{ zu wiederholende Anweisungen ; };
// Schleifenvarable i mit Angabe des Datentyps initialisieren
for ( int i =0 , i <=15 , i = i +3)
{ einObjekt . tuEtwas ();
einObjekt . tuEtwasMit ( i );
};
Listendurchlauf
for ( Datentyp jedesElement : eineListe )
{ jedesElement . tuEtwas ();
einObjekt . tuEtwasMit ( jedesElement );
};
Bedingte Wiederholung
while ( eineBedingung )
{ einObjekt . aendere ( eineBedingung ); };
Werkzeugkiste Java
10
6
Threads und Verzögerungen
Threads eine Befehlsfolge im Hintergrund ausführen
für einen Einführungskurs zu kompliziert
Wartezeiten eine Befehlsfolge für ein paar Millisekunden unterbrechen
try {
Thread . sleep (5000); // 5000 Millisekunden
} catch ( InterruptedException ex ) {
ex . printStackTrace ();
}
11
Ein- und Ausgabe
Textausgabe
System . out . println ( " eine Zeichenkette in einer neuen Zeile " );
System . out . print ( " eine Zeichenkette in derselben Zeile " );
Texteingabe vgl. http://wiki.zum.de/Java/Texteingabe
// Zu Beginn des Programmes Bibliothek f r Ein / Ausgabestroeme einbinden
import java . io .*;
// ...
// Eingabestrom erzeugen
BufferedReader br = new BufferedReader ( new InputStreamReader ( System . in ));
// leere Zeichenkette fuer das Ergebnis der Eingabe erzeugen
String antwort = null ;
System . out . println ( " Gib eine Antwort ein : " );
// Einlesen mit Fehlerbehandlung
try
{
antwort = br . readLine (); // Einlesen in die Zeichenkette
}
catch ( IOException ausnahme )
{
ausnahme . printStackTrace ();
}
Schlager