Anweisungen - megloff.ch

Java
Programmierung mit
Eine Einführung in Java
> Anweisungen
Mark Egloff 2006
1
Java
Programmierung mit
Lernziel Heute Abend
>
Sie verstehen die Bedeutung des Begriffes „Anweisung“.
>
Sie kennen die verschiedenen Arten der Anweisungen in
Java und können diese auch unterscheiden
Mark Egloff 2006
2
Java
Programmierung mit
Anweisungen in Java
> Was ist eine Anweisung ?
>
Eine Anweisung (engl. statement) ist in einer Programmiersprache verfasste Arbeitsvorschrift.
>
In der Maschinensprache z.B. Assembler kann die
Bezeichnung Anweisung direkt als Synonym für Befehl
gesehen werden, jedoch in höheren Programmiersprachen
nicht, da eine Anweisung aus Befehlsfolgen bestehen kann.
>
Java zählt zu den imperativen Programmiersprachen, in
denen der Programmierer die Abarbeitungsschritte seiner
Algorithmen durch Anweisungen vorgibt.
Mark Egloff 2006
3
Java
Programmierung mit
Anweisungen in Java
Übersicht verschiedene Anweisungen in Java (1/4)
>
In Java lassen sich die Anweisungen ca. in 7 Arten einteilen:
;
Leere Anweisung
{}
Block Anweisung
Label:
Bezeichnete Anweisung
class ABC{}
int i;
public static void main(){}
String str = "Hello" + "World";
System.out.print("O");
X++; Y = X + 2;
Mark Egloff 2006
DeklarationsAnweisung
AusdrucksAnweisung
4
Java
Programmierung mit
Anweisungen in Java
Übersicht verschiedene Anweisungen in Java (2/4)
AuswahlAnweisung
if (x==1) do();
if (x==1){...}
else {...}
test()? A : B;
switch(x)
{
case(1): do();
break;
}
Mark Egloff 2006
5
Java
Programmierung mit
Anweisungen in Java
Übersicht verschiedene Anweisungen in Java (3/4)
IterationsAnweisung
while(x < 1)
{...}
do
{...} while(x < 1);
for( int i = 0; i < 23; i++)
{...}
break;
continue;
return;
throw;
SprungAnweisung
Mark Egloff 2006
6
Java
Programmierung mit
Anweisungen in Java
Übersicht verschiedene Anweisungen in Java (4/4)
synchronized{...}
threadsafe{..}
SynchronisationsAnweisung
try{...}
catch(IOException){...}
finally{...}
Mark Egloff 2006
SchutzAnweisung
7
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (Java 1.5)
abstract
continue
for
new
switch
assert1.4
default
if
package
synchronized
boolean
do
goto
private
this
break
double
implements
protected
throw
byte
else
import
public
throws
case
enum1.5
instanceof
return
transient
catch
extends
int
short
try
char
final
interface
static
void
class
finally
long
strictfp1.2
volatile
const
float
native
super
while
 “const” u. “goto” können nicht verwendet werden, sind aber Schlüsselwörter
