Programmieren mit Java Java-Referenzen

GhK 

FB 17 Mathematik / Informatik 

Programmieren mit Java 

Was ist JAVA? 

Arbeitsweise, Programmstruktur 

GhK 


Java-Referenzen 

• http://www.ora.com/info/java/ (Verlagsseite O‘ Reilly) 

• http://www.javasoft.com/ (Sun Microsystems Java-Seite) 

• David Flanagan : JAVA in a nutshell (deutsch), O‘ Reilly, 1996 

• Martin Schrader , Lars Schmidt- Thieme : Java, eine Einführung, Springer 1997

GhK 


• einfach 

– nur kontrollierte Sprünge (kein goto) 

– modularer Aufbau 

– keine Zeiger 

• interpretiert 

– Übersetzung in Java-Bytecode 

– interpretiert durch ava-¡ irtual-¢ achine 

– portabel (plattformunabhängig) 

– gute Performance , sparsam 

£ 

ust ¤ n ¥ ime compilierung 

• robust 

– für technische Anwendungen kozipiert 

– stark typisiert 

– Ausnahmenbehandlung 

– Sicherheit 

• Objekt-orientiert 

• Multithread-fähig 

Eigenschaften von Java 

GhK 


Java-Umgebung 

.java-Datei 

Compiler 

(javac) 

.class-Datei 

Applet 

Applikation 

Texteditor 

Compiler 

(javadoc) 

Interpreter 

(appletviewer) 

JVM (java) 

Interpreter 

.html-Datei 

Browser 

(netscape) 

Interpreter

GhK 


elementare Programmstruktur 

• Programme (Java-Klassen) 

public class 

{ 

public static void main (String args[]) 

{ .......... 

} 

} 

• Applets 

import java.applet.*; 

import java.awt.*; 

Programmdatei : 

.java 

public class 

{ 

public static void main 

(String args[]) 

{ .......... 

} 

} 

public class extends Applet 

{ 

public void init () 

{ .......... 

} 

public void paint (Graphics ) 

{ .......... 

} 

} 

GhK 


Kommentare 

• von entscheidender Wichtigkeit bei jedem Programmieren 

sind die Kommentare, ohne die ein Programm weder 

lesbar noch wartbar ist: 

– Was tut dieser Programmabschnitt? 

– Welche Rolle spielt diese Variable 

– Welche Bedingungen sind an diese Parameter geknüpft 

• Java kennt 3 sorten von Kommentarklammern 

– // ........ Zeilenende kurze Anmerkungen 

– /* ........ */ Kommentare über mehrere Zeilen 

– /** ........ */ Kommentare, die zur Dokumentation 

verwendet werden

GhK 


// Zaehler.java 

Beispiel: Zaehler 

class Zaehler 

{ 

// Variablen 

private int wert; 

//Zählerstand 

//Methoden 

int wert() {return wert;} 

//Zählerstand ablesen 

void wert(int i) {wert = i;} //Zähler setzen 

void inkrement() {++wert;} // weiterzählen 

void dekrement() {--wert;} // zurückzählen 

} 

GhK 


//ZaehlerTest.java 

import java.io.* ; 

//in/output 

class ZaehlerTest 

{ 

public static void main(String[] args) 

{ 

Zaehler z = new Zaehler(); 

BufferedReader in = 

new BufferedReader( 

new InputStreamReader(System.in)); 

// in liest von der Tastatur 

PrintWriter out = 

new PrintWriter(System.out, true); 

// out schreibt auf den Bildschirm 

for(;;) 

{ //Endlosschleife 

out.println("----\nZählerstand: " + z.wert() 

+ "\n----"); 

char akt = '+' ; // char-Variable deklariert 

Beispiel ZählerTest 

do 

{ 

out.print("Aktion(+/-): "); 

out.flush(); 

try 

{ 

akt = in.readLine().charAt(0); 

} 

catch(IOException ioe){} 

} 

while (akt != '+' && akt != '-'); 

if (akt ='+') z.inkrement(); 

else z.dekrement(); 

} //Ende for-Schleife 

} //Ende main 

} //Ende ZaehlerTest

GhK 


❚ 

Ausgabe ZaehlerTest 

GhK 


//ZaehlerFrame.java 

import java.awt.* ; //Fenstertechnik 