Mark Egloff 2006
8
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (1/5)
abstract Deklarationsanweisung, für Klasse nu. Methoden definiert eine
nichtinstanzierbare Klasse bzw. zu überschreibender Bereich
assert1.4
Ausdrucksanweisung Einbettung von Testanweisungen die
ausgeschaltet werden können (seit Java 1.4)
boolean
Deklarationsanweisung, Primitiver Datentyp
break
Sprunganweisung, bricht aktueller Block ab
byte
Deklarationsanweisung, Primitiver Datentyp
case
Verzweigung in einer MehrfachVerzweigungs-Anweisung (switch)
catch
Schutzanweisung, zum Auffangen einer Exception
char
Deklarationsanweisung, Primitiver Datentyp
class
Deklarationsanweisung, Deklaration einer Klasse
const
Reserviertes Wort aber nicht verwendet in Java
Mark Egloff 2006
9
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (2/5)
continue Sprunganweisung, aktuellen Block unterbrechen & weiterfahren
default
Auswahl-Anweisung, Standard b. Mehrfach-Verzweigung (switch)
do
Iterations-Anweisung, leitet do … while Schleife ein
double
Deklarationsanweisung, Primitiver Datentyp
else
Auswahl-Anweisung, Verzweigung bei nicht zutreffen
enum1.5
Deklarationsanweisung, Ermöglich die Erstellung von
Nummerierungstypen (seit Java 1.5)
extends
Deklarationsanweisung, Vererbung bei Klassen und Interfaces
final
Deklarationsanweisung, Konstanten und Schuz um Klassen zu
überschreiben
finally
Schutzanweisung, leitet ein Block ein der immer ausgeführt wird
float
Deklarationsanweisung, Primitiver Datentyp
Mark Egloff 2006
10
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (3/5)
for
Iterations-Anweisung, Definition einer for Schleife
if
Auswahlanweisung, Einleitung des zu testenden Ausdrucks
goto
Geschütztes Wort aber in Java nicht verwendet
implements
Deklarationsanweisung, Klassen-Modifizierer, gibt an welche
Interfaces implementiert wurden
import
Bekanntmachung der Packages, Namespaces
instanceof
Operator um den Datentyp eines Objekts zu testen
int
Deklarationsanweisung, Primitiver Datentyp
interface
Deklarationsanweisung, Definiert ein Interface
long
Deklarationsanweisung, Primitiver Datentyp
native
Deklarationsanweisung, Klassen – Methodenmodifizierer,
Element ist in einer anderen Sprache geschrieben
Mark Egloff 2006
11
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (4/5)
new
Ausdrucksanweisung, zur Erzeugung eines neuen Objektes
package
Deklarationsanweisung, definiert Zugehörigkeit der Klasse
private
Deklarationsanweisung, Zugriffschutz für Kapselung
protected
Deklarationsanweisung, Zugriffschutz für Kapselung
public
Deklarationsanweisung, Zugriffschutz für Kapselung
return
Ausdrucksanweisung, Rückgabe bei Methoden
short
Deklarationsanweisung, Primitiver Datentyp
static
Deklarationsanweisung, Definiert globaler Bereich in Klasse
strictfp1.2
Deklarationsanweisung, um Floatingpoint Kompatibilität auf
allen Plattformen zu gewährleisten (seit Java 1.2)
super
Ausdrucksanweisung, Aufruf der Elemente der Basisklasse
Mark Egloff 2006
12
Java
Programmierung mit
Anweisungen in Java
Reservierte Schlüsselwörter in Java (5/5)
switch
Auswahl-Anweisung, leitet eine Mehrfach-Auswal ein
synchronized
Deklarationsanweisung bei Methoden- oder Block, dieser
Bereich wird mit Semaphoren geschützt, für Multi-threading
this
Ausdrucks-Anweisung, Referenz auf sich selber das
momentanes Objekt
throw
Schutzanweisung um einen Fehler (Exception) auszulösen
throws
Deklarationsanweisung, definiert welche Exceptions ausgelöst
werden dürfen
transient
Deklarationsanweisung, keine Serialisierung für Attribute
try
Schutzanweisung, Einleitung eines zu überprüfenden Blocks
void
Deklarationsanweisung, definiert keine Rückgabe b. Methoden
volatile
Deklarationsanweisung, Überprüfung für Compiler das
Variable nicht verwendet wird von mehreren threads
while
Iterations-Anweisung, Einleitung einer „while“ Schleife
Mark Egloff 2006
13
Java
Programmierung mit
Eine Einführung in Java
> Kontrollstrukturen
Mark Egloff 2006
14
Java
Programmierung mit
Lernziel Heute Abend
>
Sie kennen die Bedeutung von Kontrollstrukturen
>
Sie verstehen den Aufbau und Ablauf von Schleifen und
Auswahlanweisungen
>
Sie erstellen eigene Schleifen mit Mehrfachauswahl.
Mark Egloff 2006
15
Java
Programmierung mit
Kontrollstrukturen
> Was sind Kontrollstrukturen ?
>
Kontrollstrukturen dienen in einer Programmiersprache dazu,
Programmteile unter bestimmten Bedingungen auszuführen.
>
Java bietet zum Ausführen verschiedener Programmteile eine
if- und if /else-Anweisung sowie die switchAnweisung
>
Mittels den Iterationsanweisungen von while /do while
/for können in Java sämtliche Schleifen (Mehrfachausführungen von Anweisungen) erstellt werden
>
Mit den Sprunganweisungen break / continue können in
Java Blöcke bzw. Schelifen abgebrochen und fortgesetzt
werden
Mark Egloff 2006
16
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung (1/6)
>
Die Anweisung beginnt mit dem Schlüsselwort „if“, dem
zwingend ein Ausdruck vom Typ „boolean“ in Klammern folgt.
>
Es folgt eine Anweisung die nur ausgeführt wird falls der
boolean - Ausdruck „true“ ist
>
Mit „else“ kann die Anweisung definiert werden welche im Falle
„false“ ausgeführt werden soll. Dieser Teil ist optional
Syntax:
if ( boolean-Ausdruck )
Anweisung;
[ else
Anweisung; ]
Mark Egloff 2006
17
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung – Beispiele (2/6)
Einfach Auswahl ohne else - Anweisung
if( i == 45 )System.out.print("i ist 45");
if ( x < y )
System.out.print("x ist kleiner als y");
Einfach Auswahl mit else - Anweisung
if( x == 3 )System.out.print("x ist 3");
else System.out.print("x ist anders");
if( x==3 && i!=4 )
System.out.print("x == 3 und i !=4");
Mark Egloff 2006
18
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung – Beispiele (3/6)
>
Mehrere Anweisungen müssen in einem separaten Block
„{}“ untergebracht werden
z.B.:
if( x==3 )
{
System.out.print("x");
System.out.print(" ist ");
System.out.println("3");
}
else
{
System.out.print("x ist anders");
}
Mark Egloff 2006
19
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung – Beispiele (4/6)
>
Achtung bei Verschachtelung von „if“ Anweisungen, das
„else“ gehört immer zum letzten „if“
z.B.: ohne Einrückung und ohne Klammern ist es schlecht lesbar !
if( x==3 )
if (i==4)
System.out.print("x = 3 und i = 4");
else

System.out.print("x = 3 und i != 4");
else if (j > 0)
System.out.print("x !=3, i = ? und" +
"j > 0!");
Mark Egloff 2006
20
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung – Beispiele (5/6)
z.B.: besser mit Einrückung, aber noch besser Klammern
setzen
if( x==3 )
{
if (i==4)
{
System.out.print("x = 3 und i = 4"); }
else
{
System.out.print("x = 3 und i != 4"); }
else
{
if (j > 0)
{ System.out.print("x !=3, i = ? und j > 0!"); }
}
Mark Egloff 2006
21
Java
Programmierung mit
Kontrollstrukturen
Die „if/else“ Anweisung – Beispiele (6/6)
>
Mehrere „if“ Anweisungen können mittels den
Operatoren „&&“ „||“ „!“ zusammengefasst werden
z.B.: Verschachtelte if-Anweisung zusammenfassen mit „&&“
if( x==3 )
{
if (i==4)
{
System.out.print("x = 3 und i = 4"); }
}
if( x==3 && i==4)
System.out.print("x = 3 und i = 4");
Mark Egloff 2006
22
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (1/6)
>
Die switch-Anweisung ist für Mehrfachverzweigungen. Sie
vergleicht nacheinander einen Ausdruck mit einem jeweiligen
Wert bzw. Fall „case“.
switch( Ausdruck )
{
case(Wert_1): [Anweisung im Falle Ausdruck == Wert1]
break;
case(Wert_n): [Anweisung im Falle Ausdruck == Wert_n]
break;
default:
[Anweisung im Falle kein Wert zutrifft]
break;
}
Mark Egloff 2006
23
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (2/6) – Syntax / Regeln
>
Der zu testende Ausdruck „switch(Ausdruck)“ muss vom Typ
„int“ oder in „int“ wandelbar sein z.B. „byte“, „char“ etc.
>
Jeder Fall wird mit einem „case(Wert):“ eingeleitet wobei der
zu prüfende Wert ebenfalls vom Typ „int“ und konstant sein
muss.
>
Trifft ein „case“ Fall zu, so wird dieser ausgewertet und alle
Anweisungen bis zum „break“ abgearbeitet.
>
Trifft kein Fall zu so wird der optionale „default“ abgearbeitet
>
Der switch- Block muss mindestens ein „case“ oder
„default“ haben
Mark Egloff 2006
24
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (3/6) – Syntax / Regeln
switch( Ausdruck )
Datentyp „int“
{
case(Wert_1): [Anweisung im Falle Ausdruck == Wert1]
break;
case(Wert_n): [Anweisung im Falle Ausdruck == Wert_n]
break;
Konstanter Wert
Abbruch des Blocks
Datentyp „int“
default:
[Anweisung im Falle kein Wert zutrifft]
break;
}
Mark Egloff 2006
25
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (4/6) – einfaches Beispiel
switch( x )
{
case(4): System.out.print("x ist 4 !");
break;
case(3): System.out.print("x ist 3 !");
break;
default: System.out.print("x ist anders !");
break;
}
Mark Egloff 2006
26
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (5/6) – Beispiel „Durchfall“
>
Falls bei einem „case“ kein „break“ angegeben wird werden
sämtliche Anweisungen abgearbeitet bis zum nächsten „break“
>
Dadurch lassen sich „case“ Fälle absichtlich zusammenfassen
z.B.: switch( x )
{
case(4):
System.out.print("x ist 4 und");
case(3):
System.out.print("x ist 3 !");
break;
default:
System.out.print("x ist anders!");
break;
}
Mark Egloff 2006
27
Java
Programmierung mit
Kontrollstrukturen
Die „switch/case“ Anweisung (6/6) - Beispiel Konstante
>
z.B.:
Bei jedem zu prüfenden Fall „case“ kann nur ein konstanter „int“
Wert (oder wandelbar in „int“) angegeben werden, also entweder
eine Literale oder Konstante
final byte b = 3;
Lokale Konstante
switch( x )
{
case(4):
System.out.print("x ist 4 !");
break;
case(b):
System.out.print("x ist 3 !");
break;
}
Mark Egloff 2006
28
Java
Programmierung mit
Kontrollstrukturen
Die „while“ Schleife (1/3)
>
Mittels „while“ wird in Java eine einfache Schleife (Iteration)
eingeleitet.
>
Die Schleife wird solange wiederholt bis der zu prüfende
Ausdruck „false“ ist. Der Ausdruck muss Typ „boolean“ sein
>
Die „while“-Schleife ist eine abweisende Schleife, da sie vor
jedem Schleifeneintritt die Schleifenbedingung prüft
>
Mehrere Anweisungen müssen in einem Block „{}“
zusammengefasst werden
Syntax: while( boolean-Ausdruck )
Anweisung;
Mark Egloff 2006
29
Java
Programmierung mit
Kontrollstrukturen
Die „while“ Schleife (2/3) – Beispiele 1
z.B. Einfacher Zähler
int i = 0;
 stoppt bei i = 10, läuft 10 mal
while ( i < 10 ) i++;
z.B. Mehrere Anweisungen
int i = 0;
while ( i < 10 )
{
i++;
System.out.println(i);
}
Mark Egloff 2006
30
Java
Programmierung mit
Kontrollstrukturen
Die „while“ Schleife (3/3) – Beispiele 2
Einfache Endlosschleifen
 Bedingung bleibt „true“
while( true )
System.out.println("endlos");
 keine Anweisung die was ändert
while( x == 3 );
Endlosschleifen durch Überlauf

byte b = 0;
while( b < 129 ) b++
 129 wird als int angesehen
 129 ist nicht in byte enthalten
Endlosschleifen durch Ungenauigkeit
double d = 0.0;
while( d != 1.0 ) d += 0.1;

Mark Egloff 2006
 double u. float ist „ungenau“
 0.999999 != 1.0
31
Java
Programmierung mit
Kontrollstrukturen
Die „do / while“ Schleife (1/2)
>
Die „do/while“ Schleife ist fast wie die „while“ Schleife. Die
Bedingung wird jedoch am Schluss geprüft
>
Dieser Schleifentyp ist eine annehmende Schleife, da die
Schleifenbedingung erst nach jedem Schleifendurchgang geprüft
wird
>
Mehrere Anweisungen müssen in einem Block „{}“
zusammengefasst werden
Syntax: do
Anweisung;
while( boolean-Ausdruck );
Mark Egloff 2006
32
Java
Programmierung mit
Kontrollstrukturen
Die „do / while“ Schleife (2/2) – Beispiele
z.B. Einfacher Zähler mit mehreren Anweisungen
int pos = 1;
do
{
System.out.println( pos );
pos++;
} while ( pos < 10 );
Mark Egloff 2006
33
Java
Programmierung mit
Kontrollstrukturen
Die „for“ Schleife (1/5)
>
Die for-Schleife ist eine spezielle Variante einer while-Schleife
und wird typischerweise zum Zählen benutzt.
>
for-Schleifen sind abweisend, der Rumpf wird also erst dann
ausgeführt, wenn die Bedingung true ist.
>
Die for-Schleife besteht aus Initial-Anweisung, zu prüfender
Ausdruck, Schrittanweisung und der zu wiederholenden
Anweisung
>
Mehrere Anweisungen müssen in einem Block „{}“
zusammengefasst werden
Syntax: for( InitialAnw; boolean-Ausdruck; SchrittAnw)
Anweisung;
Mark Egloff 2006
34
Java
Programmierung mit
Kontrollstrukturen
Die „for“ Schleife (2/5)
z.B. Gib die Zahlen von 1 bis 10 auf dem Bildschirm aus
1.
2.
4.
for ( int i = 1; i <= 10; i++ )
System.out.println( i );
3.
Ablauf:
1. Initialisiere i mit 1
2. Teste, ob i <= 10 gilt.
3. Ergibt sich true, dann führe den Block aus, sonst ist es das
Ende der Schleife.
4. Erhöhe i um 1.
5. Geh zu Schritt 2.
Mark Egloff 2006
35
Java
Programmierung mit
Kontrollstrukturen
Die „for“ Schleife (3/5) – Beispiele 1
z.B. „<“ und „<=“
for ( i = 0; i < 10; i++ ) ...
 Beide sind gleich
for ( i = 0; i <= 9; i++ ) ...
 werden 10 mal ausgeführt
z.B. Einfache Endlosschleife
 ; muss immer angegeben werden
for ( ; ; ) ...;
z.B. Geschachtelte Schleifen
for ( int i = 1; i <= 5; i++ )
{
for ( int j = 1; j <= i; j++ )
System.out.print( "*" );
System.out.println();
}
Mark Egloff 2006
 Ausgabe:
*
**
***
****
*****
36
Java
Programmierung mit
Kontrollstrukturen
Die „for“ Schleife (4/5) - mehrere Initial-Anweisungen
>
Variabeln die in der Initialanweisung deklariert wurden sind nur
innerhalb der Schleife gültig, danach nicht mehr
>
Mehrere Variablen können deklariert werden, werden mit ','
getrennt, alle müssen denselben Datentyp verwenden
z.B.: zwei Variabeln vom Typ „int“
for ( int i = 1 , j = 0; i <= 10; i++ )
System.out.println( i + j++ );
Ausgabe: 1
3
5
7
...
Mark Egloff 2006
37
Java
Programmierung mit
Kontrollstrukturen
Die „for“ Schleife (5/5) - mehrere Schrittanweisungen
>
Bei der for-Schleife können auch mehrere Schrittanweisungen
angegeben werden. Die einzelnen Anweisungen müssen dabei
mit ',' getrennt werden
z.B.: Schleife mit zwei Zählern
for ( int i = 1 , j = 9; i <= j; i++ , j-- )
System.out.println( i + "*" + j + "=" + i * j );
Ausgabe: 1*9
2*8
3*7
4*6
5*5
=
=
=
=
=
9
16
21
24
25
Mark Egloff 2006
38
Java
Programmierung mit
Kontrollstrukturen
Sprunganweisungen „break“ und „continue“ (1/4)
>
In Schleifen können Sprung-Anweisungen ausgeführt werden um
die Schleife abzubrechen oder sie frühzeitig fortzuführen.
>
Mittels „break“ wird eine Schleife abgebrochen
>
Mittels „continue“ springt die Schleife zum nächsten Durchlauf
>
Die Anweisungen sind nützlich um festzustellen, ob die Schleife
noch einmal durchlaufen werden soll.
Syntax:
Iterations-Anweisung
{
if ( Ausdruck ) break [label];
if ( Ausdruck ) continue [label];
}
Mark Egloff 2006
39
Java
Programmierung mit
Kontrollstrukturen
Sprunganweisungen „break“ und „continue“ (2/4)
z.B. Führe die Schleife so lange durch, bis „i“ den Wert 0 hat.
int i = 10;
while ( true )
if ( i-- == 0 )
break;
 Abbruch der Schleife
z.B. Gib die geraden Zahlen von 0 bis 10 aus.
for ( int i = 0; i <= 10; i++ )
{
if ( i % 2 == 1 )
continue;
 nächster Schleifendurchlauf
System.out.println( i + " ist eine gerade Zahl" );
}
Mark Egloff 2006
40
Java
Programmierung mit
Kontrollstrukturen
Sprunganweisungen „break“ und „continue“ (3/4)
>
Mit einer Sprungmarke kann man einen Label vor ein for-,
while- oder do-while-Statement setzen und dann mit
continue labelname; bzw. break labelname; eine
(äußere) Schleife, auch von innen aus, vorzeitig beenden.
>
Die Sprungmarke kann ein beliebiges Wort sein mit
anschliessenden „:“, muss unmittelbar vor der Schleife
angegeben werden
Syntax:
label:
Iterations-Anweisung
{
if ( Ausdruck ) break label;
if ( Ausdruck ) continue label;
}
Mark Egloff 2006
41
Java
Programmierung mit
Kontrollstrukturen
Sprunganweisungen „break“ und „continue“ (4/4)
z.B. Sprungmarke in verschachtelter for-Schleife
outer:
for (int i=0; i<10;i++)
{
Zuvor definiertes Label
for (int v=0; v<10;v++)
{
if (v==1) continue;
if (v==2) continue outer;  continue auf äussere Schleife
if (v==3) break outer;
 Abbruch äusserer Schleife
if (v==4) break;
}
// inner block end...
}
// outer block end...
Mark Egloff 2006
42
Java
Programmierung mit
Eine Einführung in Java
> Einführung in
statische Methoden
Mark Egloff 2006
43
Java
Programmierung mit
Lernziel Heute Abend
>
Sie verstehen den Aufbau von statischen Methoden
können auch eigene erstellen.
>
Sie wissen wie rekursive Methoden funktionieren und
können auch eigene schreiben.
Mark Egloff 2006
44
Java
Programmierung mit
Methoden
>
Eine Methode kann als benannte Folge von Anweisungen
angesehen werden
>
Methoden dienen dazu um mehrere Anweisungen als Blöcke
zusammenzufassen und zugleich parametrisierbar zu machen
>
Java kennt zwei Arten von Methoden
 Statische „static“ Methoden (Klassenmethoden)
 Objekt Methoden (Instanzmethoden)
Syntax: [zugriff] [static] Rückgabetyp name([parameter])
{
Anweisungen;
[return [Ausdruck];]
}
Mark Egloff 2006
45
Java
Programmierung mit
Statische Methoden
„static“ Methoden (Klassenmethoden)
>
Statische Methoden (oder auch Klassenmethode) können als
globale Methoden angesehen werden.
>
Sie sind nicht an ein Objekt gebunden und können daher wenn
es der Zugriffschutz erlaubt (= public) von überall her
aufgerufen werden
>
Statische Methoden müssen innerhalb einer Klasse mit „static“
definiert werden, sonst sind sie automatisch Instanzmethoden.
>
Die Klasse dient lediglich als Namensraum (Namespace). Falls
die Methode ausserhalb der Klasse aufgerufen werden muss,
muss der Klasssennamen zuvor mit „.“ angegeben werden.
>
„static void main()“ ist ebenfalls eine statische Methode
Mark Egloff 2006
46
Java
Programmierung mit
Statische Methoden
„static“ Methoden (Klassenmethoden) – Beispiel 1
z.B. Eigene „helloWorld()“ Methode und Aufruf in eigener Klasse
public class HelloWorld
{
public static void main(String[] args)
{
helloWorld();
}
public static void helloWorld()
{
System.out.println("hello world!");
}
}
Mark Egloff 2006
47
Java
Programmierung mit
Statische Methoden
„static“ Methoden (Klassenmethoden) – Beispiel 2
z.B. Eigene „helloWorld()“ Methode und Aufruf in fremder Klasse
public class Run {
public static void main(String[] args){
HelloWorld.helloWorld();
}
}
class HelloWorld {
public static void helloWorld(){
System.out.println("hello world!");
}
}
Mark Egloff 2006
48
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – der Zugriffschutz
>
Als erstes folgt der Zugriffschutz. Er gibt an von wo aus die
Methode überhaupt aufgerufen werden darf
>
Es gibt folgende 4 Zugriffschutzmechanismen:

„public“ :

„protected“ : darf nur in allen verwandten Klassen
aufgerufen werden (Vererbung)

„private“:
darf nur in der eigenen Klasse aufgerufen werden

Keine Angabe:
Standardmässig. Methode kann in
verwandten Klassen aber nur innerhalb
desselben Packages aufgerufen werden
darf von überall her aufgerufen werden
[zugriff] [static] Rückgabetyp name([parameter])
Mark Egloff 2006
49
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – der Zugriffschutz - Beispiel 3
z.B. Eigene „helloWorld()“ Methode und Aufruf in fremder Klasse
public class Run {
public static void main(String[] args){
HelloWorld.helloWorld();
}

 compilerfehler da private
}
class HelloWorld {
private static void helloWorld(){
System.out.println("hello world!");
}
}
Mark Egloff 2006
50
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Rückgabe
>
Nach „static“ folgt die Angabe des Rückgabetyps. Dies muss
entweder ein primitiver Datentyp sein oder ein Klassennamen
>
Die Methode kann nur ein Wert bzw. Referenz (Ausdruck)
zurückgeben
>
Soll kein Wert zurückgegeben werden so muss „void“
angegeben werden
>
Innerhalb der Methode wird die Rückgabe mit „return“
eingeleitet. Nach dem „return“ können keine weiteren
Anweisungen folgen.
[zugriff] [static] Rückgabetyp name([parameter])
Mark Egloff 2006
51
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Rückgabe - Beispiel 4
z.B. Eigene „helloWorld()“ Methode mit „return“
public class Run
{
public static void main(String[] args)
{
System.out.println( helloWorld() );
}
public static String helloWorld()
{
return "hello world!";
}
}
Mark Egloff 2006
52
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Rückgabe - Beispiele 5
z.B. Vorzeitige Rückgabe aber ohne Wert
public static void myMethod() {
int x = ...;
Bei Angabe von „void“ kann mit „return;“
if (x == 22) return;
ein vorzeitiger Abbruch erreicht werden
...
}
z.B. Mehrere Rückgabe-Fälle mit Wert
public static int myMethod() {
int x = ..., a = ...;
Falls Rückgabetyp angegeben wurde
if (x == 22) return x;
so muss immer ein „return“ mit Wert
else return a;
erfolgen, ansonsten Compilerfehler
}
Mark Egloff 2006
53
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – der Methodennamen
>
Nach dem Rückgabetyp folgt immer der Methodenname gefolgt
von runden Klammern
>
Als mögliche Bezeichner gelten dieselben Regeln wie bei den
Variabelnamen
[zugriff] [static] Rückgabetyp name([parameter])
Mark Egloff 2006
54
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Parameter
>
Als letztes folgt in den Klammern die Angabe von Übergabeparametern. Es können mehrere übergeben werden, müssen
dabei mit ',' getrennt werden. Parameterdeklarationen sind
optional.
>
Parameterangaben bestehen immer aus Datentyp und
Bezeichner-Gruppen. Der Parameter ist nur für die Methode gültig.
>
Beim Aufruf müssen immer alle Parameter angegeben werden
>
Abstrakte Datentypen werden „by Reference“ (als Originale)
übergeben
[zugriff] [static] Rückgabetyp name([parameter])
Mark Egloff 2006
55
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Parameter – Beispiel 6
z.B. Eigene „helloWorld()“ Methode mit Parameter
public class Run
{
public static void main(String[] args)
{
helloWorld("Hello");
}
public static void helloWorld( String s )
{
System.out.println( s + " world!";
}
}
Mark Egloff 2006
56
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – die Parameter – Beispiel 7
z.B. Mehrere Übergabeparamater
public static void myMethod( String name, int x ) {
System.out.prinln("Heute wurde " + name + " " + x
" Jahre alt");
}
+
Aufruf:
myMethod( "Fritz",77 );
 Heute wurde Fritz 77 Jahre alt
Mark Egloff 2006
57
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – Übergabe „by Value“
>
z.B.:
Aufruf:
Bei primitiven Datentypen erfolgt die Übergabe „by Value“. Eine
Kopie der Variable bzw. des Wertes wird erstellt. Das Original
bleibt unverändert.
public static void myMethod( int x ) {
x++;
}
int x = 77;
myMethod(x);
System.out.println(x);
Mark Egloff 2006
 unverändert 77
58
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – Übergabe „by Reference“
>
Abstrakte Datentypen bzw. Objekte werden „by Reference“ (als
Originale) übergeben. Wird ein solcher Parameter in der
Methode verändert, so wird dies auf dem Original vorgenommen.
 Änderung bleibt nach Ablauf der Methode bestehen !
>
Bei der Übergabe von Objekten gibt es keine Möglichkeit diese
vor allfälliger Modifikation zu schützen
z.B.:
public static void myMethod( StringBuffer sb ) {
sb.append(" world!");
}
Aufruf:
StringBuffer s = new StringBuffer("Hello");
myMethod(s);
System.out.println(s);
 verändert “Hello world!”
Mark Egloff 2006
59
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – Übergabe „by Reference“
Beispiel Übergabe von Objekt des Typs „java.lang.String“
public static int myMethod( String str ) {
str.replace(' ','_');  Keine Veränderung, da “immutable” !
}
Aufruf:
String s = "Java ist einfach!";
myMethod(s);
System.out.println(s);
 unverändert “Java ist einfach!”
Mark Egloff 2006
60
Java
Programmierung mit
Statische Methoden
Aufbau von Methoden – Übergabe „by Reference“
Beispiel Übergabe von Objekt und neu-Instanzierung
public static int myMethod( StringBuffer sb ) {
sb = new StringBuffer("Hello World!");
//  neues Objekt ist nur gültig in dieser Methode
2.
3.
}
Aufruf:
StringBuffer s = new StringBuffer("Hello");
myMethod(s);
System.out.println(s);  unverändert “Hello”
Speicher:
1.
s
2.
sb
3.
sb
1.
2.
Hello
Hello World!
Mark Egloff 2006
61
Java
Programmierung mit
Statische Methoden
Überladen von Methoden
>
Überladene Methoden sind Methoden die mehrmals in der
gleichen Klasse mit demselben Namen definiert wurden
>
Die Parameterübergabe muss sich jedoch unterscheiden, durch
die Anzahl Parameter sowie Reihenfolge der Datentypen
>
Vorteil liegt beim Methodenaufruf. Anwender muss nicht die
genaue Deklaration 100%ig kennen z.B. „System.out.println()“
>
Der Interpreter ruft anhand der Parameterübergabe die richtige
Methode auf. Zur Not werden die Parameter implizit gewandelt!
z.B.:
public static void println( int x ) { … }
public static void println( float f ) { … }
public static void println( String s ) { … }
Mark Egloff 2006
62
Java
Programmierung mit
Statische Methoden
Überladen von Methoden – Beispiel 8
Beispiel anhand „System.out.println()“
java.sun.com/j2se/1.5.0/docs/api/java/io/PrintStream.html
void println()
void println(boolean x)
void println(char x)
System.out.println();
void println(char[] x)
System.out.println(
new char[]{'A','B'});
System.out.println(1.23);
System.out.println(1.23f);
System.out.println(77);
System.out.println(123567899L);
System.out.println(new Short(4));
System.out.println();
void
void
void
void
void
void
println(double x)
println(float x)
println(int x)
println(long x)
println(Object x)
println(String x)
System.out.println(true);
System.out.println('A');
Mark Egloff 2006
63
Java
Programmierung mit
Statische Methoden
Überladen von Methoden – Beispiel 9
Beispiel Überladung mit unterschiedlicher Parameteranzahl
public static int max( int i, int j ) {
return Math.max( i, j );  Math.max() gibt die grössere zurück
}
public static int max( int i, int j, int k ) {
return max( i, max(j, k) ); // Methode von oben aufrufen
}
 ruft Methode 1 auf  7
 ruft Methode 2 auf  9
Aufruf.: max(3,7);
max(9,7,1);
Mark Egloff 2006
64
Java
Programmierung mit
Statische Methoden
Überladen von Methoden – Beispiel 10
Compilerfehler da gleiche Parameterdatentypen und Reihenfolge
public static void myMethod( int i, int j )
{...}
public static void myMethod( int x, int z )
{...}

Erlaubt gleiche Parameterdatentypen und unterschiedliche Reihenfolge
public static void myMethod( float f, int i )
{...}
public static void myMethod( int i, float f )
{...}
Mark Egloff 2006

65
Java
Programmierung mit
Statische Methoden
Überladen von Methoden – Beispiel 11
Ad Hoc Datentypwandelung und Aufruf der jeweiligen Methode
public static void myMethod( byte b, int j )
{...}
public static void myMethod( double x, int z )
{...}
 ruft Methode 2 auf, “int” in “double”
myMethod((byte)3,7);  ruft Methode 1 auf
Aufruf.: myMethod(3,7);
Mark Egloff 2006
66
Java
Programmierung mit
Statische Methoden
Rekursive Funktionen
>
Rekursive Funktionen sind Funktionen die sich intern selber
oder gegenseitig aufrufen, dadurch entsteht eine Schleife.
>
Rekursive Funktionen sind äusserst kompakt in Code und
daher sehr beliebt. Leider nicht immer sofort überschaubar.
>
Eignen sich besonders gut beim traversieren durch
Baumstrukturen z.B. XML
z.B.:
public static void runter( int n ) {
if ( n == 0 ) return;
System.out.print( n + ", " );
runter( n – 1 );
}
Mark Egloff 2006
67
Java
Programmierung mit
Statische Methoden
Rekursive Funktionen
z.B.:
public static void runter( int n ) {
if ( n == 0 ) return;
 Abbruch
System.out.print( n + ", " );
runter( n – 1 );
}
runter(0)
runter(10)
10 8 6 4
3 5 7 9
Ausgabe: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
Mark Egloff 2006
68
Java
Programmierung mit
Statische Methoden
Rekursive Funktionen – Beispiel 12
z.B. Grösster gemeinsamer Teiler
public int ggt(int zahl1, int zahl2)
{
Abbruchbedingung
if ( zahl2 == 0)
return zahl1;
else
Rekursion
return ggt(zahl2,zahl1 % zahl2);
}
Aufruf.: ggt(12,4);
ggt(104,12);
 4
 4
Mark Egloff 2006
69
Java
Programmierung mit
Statische Methoden
Rekursive Funktionen – Beispiel 12
z.B. Grösster gemeinsamer Teiler
ggt(104,12)
 Ergebnis: 4
return ggt(12,8);
return ggt(8,4);
104 % 12 = 8  weiter
12 %
return ggt(4,0); 8 %
8 = 4  weiter
4 = 0  abbruch
Abbruch !
ggt(12,104)
return ggt(104,12);
return ggt(12,8);
...
Mark Egloff 2006
 Ergebnis: 4
 12 % 104 = 12
 104 % 12 = 8
70