import java.awt.event.* ; //Mausaktionen 

class ZaehlerFrame extends Frame 

{private Button plus, minus; 

private TextField stand; 

private Zaehler z; 

ZaehlerFrame(String s) 

{super(s); 

z = new Zaehler(); 

setLayout(new GridLayout(2,2)); 

add(new Label("Zählerstand: ", Label.RIGHT) 

add(stand = new TextField(10)); 

stand.setText(String.valueOf(z.wert())); 

stand.setEditable(false); 

add(plus = new Button("Inkrementiere")); 

add(minus = new Button("Dekrementiere")); 

ButtonListener check = new ButtonListener(); 

plus.addActionListener(check); 

minus.addActionListener(check); 

pack(); setVisible(true); 

} //Ende Konstruktor 

Beispiel Zählerframe 


{ new ZaehlerFrame("Zähler-Test") 

} //Ende main 

class ButtonListener 

implements ActionListener 

{public void actionperformed(ActionEvent e) 

{if 

(e.getAction.command().equals("Inkrementiere")) 

z.inkrement(); 

else 

z.dekrement(); 


} //Endeactinperformed 

} //Ende ButtonListener 

} //Ende ZaehlerFrame

GhK 


//ZaehlerApplet.java 

import java.applet.* ; //Applet 

import java.awt.* ; //Fenstertechnik 

import java.awt.event.* ; //Mausaktionen 

public class ZaehlerAplett extends Applet 

{private Button plus, minus; 

private TextField stand; 

private Zaehler z; 

public void init() 

{z = new Zaehler(); 

setLayout(new GridLayout(2,2)); 

add(new Label("Zählerstand: ", Label.RIGHT) 

add(stand = new TextField(10)); 


stand.setEditable(false); 

add(plus = new Button("Inkrementiere")); 

add(minus = new Button("Dekrementiere")); 

ButtonListener check = new ButtonListener(); 

plus.addActionListener(check); 

minus.addActionListener(check); // pack(); 

setVisible(true); 

} //Ende init 

Beispiel Zählerapplet 


{ new ZaehlerFrame("Zähler-Test") 

} //Ende main 

class ButtonListener 

implements ActionListener 

{public void actionperformed(ActionEvent e) 

{if 

(e.getAction.command().equals("Inkrementiere")) 

z.inkrement(); 

else 

z.dekrement(); 


} //Endeactinperformed 

} //Ende ButtonListener 

} //Ende ZaehlerFrame 

HTML-Seite: 

... 

 

GhK 


ZählerApplet

GhK 


Bezeichner 

• Alle in einem Java Programm verwendeten Variablen, 

Funktionen etc. tragen Namen (Bezeichner), die nach 

folgenden Regeln gebildet werden: 

– Sie beginnen mit einem Buchstaben a..z,A..Z oder _,$. 

– die nachfolgenden Zeichen dürfen außerdem auch Zahlen oder andere 

druckbare Zeichen des Unicode-Zeichensatzes (eine 16-Bit Obermenge 

des ASCII-Zeichensatzes) sein. 

• Java ist case-sensitiv, d.h. es unterscheidet zwischen 

Groß- und Kleinschreibung. 

– Er, eR, ER, er sind jeweils verschiedene Bezeichner. 

• Die Verwendung von _ und $ am Bezeichneranfang ist 

nicht zu empfehlen, weil die meisten Programmierer sie für 

Systemvariablen halten werden. 

GhK 


• Java kennt 8 vordefinierte Datentypen 

elementare Datentypen 

Datentyp Größe(Bit) default Wert Min Max 

boolean 8 false 

byte 8 0 -128 127 

char 16 \u0000 \u0000 \uFFFF 

short 16 0 -32768 32767 

int 32 0 -2147483648 2147483647 

long 64 0 -9223372036854775808 

9223372036854775808 

float 32 0.0F ±3.40282347E+38 

±1.40239846E-45 

double 64 0.0D ±1.79769313486231570E+308 

±4.94065645841246544E-324

GhK 


Typ boolean 

• boolean Werte sind keine Zahlwerte, sondern können nur 

die Werte true und false annehmen. 

• Operationen auf boolean: 

! logische Negation (einstellig) 

& logisches AND (zweistellig) 

^ logisches XOR (zweistellig) 

| logisches OR (zweistellig) 

?: logisches IF (dreistellig) 

&& short circuit AND (zweistellig) 

|| short circuit OR (zweistellig) 

== gleich (zweistellig) 

!= ungleich (zweistellig) 

x false true 

!x true false 

x&y false y 

x^y y !y 

x|y y true 

x?y:z z y 

x==y !y y 

x!=y y !y 

GhK 


short circuit Auswertung 

• Die Operationen && sowie || unterscheiden sich in ihrer 

Ausgabe auf boolean nicht von & und |, jedoch im 

„Verhalten“. 

• Ist x&&y bzw. x||y auszuwerten, so wird zunächst x 

berechnet. Wertet x zu 0 bzw. 1 aus, so ist dies bereits die 

Ausgabe, ohne daß y noch ausgewertet werden muß. 

• Der Sinn ist nicht nur eine Verringerung des Aufwandes, 

sondern auch die Vermeidung von Sonderfällen. 

Beispiel: 

(x==0)||(y/x

GhK 


Integer-Typen 

• In Java gibt es keine gesonderten vorzeichenlosen ganzen 

Zahlen, sondern alle 4 Zahlbereiche byte, short, int, long 

haben auch negative Werte. 

• Literale (Zeichendarstellung von Werten) 

– Die Zahlen dürfen mit einem Vorzeichen +,- oder mit 0, 0X oder 0x 

beginnen. 

– Nun kommt eine Folge von Ziffern, die nicht mit 0 beginnt 

– Ist der Anfang 0, besteht die Folge nur aus Oktalziffern 0,..,7 oder ist leer; 

die Zahl wird als Oktalzahl interpretiert. 

– Ist der Anfang 0x oder 0X, können auch die hexadezimalziffern A,..,F bzw. 

a,..,f in der Folge auftreten; die Zahl wird als Hexadezimalzahl interpretiert. 

– alle übrigen Zahlen werden als Dezimalzahlen interpretiert 

– 255, 0377, 0xff, 0xFF, 0XFF haben den gleichen Wert. 

GhK 


Integer-Operationen 

• einstellig 

++ Inkrement x+1 

-- Dekrement x-1 

+, - Vorzeichen x , -x 

~ bitweises Komplement x XOR FF..F 

• zweistellig 

+, - plus, minus 

*, /, % mal, geteilt, Rest 

Shift links, rechts 

>>> Shift rechts mit 0-Erweiterung 

&, ^, | 

bitweises AND, XOR, OR 

• boolean-wertig 

==, != gleich, ungleich 

= Größenvergleich 

?: dreistelliges IF (b)?x:y = “falls b, dann x sonst y“

GhK 


Seiteneffekte von ++ und -- 

• Normalerweise erwartet man von einer Operation, daß sie 

Eingaben entgegennimmt und eine Ausgabe abliefert, aber 

die Eingaben unverändert läßt, ++ und -- sind anders! 

• ++x und --x erhöhen oder erniedrigen den Wert von x um 1 

und liefern dann diesen veränderten Wert von x ab. 

• x++ und x-- liefern zuerst den Wert von x ab und erhöhen 

oder erniederigen danach den Wert von x 

• Beispiel: hat x den Wert 5 , so ist die Wirkung von: 

y=++x y=x++ y=--x y=x-- 

x: 6 6 4 4 

y: 6 5 4 5 

• Man nennt ein solches Verhalten einer Funktion einen 

Seiteneffekt. 

GhK 


char-Typ 

• Der typ char kann beliebige unicode-Zeichen enthalten 

• Literale (werden in Hochkommata ‘ ‘ oder “ “ eingeschlossen ): 

–alle druckbaren Ascii-Zeichen außer ‘ “ und \ . 

–Die Escape-Sequenzen: 

\n (neue Zeile) \t (tabulator) \b (Rückschritt) \r (Rücklauf) 

\f (neue Seite) \‘ ( Hochkomma) \“ (Quotation) \\ (Backslash) 

–Unicode-Zeichen : \uxxxx dabei ist xxxx eine Folge von 1 bis 4 

Hexadezimalziffern. 

• Beispiele 

‘ ‘ Leerzeichen ‘\‘‘ Hochkomma 

‘\‘ „Fehler“ ‘\u5c‘ „derselbe Fehler“ 

‘\\u22‘ Backslash ‘\u3240‘ 

• Operationen: ==, !=, ?:

GhK 


real-Typen 

Gleitkommazahlen gibt es in zwei Genauigkeiten float und 

double, die nach IEEE Standard 754 festgelegt sind, nach 

diesem Standard gibt es außer den Zahlen noch : 

• +inf 

• -inf 

• NaN 

das Ergebnis + Unendlich bei einem Überlauf 

das Ergebnis - Unendlich bei einem Unterlauf 

das Ergebnis „not a number“, wenn eine Operation kein sinnvolles Ergebnis 

haben kann, z.B. Division durch 0 oder Wurzel aus einer negativen Zahl. 

Ist x = 0, +inf oder -inf, so ist NaN*x=x 

Achtung: 

Es wird nie ein Fehler "Division durch 0" moniert! 

GhK 


Operationen auf reals 

• einstellig 

++ Inkrement x+1 

-- Dekrement x-1 

+, - Vorzeichen x , -x 

• zweistellig 

+, - plus, minus 

*, / mal, geteilt 

• boolean-wertig 

= =, != gleich, ungleich 

= Größenvergleich 

?: dreistelliges IF (b)?x:y = “falls b, dann x sonst y“

GhK 


real Literale 

• Die Gleitkommazahlen haben die Literaldarstellung: 

Vorzeichen Ziffernfolge ¦ Ziffernfolge Exponent Endung 

dabei sind 

optional 

• Vorzeichen § |¨ : 

• Exponent © : | Vorzeichen Ziffernfolge optional 

 

• Endung : | | | optional 

wenn ein Exponent vorkommt, ist auch der Dezimalpunkt 

optional. 

• Die Zahl 256.0172 hat also z.B. folgende Darstellungen: 

2560172E-4D, .2560172e3, 2.560172e2f, ... 

GhK 


Zeichenketten 

• Ein besonderer Datentyp in Java ist der String , der eine 

Folge von unicode-Zeichen darstellt. 

• Literale: Wie bei char werden Einzelzeichen und escapesequenzen 

in Folge notiert und die Folge in Hochkommata 

eingeschlossen. 

• Beispiele: “Ausgabe:\n“ , ‘dies ist ein langer String‘, ““ 

• Operationen: 

+ (Conkatenation) ‘Milch‘+‘Mann‘ steht für ‘ MilchMann‘ 

==, != (Identität, Vorsicht!!) 

length( ) (Länge) length(‘der Hund ist tot.\n‘) ist 18 

charAt( ) , equals( ) , compareTo( ) , IndexOf( ) , ...

GhK 


Referenztyp String 

• String ist kein elementarer Typ, obwohl er praktisch wie ein 

elementarer Typ behandelt wird. 

• Elementare Daten haben einen Speicherplatz fester Größe, 

in dem ihr Wert abgespeichert ist. 

Auch Strings haben einen Speicherplatz fester Größe, in 

dem steht aber nur eine Referenz (Verweis, Zeiger) auf 

den Speicherplatz, wo die Zeichenfolge abgelegt ist. 

• == und != fragen ab, ob zwei Strings auf denselben 

Speicherplatz verweisen. x!=y besagt also nicht notwendig, 

daß die Zeichenreihen verschieden sind, sondern lediglich, 

daß sie an unterschiedlichen Stellen abgelegt sind. Ob 

zwei Strings dieselbe Zeichenreihe sind, wird mit equals( ) 

überprüft. 

• Java achtet darauf , daß gleichlautende String Konstanten 

nicht mehrmals an verschiedenen Stellen abgelegt werden. 

GhK 


Spezielle Strings 

• null ist kein String, sondern allgemein ein leerer Zeiger, wo mal ein 

Verweis (z.B. auf einen String) hinein kann. 

• ‘‘ (bzw. ““) ist der leere String, d.h. der einzige String 

von Länge 0. 

• ‘ ‘(bzw. “ “) ist der String der Länge 1, der als einziges 

Zeichen das Leerzeichen ( space) enthält. 

• In String-literalen können alle Zeichen wie bei char verwendet werden: 

– alle druckbaren Ascii-Zeichen außer ‘ “ und \ . 

– Die Escape-Sequenzen: 

\n (neue Zeile) \t (tabulator) \b (Rückschritt) \r (Rücklauf) 

\f (neue Seite) \‘ ( Hochkomma) \“ (Quotation) \\ (Backslash) 

– Unicode-Zeichen : \uxxxx dabei ist xxxx eine Folge von 1 bis 4 

Hexadezimalziffern. 

• Strings sind im Wesentlichen unveränderlich. Eine Veränderung einer 

String-Variable kann nur dadurch erzeugt werden, daß man einen 

neuen String des gewünschten Inhalts erzeugt und dann die Variable 

darauf verweisen läßt.

GhK 


Java hat keine Zeiger 

Die Behauptung, Java habe keine Zeiger, ist in gewissem 

Sinn zwar richtig, aber im Grunde genommen völlig falsch. 

• Andere Programmiersprachen haben Zeiger, das sind 

Speicheradressen, die der Programmierer manipulieren 

kann. Letzteres geht in Java tatsächlich nicht. 

• Alle Datentypen (= Klassen) in Java, außer den 

elementaren Typen sind Referenztypen, also Zeiger auf 

eine entsprechend große Speicherstelle. In diesem Sinne 

ist Java ohne Zeiger also nicht denkbar. Der Unterschied 

zu anderen Programmiersprachen ist, daß die Speicherverwaltung 

aus Sicherheitsgründen jedem programmierten 

Zugriff entzogen ist. Alles was ein Java-Programm tun 

kann, ist Speicher anfordern und die zugeteilte Adresse im 

Zeiger ablegen. 

GhK 


Felder (Arrays) 

• Felder (arrays) sind Folgen von Daten, die alle denselben 

Typ T besitzen, das Feld wird dann mit T[] deklariert. 

String ist so ähnlich wie ein char array. 

• Auch Felder sind Referenztypen, also Zeiger auf einen 

Speicherbereich und werden bei der Deklaration T[] Name 

mit null (dem leeren Zeiger) initialisiert. 

• Beispiele: 

– int[] a; //deklariert ein int-Feld a 

– String[] b //deklariert ein String-Feld b 

– short[][] c //deklariert ein doppelt indiziertes 

short-Feld c

GhK 


Erzeugen von Feldern 

• Die Deklaration eines Referenztyps (z.B. Feld) erzeugt nur 

den Zeiger null, der noch auf nichts zeigt. Deshalb muß ein 

solcher Typ vor Gebrauch erst erzeugt werden, d.h. 

Speicher muß reserviert und die Adresse im Zeiger 

abgelegt werden. (Standardmethode new) 

• a = new int[5] 

a 0 0 0 0 0 

ein Feld von 5 integers wird erzeugt und jeder Eintrag mit 0 initialisiert. 

• double[] d = {1.1, 1.21, 1.331}; 

d 1.1 1.21 1.331 

ein Feld von 3 doubles wird deklariert, erzeugt und mit den angegebenen 

Werten initialisiert. 

• b = new String[] {“Die“, “Erzeugung“, “von“, “Feldern“}; 

ein Feld von Strings wird deklariert, erzeugt und mit den angegebenen 

Werten initialisiert. 

die Erzeugung von Feldern 

b 

GhK 


Zugriff auf Felder 

• Der Inhalt von Feldkomponenten kann angesprochen 

werden (zum Lesen oder zum Schreiben), indem man den 

Feldnamen A und in eckigen Klammern [] die Position i 

anspricht : A[i] 

• Die Positionen beginnen mit 0 und gehen bis length(A)-1 

• Beispiel: 

int[] x = new int [n] // auch Variable n ist zulässig 

for ( int i=0; i

GhK 


Speicherverwaltung 

• Aus Sicherheitsgründen übernimmt Java vollständig die 

Speicherverwaltung. 

• new : Der Nutzer (Programmierer) hat nur die 

Möglichkeit Speicherplatz für einen bestimmten Datentyp 

anzufordern. Die Speicheradresse (Zeiger) wird dann unter 

dem Namen des Datenelementes abgelegt. 

• elementar : Bei elementaren Datentypen wird für jedes 

Datenelement direkt der Wert (kein Zeiger) unter dem 

Namen abgelegt. 

• garbage collection: Wird ein Speicherbereich von seinem 

Programm nicht mehr referenziert, gibt Java selbständig 

den Speicherplatz wieder frei.

Programmieren mit Java Java-Referenzen

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?