JAVA - NetbeansJAVA - NetbeansMag. Stefan Hagmann

BG und BRG FrauengasseBaden

Diese(s) Werk bzw. Inhalt steht unter einer http://creativecommons.org/licenses/by-nc-sa/4.0/deed.de, d.h.• Sie müssen die Urheberschaft ausreichend deutlich benennen, einen Link zur Lizenz beifügen und angeben, ob

Änderungen vorgenommen wurden.• Alle ursprünglichen Autoren müssen als Rechteinhaber genannt werden.• Eine kommerzielle Nutzungen ist verboten• Die Abwandlungen und Bearbeitungen des Werkes bzw. Inhaltes ist erlaubt, solange andere unter denselben

Bedingungen das Werk weitergeben.

Threads

Aufgaben Verzeichnis(3.1) Mittelwert deiner Schulnoten....................................................................................................8(6.1) Antiker Taschenrechner..........................................................................................................15(6.2) Temperaturrechner.................................................................................................................15(6.3) Ostern berechnen..................................................................................................................15(7.1) Baybylonisches Wurzelziehen, Heronverfahren.....................................................................18(7.2) ggT mit dem Euklidschen Algorithmus...................................................................................18(7.3) Das Sieb des Erathostenes....................................................................................................18(8.1) Datums-Spielerein I................................................................................................................20(8.2) Datums-Spielerein II...............................................................................................................20(10.1) Fehler Erkennung.................................................................................................................23

1. Einleitung, Voraussetzungen

Um Java programmieren zu können, braucht man einige Voraussetzungen am eigenen Computer1. Java Runtime Umgebung2. JDK, Java Development Kit3. Netbeans als Editor

Jede Software ist über http://developers.sun.com/downloads/index.jsp zu beziehen.

Neben Netbeans kann man auch jeden anderen Editor verwenden. Erwähnt sei hier das Eclipse http://www.eclipse.org/ Projekt.

Um ein Java-Programm auszuführen, benötigt man am Computer die JR (Java Runtime). Da es die JR für alle Betriebssysteme gibt, kann man Java-Programme auf jedem BS ausführen.

Seite -1-

2. Editoren IDE's

Im folgenden wird beschrieben, wie man die verschiedenen gängigen Editoren zum Arbeiten bringt. Netbeans arbeitet mit der SWING (SAF, swing application framework) Oberfläche, die momentan (2010) nicht mehr weiterentwickelt wird. Eine Alternative wäre BSAF, better swing application framework.Eclipse hingegen, arbeitet mit der SWT Oberfläche.

2.1. Eclipse

Beachte: Das JDK muss bereist installiert sein. Herunterladen von: http://www.eclipse.org/

Eclipse muss nicht installiert werden, einfach aus dem Ordner heraus starten. Bevor man startet sollte man folgendes tun

1. Eclipse herunterladen und entpacken, die IDE for JAVA Developers reicht hier.2. Deutsches Sprachpaket laden, vom Babel Projekt

http://www.eclipse.org/babel/downloads.php (hier findet man alle Sprachen). Suche dir dort folgendes Paket BabelLanguagePack-eclipse-de_3...Auch entpacken, und in den Ordner von Eclipse kopieren.

3. Um mit SWT arbeiten zu können, noch SWT herunterladenvon http://download.eclipse.org/eclipse/downloads/. Dortdas letzte Release auswählen, und SWT Binariesherunterladen.

4. SWT (als zip File) Importieren mit Datei Importieren Allgemein Vorhandenes Projekt im Arbeitsbereich, danndas Zip File Auswählen und Fertigstellen. Wir erhalten imProjektbereich dieses Projekt, und können dmit arbeiten.

5.

2.2. Die Netbeans Oberfläche

Beachte: Das JDK muss bereist installiert sein.Herunterladen von : http://netbeans.org/

Netbeans wird einfach installiert, und fertig.

Mag. Stefan Hagmann

Seite -2-

Netbeans zeigt alle Projekte in einemeigenen Fenster an. Hier kann man die Projekte einsehen und komfortabel verwalten. Links siehst ein Beispiel, wie das aussehen kann.

Oft ist es hier verwirrend, wenn man ein bereits bestehendes Projekt importieren möchte.

Es ist nicht der Befehl Open Project.Den verwendet man nur, wenn das Projekt mit dem Befehl Close geschlossen wurde (erkennbar am Icon Kaffeehäferl ). Wenn ein

anderes Projekt aufgenommen werden soll, geht man wie folgt vor:• Neues Projekt• Java Project with existing Source

• Dann die bestehenden Quellen des src Ordners angeben. Und dann wird das Projekt importiert.

3. Grundlagen

3.1. Das erste Programm

Der Haupteinstiegspunkt liegt in der Methode main. Dort lassen wir den üblichen ersten Text ausgeben „Hallo Java“.

public class Main { public static void main(String[] args) { System.out.println("Hallo Java"); }}

Mag. Stefan Hagmann

Seite -3-

Mit dem Editor Netbeans drückt man nun die Taste F6 (Run Main Project) und sieht die Ausgabe im unteren Teil des Programms.

3.2. Starten des Programm's über die Konsole

Manchmal möchte man ein Programm auch über die Konsole starten. Dazu muss man java.exe aufrufen, das gelingt aber nur, wenn man den Pfad kennt.Nehmen wir an, der Pfad zur java.exe liegt in C:\Program Files (x86)\Java\jre6\bin\. Man kann nun in Windows den Pfad permanent setzen (Systemsteuerung, u.s.w.), oder man erstellt sich ein Batch File, und setzt den Pfad bei Bedarf.Im Batch File steht folgendes

@echo offecho JAVA Consoleecho Prepending 'C:\Program Files (x86)\Java\jre6\bin\' to PATHPATH=C:\Program Files (x86)\Java\jre6\bin\;%PATH%

StartJavaConsole.bat

Dann legt man sich eine Verknüpfung an, die folgendes startet

C:\Windows\System32\cmd.exe /k "StartJavaConsole.bat"

Wie man erkennen kann, wird zur Laufzeit der Pfad zur java.exe gesetzt, und ab jetzt kann man sein Programm direkt starten.

Man kann auch den obigen Schritt oft weglassen, und das Programm so starten

java -Xms1024M -Xmx1536M -jar MyFoto2Web.jar

Die Parameter werden später in 22. Virtuelle Maschine VM erklärt.

Auf Linux PC's kann man z.B. so starten

Mag. Stefan Hagmann

Seite -4-

#!/bin/bashjava -Xms1024M -Xmx1536M -jar MyFoto2Web.jar

3.3. Die Struktur der Dateien

Welche Verzeichnisstruktur mit welchen Dateien erhalte ich nun? Schauen wir uns dazu die Verzeichnisstruktur genauer an.

Das erste Programm erzeugt nebenstehende Verzeichnisstruktur. build: beinhaltet die *.class Dateiensrc: beinhaltet die *.java Dateien

die anderen Ordner sind momentan nicht von Interesse für uns.

Die *.java Dateien sind die Quellcode Dateien, während die *.class Dateien die bereits compilierten Dateien darstellen, die dann von der JR interpretiert werden.

Wird das Projekt mit build ausgeführt (F11), erhält man eine *.jar Datei. Das ist im Prinzip eine zip-Datei in der alle *.class Dateien liegen. Starten kann man das Programm dann anschließend mit java -jar Console1.jar. Für Windows gibt es einige Tools um aus *.jar Files *.exe Dateienzu machen, z.B. JSmooth.

Ein Package hingegen beinhaltet viele *.java Dateien, und dient als eine Art Bibliothek. Packages können beliebig oft von anderen Anwendungen verwendet werden.

3.4. Klassen und Packages

Packages beinhalten Sammlungen von Klassen. Will man solche Klassen in seinem Programm verwenden, muss man diese mit dem import Befehl importieren. Zum Beispiel die String Klasse beinhaltet alles, was zum Arbeiten mit Strings nötig ist. Diese Klasse befindet sich im Package java.lang. Also importiert man diese Klasse mit

import java.lang.String;

Möchte man alles aus dem Package importieren, schreibt man einfach

import java.lang.*;

3.5. Variablentypen

Folgende Variablentypen haben wir in JAVA.

Type Range

byte -128 to +127

short -32,768 to 32,767

Mag. Stefan Hagmann

Seite -5-

int -2,147,483,648 to 2,147,483,647

long -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Andere Typen

Type Approximate range Precision

float -3.4 × 10-38 ... +3.4 × 1038 7 digits

double -1.7 × 10-308 ... +1.7 × 10308 15-16 digits

char 0 to 65535 Unicode Zeichen

bool true oder false

Wie legt man nun Variable an, z.B. so

Variablentyp Name;int x; /*Variable nicht initialisiert*/int x = 2; /*initialisiert*/

String was = "Hallo Welt";Char x = 'C';float fltValue = 0.123456789;boolean myBool = true;

Für die Bezeichnung von Variablen muss man sich an gewisse Regeln halten. Ein Bezeichner in Java kann beliebig lang sein und alle Stellen sind signifikant. Er muss mit einem Unicode-Buchstaben beginnen (d.h. 'A' bis 'Z', 'a' bis 'z', '_' und '$') und darf dann weitere Buchstaben und Ziffern enthalten. Es können auch Buchstaben aus anderen Landessprachen enthalten sein, allerdings darf es zu keinen Kollisionen mit reservierten Schlüsselwörtern kommen:

abstract default if private throw

boolean do implements protected throws

break double import public transient

byte else instanceof return try

case extends int short void

catch final interface static volatile

char finally long super while

class float native switch

const for new synchronized

continue goto package this

Die Literale true, false und null dürfen ebenfalls nicht als Bezeichner verwendet werden.

Mag. Stefan Hagmann

Seite -6-

3.6. Konvertierung von Zahlentypen

Ein Standardproblem ist es, einen Zahlentyp in einen anderen über zuführen. Man kann hier unterscheiden zwischen automatischer Konvertierung und expliziter Konvertierung.

int x = 4711;double y;y=x;System.out.println(y);

Automatische Konvertierung int > double

int x,y;short z;x=10;y=20;z= (short)(x+y);System.out.println(z);

Explizite Konvertierung int > short mit Hilfe des Type-Cast-Operators (siehe 4.1.2)

3.7. String zu Zahlentyp

Wie funktioniert das?

String zahl = "12.34";double erg = Double.parseDouble(zahl) ;

Double ist ein ein Objekt und beherrscht verschiedenste Methoden die zu diesem Zahlentyp passen. Beachte den unterschied zwischen double und Double!

Aufgaben:(3.1) Mittelwert deiner SchulnotenBerechne den Mittelwert deiner Schulnoten. Gib im Anschluss das Ergebnis als double, float, int sowie String aus!

4. Tastatur einlesen und formatierte Ausgabe

4.1. Einlesen der Tastatur

Mit der passenden Klasse ist alles ganz einfach.

Scanner s = new Scanner(System.in);int x = s.nextInt();String msg = s.next();

Mag. Stefan Hagmann

Seite -7-

oder so geht es auch … nur etwas allgemeiner gehalten

import java.io.*;

private String ReadLine(){BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

String s =""; try { s = in.readLine(); } catch(IOException ex){ return ""; } return s;}

Der BufferedReader übernimmt für uns die Aufgabe das Ende der Eingabe zu suchen. Arbeitet man mit System.in.Read() erhält man bloß ein Char[] und muss sich selbst um das Auslesen der gesamten Eingabe kümmern. Die IOException ist ein Fehler beim Auslesen des Tastatur Datenstroms (vergl. dazu Kapitel 10. Fehlerbehandlung mit Exceptions).

4.2. Formatierung der Systemstandardausgabe

Nachdem man über System.out.println zwar schnell und komfortabel eine Ausgabe erzeugen kann, findet man aber keine Möglichkeiten, diese Ausgabe ordentlich zu formatieren.

In den Klassen String und PrintStream gibt es dafür die Methode format().

for(int i=5; i < 199; i += 45){ System.out.format(„Aktueller Wert: %3d%n“, i);}

Die Angabe %3d%n erzwingt eine Ausgabe einer 3-stelligen Ganzzahl und anschließendem Zeilenvorschub.

Optionen

b Boolescher Wert

c Einzelnes Zeichen

d, o, x Ganzzahl in Dezimal-, Oktal- bzw. Hexadezimaldarstellung

X Darstellung in Hexadezimaldarstellung nur mitgroßen Buchstaben

f Gleitkommazahl

e, E Gleitkommazahl mit Exponent bzw. mit großem „E“

g, G Gleitkommazahl in gemischter Schreibweise bzw. mit großem „E“

Mag. Stefan Hagmann

Seite -8-

Optionen

t Präfix für Datums-/Zeitangaben, wobei anschließend angegeben werden muss, welcher Teil des Date- bzw. Calendar-Objektes angegeben wird (H,M,S,d,m,Y,F,c)

s Strings und andere Objekte

Man sollte allerdings genau auf Typenkonformität achten!

Einige weitere Beispiele:

//Boolesche WerteSystem.out.format("%b %b %2$b %1$b%n", true, false);

//GanzzahlenSystem.out.format("[%d]%n", -2517);System.out.format("[%7d]%n", -2517);System.out.format("[%-7d]%n", -2517);System.out.format("[%(7d]%n", -2517);System.out.format("[%07d]%n", -2517);System.out.format("[%,7d]%n", -2517);System.out.format("%1$d %<o %<x %<X%n", 127);

//FliesskommazahlenSystem.out.format("%f%n", 0.000314);System.out.format("%1$6.2f %1$6.2e %1$6.2E %1$6.2G%n", 3.141592);System.out.format("%,8.2f%n", 31415.92);System.out.format(Locale.ENGLISH, "%,8.2f%n", 31415.92);

//Zeichen und StringsSystem.out.format("%c%c%c\n", 97, 64, 98);System.out.format("%s nein\n", "ja");//Datum/UhrzeitCalendar now = Calendar.getInstance();System.out.format("%1$td.%1$tm.%1$tY %1$tH:%1$tM:%1$tS%n",now);System.out.format("%tF%n", now);System.out.format("%tc%n", now);

5. Methoden – functions

Wichtig ist die Unterscheidung ob Methoden mit oder ohne Rückgabewert erstellt werden. Eine explizite Unterscheidung ist hier nötig.

/** * Eine öffentliche Methode ohne Rückgabewert */ public void Meinefunktion(){ }

Mag. Stefan Hagmann

Seite -9-

Wenn kein Rückgabewert existiert, schreibt man das Schlüsselwort void!

/** * Eine private Methode * @return die Zahl 12 */ private int Meinefunktion2(){ return 12; }

Mit einem Rückgabewert muss der Typ des Wertes angeschrieben werden, hier int also Integer.

6. Kontrollstrukturen

6.1. Operatoren

Math. Operatoren Aktion

+= i += 10 entspricht i = i + 10

-= i -= 10 entspricht i = i – 10

+ Plus

- Minus

* Mal

/ Division

% Modulo (berechnet Rest der Division)

++ i++ entspricht i=i+1

-- i-- entspricht i=i-1

Vergleichsoperatoren

== Gleich

!= Ungleich

> Größer

< Kleiner

>= Größer oder gleich

<= Kleiner oder gleich

Logische Operatoren

&& UND (beide Ausdrücke müssen wahr sein)

|| ODER incl (mind. 1 Ausdruck muss wahr sein)

^^ ODER excl (genau nur 1 Ausdruck darf wahr

Mag. Stefan Hagmann

Seite -10-

Vergleichsoperatoren

sein)

bitweise Operatoren

<< bitweises verschieben nach links

>> bitweise Operatoren

Zuweisungsoperatoren

= Einfache Zuweisung

+= Additionszuweisung

-= Subtraktionszuweisung

*= Multiplikationszuweisung a*=b äquivalent mit a= a*b

/= Divisionszuweisung a/=b äquivalent mit a= a/b

%= Modulozuweisung

&= UND-Zuweisung a&=b weist a den Wert a & bzu

|= ODER-Zuweisung

^= Exklusiv-ODER- Zuweisung

<<= Linksschiebezuweisung

6.2. If - Abfragen

Dient dazu Fälle zu unterscheiden. Üblicherweise gibt es nur 2 Möglichkeiten

if (<Anweisung>){ …}else{ …}

Wenn die Anweisung eintritt, wird der if Bereich ausgeführt. Tritt die Anweisung aber nicht ein, der else Bereich.Hier ein Beispiel

if (zahl1<zahl2){ System.out.println("Die Zahl {0} ist größer als die Zahl {1}", zahl2, zahl1);}else{ System.out.println("Die Zahl {0} ist größer als die Zahl {1}", zahl1, zahl2);}

Mag. Stefan Hagmann

Seite -11-

Wie können Anweisungen aussehen, in etwa so

zahl1 == zahl2zahl1 ist gleich zahl2?

zahl1 != zahl2zahl1 verschieden zahl2?

zahl1 % zahl2 == 0zahl1 modulo zahl2 gleich Null?

(x ==1 ) && (y != 1)x gleich 1 UND y verschieden zu 1?

Ausdruck1 || Ausdruck2Boolscher Ausdruck1 oder Ausdruck2

Es ist auch möglich, eine Kurzschreibweise zu schreiben

if (x<10){ y = 1;}else{ y = 0;}

wird zu

y = x<10 ?1:0;

6.3. Switch – Anweisung

Die switch Anweisung ersetzt viele verschachtelte If Anweisungen. Die Syntax sieht wie folgt aus

switch (<Ausdruck>){

case <Konstante_1>://Anweisungen

break;case <Konstante_2>:

//Anweisungenbreak;u.s.w

}

Als Beispiel wollen wir die Note eines Schülers abfragen

int Note = …;switch (Note){ case 1: System.out.println("Sehr gut"); break; case 2: System.out.println("Gut");

Mag. Stefan Hagmann

Seite -12-

break; case 3: case 4: case 5: System.out.println("Auch nicht schlecht!"); break; default: System.out.println("Nix gefunden"); break;}

Wie hättest du diese Abfrage mit if-Anweisungen erstellt? Überlege!

Aufgaben:(6.1) Antiker TaschenrechnerErstelle ein Konsolenprogramm, das den Benutzer nach der Art der Rechenoperation fragt, dann nach der Angabe von zwei Zahlen. Im Anschluss wird die Rechenoperation ausgeführt, und das Ergebnis ausgegeben (lies dazu das nächste Kapitel).

(6.2) TemperaturrechnerErstelle ein Konsolenprogramm, das den Benutzer ermöglicht zwischen den Temperatureinheiten °C, F und Kelvin umzurechnen.

(6.3) Ostern berechnenErstelle ein Konsolenprogramm, das für eine Jahreszahl das Osterdatum berechnet (siehedazu Wikipedia...)

7. Schleifen

Schleifen sind ein wichtiges Instrument beim Programmieren. Sie haben die Aufgabe gewisse Befehle solange zu wiederholen, bis ein Ziel erreicht worden ist. Welchen Schleifentyp man verwendet ist an und für sich egal.

7.1.1. For-Schleife

Die Syntax sieht wie folgt aus

for (Variable; Bedingung; Weiterschalten){

//Anweisungen}

Solange die Bedingung erfüllt ist, zählt die Schleife in der Variable mit Weiterschalten weiter.

Mag. Stefan Hagmann

Seite -13-

for (int i=0; i<=101; i++){ System.out.println("Hallo das ist Satz Nr. "+ i);}

Solange wie i kleiner oder gleich 101 ist, wird in Einserschritten i++ weiter gezählt und die Anweisungen ausgeführt. Mit dem break Befehl kann man auch vorzeitig eine Schleife verlassen.

for (int i=0; i<=101; i++){ if (i==99) { break; /*Beenden der Schleife*/ } System.out.println("Hallo das ist Satz Nr. "+ i);}

7.1.2. verbesserte for-Schleife, foreach

Diese Version erleichtert das Iterieren über alle Elemente in einem Array oder in anderen Arten vonCollections. Da diese Anwendung eigentlich die häufigste darstellt, erweist sie sich als äußerst nützlich.

for(String name:arrayName){ // tu irgendwas }

Die Stringvariable name dient hier als Iterationsvariable, in der die einzelnen Werte aus dem Arrayfür die weitere Verarbeitung im Anweisungsteil der Schleife aufgenommen werden. Die Elemente des Arrays müssen mit dem Variablentypen von Name übereinstimmen. Bei jeder Iteration wird einneues Element aus dem Array aufgenommen. ArrayName steht für das Array oder die Collection, die durchforstet werden soll.

7.1.3. while - Schleife

Die Syntax sieht wie folgt aus

while (<Bedingung>){

//Anweisungen}

Schauen wir uns dieses Beispiel an

int intVar = 0;while (intVar < 5){ intVar++; if (intVar == 3) break; System.out.println(intVar);}

Wie man sehen kann, muss außerhalb der Schleife eine Zählvariable intVar definiert werden. Innerhalb der Schleife muss man diese Variable weiter zählen. Gerne vergisst man das, und erzeugt damit ungewollt eine Endlosschleife.

Mag. Stefan Hagmann

Seite -14-

7.1.4. break

Mit break kann man eine Schleife (for, while,do aber auch switch) vorzeitig verlassen.

for(int i = 0; i < a.length; i++) { if (a[i] == 0){ break; }}

Mit break ist es auch möglich, die Ausführung nach dem Abbruch hinter einem übergeordneten Programmblock fortzusetzen. Hierzu muss dem betreffenden Programmblock eine Marke vorangestellt werden, die dann bei der break-Anweisung angegeben wird.

demo: { index = 0; while(index < a.length) { if (a[index++] == -1){ break demo; }}

Mag. Stefan Hagmann

Seite -15-

Aufgaben:(7.1) Baybylonisches Wurzelziehen, HeronverfahrenErstelle ein Konsolenprogramm für die Berechnung einer Quadratwurzel.◦ Lass alle Schätzwerte auf 6 Dezimalstellen genau ausgeben◦ Der Benutzer kann den Wert unter der Wurzel eingeben (auch Kommazahl möglich)◦ Überlege dir, wie oft die Schleife ablaufen soll und wann ein sinnvolles Ende erreicht

ist!

(7.2) ggT mit dem Euklidschen AlgorithmusErstelle ein Konsolenprogramm für die Berechnung des ggT von zwei Zahlen◦ siehe dazu http://de.wikipedia.org/wiki/Euklidischer_Algorithmus◦ Erstelle zwei Versionen, eine mit einer for-Schleife, die andere mit einer while-Schleife

Berechne im Anschluss auch das kgV der beiden Zahlen (hängt mit dem ggT zusammen, siehe Wikipedia)

(7.3) Das Sieb des ErathostenesErstelle ein Konsolenprogramm für die Berechnung der Primzahlen von 1-100◦ Verwende die klassische Methode des Erathostenes◦ Erweitere dein Programm dahingehend, dass das Ende eingeben werden kann z.B.

bis 1000◦ Verwende den Typ BigInteger, z.B:

BigInteger n = new BigInteger("1233");n.isProbablePrime(10);

Die Wahrscheinlichkeit, dass n eine Primzahl ist, würde hier bei 1−1

210 liegen.

8. Datum und Zeit

Wenn man einen Zeitstempel benötigt, verwendet man die date-Klasse (java.util.Date). Es dient eigentlich zum Speichern eines Datum-/Zeitwertes (als 64-Bit-Long-Variable) in ms (Millisekunden)seit 1970-01-01 0h UTC (negative Werte sind vor 1970).

// Aktuelles DatumDate dt = new Date();// z.B. 'Fri Jan 26 19:03:56 GMT+01:00 2001'System.out.println( "Date = " + dt ); // Ausgabe der ms = TimestampSystem.out.println( "ms = " + dt.getTime() ); // lokales Kalendersystem mit aktueller ZeitCalendar myCal1 = Calendar.getInstance(); // GregorianCalendar mit aktueller ZeitCalendar myCal2 = new GregorianCalendar(); // GregorianCalendar mit vorgegebener ZeitCalendar myCal3 = new GregorianCalendar(1956,Calendar.MARCH,17);

Mag. Stefan Hagmann

Seite -16-

// Setzen von Jahr + Monat + TagmyCal2.set( 1956, Calendar.MARCH, 17 );

myCal2.setTime( myCal2.getTime() ); // Zeit setzen mit DatemyCal2.setTime( new Date() );// Einzelne Felder extrahierenint year = myCal2.get( Calendar.YEAR );// nicht vergessen die 1 zu addierenint mnth = myCal2.get( Calendar.MONTH ) + 1; int date = myCal2.get( Calendar.DATE );// für Formatierung ist SimpleDateFormat besser System.out.println( date + "." + mnth + "." + year ); SimpleDateFormat format = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");datum = format.parse(dstr);// Calendar ist gut geeignet, um Berechnungen durchzuführen,// z.B. um den um ein Jahr erhöhten Zeitwert zu berechnen:myCal2.add( Calendar.YEAR, 1 );// Umwandlung von Calendar in Date:Date myDate = myCal2.getTime();System.out.println( myDate );

Methoden der Calendar-Klasse

set Um die Zeit auf einen bestimmten Wert zu setzen Beispiel: cal.set(2009,3,29,10,00)

add Um zB. 35 Tage zum Datum zu addierencal.add(c.DATE,35)

roll Datum um 35 Tage „rollieren“(vordrehen), Monat belibt unverändert

SetTimeInMillis, getTimeInMillis

das Datum in Millisekunden umwandeln

get Auslesen von Teilinformationen (YEAR, MONTH, DAY_OF_MONTH, DAY_OF_WEEK, HOUR_OF_DAY , MINUTE , SECOND

Mag. Stefan Hagmann

Seite -17-

Aufgaben:(8.1) Datums-Spielerein IErstelle ein Konsolenprogramm für die Berechnung von◦ die Anzahl der Tage bis zum Schulende z.B. 1.6.2013◦ Wie lange dauert es in Tagen bis Ostern ist (du benötigst die Osterdatumsberechnung

aus (6.3) Ostern berechnen)◦ Addiere zu einem Datum 12 Tage und gib es aus.

(8.2) Datums-Spielerein IIErstelle ein Konsolenprogramm für die Berechnung von◦ allen Schaltjahren von jetzt bis zum Jahr 2200 (siehe dazu Wikipedia)

9. Eigene Packages erstellen

Oft programmiert man Routinen, die man wiederverwenden möchte. Stell dir Methoden vor, die aufKnopfdruck z.B. die Fläche von Rechtecken, Parallelogrammen oder Trapezen berechnet. Warum soll man diese Methoden jedes mal neu programmieren wenn man sie benötigt. Hier kommt das Package ins Spiel. Ein Package ist eine Sammlung von Routinen, die man jederzeit wiederverwenden kann.Das Erstellen ist ganz einfach. Wichtig zu wissen ist, das jedes Package ein eigenes Unterverzeichnis haben muss.

Durch einen einfachen Rechtsklick auf SourcePackages kann man neue Packages erstellen (hier MathPackage).Ein Package kann viele *.java Quelldateien beinhalten.

Die *.java Datei beinhaltet als erste Zeile

package MathPackage;

sonst programmiert man wie gewohnt.

Wenn man nun das Package verwenden möchte, muss man das Package mit dem import Befehl eingliedern (vergleich dazu auch 3.4. Klassen und Packages). Ab dann kann man auf alle Methoden und Variable zugreifen (beachte die Zugriffsmodifizierer wie public, private).

package testpackages;import MathPackage.Vierecke;

Mag. Stefan Hagmann

Seite -18-

public class Main { public static void main(String[] args) { Vierecke veck = new Vierecke(); System.out.println("Verwendung eines externen Packages ..."); double fl = veck.Flaeche_Rechteck(12, 14); System.out.println("Fläche eines Rechteckes: " + fl); }}

Im Umgang mit Paketen sollte man ein paar Regeln beachten:

1. Was zu einem Paket gehört ist außerhalb unsichtbarDiese Regel hat den Zweck, dass man in verschiedenen Paketen dieselben Namen verwenden kann. Man muß bei selbst entwickelten Paketen nur darauf achten, dass es zu keinen Namenskollisionen innerhalb des Paketes kommt. Man sollte sicherstellen, dass dieeigenen Klassen nur von berechtigten Methoden und Klassen gesehen und manipuliert werden können.

2. Namen können von einem Paket exportiert werdenMit dem Zusatz public können Klassen, Methoden, Felder und Konstruktoren exportiert werden, nicht jedoch Parameter oder lokale Variablen. Eine exportierte Methode ist in anderen Paketen nur dann sichtbar, wenn auch die zugehörige Klasse exportiert wurde.

3. Exportierte Klassen können in anderen Paketen importiert werden

Packages sind nichts anderes als Unterverzeichnisse im Java Projekt. Sie können daher auch mit einem Dateimanager jederzeit kopiert werden. Netbeans erkennt dann die neuen Packages und wird diese korrekt darstellen.

10. Fehlerbehandlung mit Exceptions

10.1. Exceptions

Exceptions sind Fehler, Ausnahmen die in einem Programm passieren. Üblicherweise stürzt das Programm dann ab. Ein gutes Programm tut das allerdings nicht, nur muss der Programmierer diese Fehler auffangen und behandeln. Als Beispiel nehmen wir dieses Programm

double erg;erg = 100/0;

Mag. Stefan Hagmann

Seite -19-

Das Programm muss abstürzen, da eine Division durch 0 nicht gestattet ist. Exeptions werden immer dann ausgelöst, wenn im Programmfluss ein Fehler auftritt. Im Regelfall stürzt das Programm mit einer Fehlermeldung ab (bekannt von Windows). Der fleißige Programmierer kann aber solche Fehler abfangen und darauf reagieren, und somit das Programm vor Abstürzen schützen.Klingt kompliziert? Ist es nicht. Schauen wir uns den folgenden Programmcode an

int zahl=0;boolean err = false;try{

zahl = (int) zahl;}catch (ArithmeticException ex){ System.out.println("Bitte IRGENWAS eingeben!" + ex.getMessage()); err = true;}catch(Exception ex2){ System.out.println("Allgemeiner Fehler" + ex.getMessage()); err = true;}finally{

System.out.println("finally wird IMMER ausgeführt");if (!err) System.out.println(zahl);

}

Für jeden Fall eines Fehlers gibt es im Allgemeinen einen eigenen Exceptiontyp. Welchen Typ manabfragen kann, findet man in der Hilfe des Programms. Üblicherweise fängt man Fehler in einem try catch Block ab.Passiert im try Block ein Fehler, geht das Programm zum entsprechenden catch Block über, und arbeitet dort weiter. Man kann hier beliebig viele catch Blöcke definieren. Das Programm stürzt nun nicht mehr ab, und arbeitet weiter.Der finally Block wird auf jeden Fall ausgeführt.

10.1.1. throws im Methodenkopf angeben

Neben dem üblich try-catch Statements, kann man auch im Kopf der betreffenden Methode eine throws-Klausel einführen. Dadurch stürzt die Methode nicht mehr ab, sondern gibt den Fehler an die aufrufende Instanz weiter. Die aufrufenden Instanzen können dann auf den Fehler reagieren.

static double Division(double zahl) throws ArithmeticException, Exception{ return zahl/0;}try{ Division(100.1);}catch(ArithmeticException ex){ System.out.println(ex.getMessage());

Mag. Stefan Hagmann

Seite -20-

}catch(Exception ex){ System.out.println(ex.getMessage()); ex.printStackTrace();}

Im obigen Beispiel sieht man, das die Methode nicht auf etwaige Exceptions reagiert, sondern diese mit dem throw Befehl weitergibt. Der throw Befehl ermöglicht es, manuell Exceptions auszulösen, z.B. so:

throw new ProtocolException();

Aufgaben:(10.1) Fehler ErkennungErstelle ein Konsolenprogramm, dass◦ die Eingabe einer Jahreszahl verlangt. Fehlerhafte Eingaben erkennt und auswertet,

z.B. du tippst Hallo ein◦ die Eingabe eines Bruches ermöglicht, also z.B. 2 3 liefert 2/3 oder 0.66666. Die

Eingabe sind also Integer Zahlen, alle anderen Fehler werden abgefangen.◦ die Eingabe eines Dateinamens der Form NAME.EXTENSION verlangt. Fehlerhafte

Eingaben werden abgefangen, zusätzlich MUSS noch eine Extension aus genau 3 Zeichen bestehen.

11. Speicherstrukturen

11.1. Arrays

Werden wie in php folgendermaßen definiert, Typ[] Name.

int[] chessboard; Point[][] points;

Mit Inhalten befüllt wird ein Array so

int[] prim = { 1, 2, 3, 5, 7, 7 + 4, }; String[] nouns = { "Haus", "Maus", "dog".toUpperCase(), /*DOG*/ new java.awt.Point().toString() };

Zugriffe geschehen über eine Indexnummer

Mag. Stefan Hagmann

Seite -21-

int[] zahlen = { 1, 2, 3, 5, 7, 7 + 4, }; System.out.println( zahlen.length );System.out.println( zahlen[0]); System.out.println( zahlen[3]);

Arrays mit bestimmter Länge erzeugen

int[] zahlen = new int[100];//erzeugt ein Array, das mit 100 Stellen, die jeweils mit dem Integer 0 initialisiert werden

Auch mehrdimensionale Arrays sind Standard wie folgendes Beispiel zeigt

zahlen[3][0] = 1;zahlen[1][3] = 4;

Wobei es hierbei im Gegensatz zu vielen Programmiersprachen auch möglich ist, nichtrechteckige Arrays zu erzeugen. Dies liegt daran, dass mehrdimensionale Arrays als verschachtelte Arrays gespeichert werden.

/*Beispiel für ein dreieckiges Array*/int[][]a ={{0},

{1,2},{3,4,5},{6,7,8,9}};

11.2. Dynamische Listen – Container

Da man oft nicht weiß wie viele Elemente gespeichert werden sollen, sind Arrays hier ein Problem. Bei dynamischen Listen können jeder Zeit Elemente gespeichert und gelöscht werden. Die Anzahl der Elemente muss nicht beachtet werden.

Schauen wir uns ein Beispiel an

import java.util.*;

public static void main( String[] args ) { Collection c = new LinkedList<Integer>(); for ( int i = 0; i < 5; i++ ) c.add( "" + i ); System.out.println( c ); }

Der Typ Collection erlaubt es beliebig viele Elemente zu speichern.

Es stehen auch einige Methoden zur Verfügung:

Methoden für ArrayLists

add(Object elem) Fügt der Liste das Object elem hinzu

Mag. Stefan Hagmann

Seite -22-

remove(int index) Entfernt das Objekt mit dem angegebenen Index

remove(Object elem) Entfernt dieses Objekt, falls vorhanden

contains(Object elem) Liefert true falls vorhanden

isEmpty() Liefert true, falls die Liste keine Elemente enthält

indexOf(Object elem) Liefert den Index des Elements oder -1

size() Liefert die Anzahl der Elemente

get(int index) Liefert das Object mit angegebenem Index

Zu keiner Zeit braucht man sich Gedanke über die Anzahl der Element Gedanken machen. Die Syntax

Collection c = new LinkedList<Integer>();

oder LinkedList<Double> koord = new LinkedList<Double>();

gibt an, das ausschließlich Integer Typen in der Collection gespeichert werden.

Als Containerklassen für Collections kommen die ArrayList und die LinkedList in Frage. Der Zugriff auf eine ArrayList ist schneller, während alle Elemente in der LinkedList untereinander verkettet sind, was das Behandeln der Reihenfolge einfacher macht. Weiters gibt esdas HashSet, TreeSet, LinkedHashSet, HashMap, TreeMap, LinkedHashMap, WeakHashMap, LinkedList, ArrayBlockingQueue und PriorityQueue. Bitte hier in der Dokumentation nachlesen!

11.3. Strings

Wie schon vorhin erwähnt benötigt man zum Arbeiten mit Strings die entsprechende Klasse aus dem java.lang-Package.

Eine neue Stringvariable deklariert man nun folgendermaßen:

String test = new String();//eine leere Zeichenkette wird erzeugt;

Man kann nun diese Variable auch gleich mit einer Zeichenkette initialisieren:

String s = new String("Heute ist ein schöner Tag!");

11.3.1. Initialisierung durch char-Arrays

Zur Klasse String gibt es einen Konstruktor, der die Inhalte eines Arrays in eine Zeichenkette überträgt:

Mag. Stefan Hagmann

Seite -23-

char text[] = {'I','n','f','o','r','m','a','t','i','k'};String s = new String(text);

Durch die Angabe des Index und der Anzahl der Zeichen werden die Zeichen teilweise aus dem Array übernommen:

char text[] = {'I','n','f','o','r','m','a','t','i','k'};String s = new String(text,2,4);System.out.println(s);

Als Ausgabe erhalten wir erwartungsgemäß „form“.

11.3.2. Stringmethoden

Die Klasse String liefert einige Methoden, die den Umgang mit Strings erleichtern.Um die Länge einer Zeichenkette zu ermitteln:

String s = new String("Heute ist ein schöner Tag!");System.out.println(s.length());

Um ein Zeichen an einer bestimmten Stelle auszugeben:

System.out.print(s.charAt(5));

Weitere wichtige Methoden:

Stringmethoden

getChars() Auswahl einer zusammenhängenden Zeichenkette mit Startindex bis Endindex wirdin eine Array geschrieben, beginnend mit dem Index start_ergebnis

getChars(int start, int ende, charergebnis[], int start_ergebnis)

indexOf() Liefert die Position des ersten Auftretens des angegebenen Zeichens (bzw. Zeichenkette)

substring() Liefert eine Teilzeichenkette mit Startindex und Endindex

replace() Ersetzt in einer Zeichenkette ein bestimmtes Zeichen durch ein anderesreplace( char alt, char neu)

trim() Entfernt vorangehende und anschließende nicht druckbare Zeichen

11.3.3. Operatoren für Zeichenketten

Man kann mehrere Zeichenketten mit Hilfe von concat() verketten:

Mag. Stefan Hagmann

Seite -24-

String s1 = new String("BRG");String s2 = new String("Frauengasse");System.out.println(s1.concat(s2).concat("!"));

Um Zeichenketten und Variablenwerte nebeneinander zu verwenden, verkettet man diese mit „+“:

int a = 10;int b = 20;System.out.println(a + " + " + b + " = " + a + b);System.out.println(a + " + " + b + " = " + (a + b));

Man beachte die unterschiedlichen Ausgaben. Um vor der Verkettung Berechnungen auszuführen (wie hier z.B. a+b ), muss man Klammern verwenden, da sonst das „+“ als Verkettungsoperator interpretiert wird.

Man kann 2 Zeichenketten mit Hilfe der Methode equals() auf Gleichheit überprüfen. Die Ausgabe liefert Boolesche Werte.

String s = new String("hallo");System.out.println(s.equals("hallo"));

Sonstige Vergleichsmethoden

equalsIgnoreCase() Beim Vergleichen wird Groß/Kleinschreibung igoriert

startsWith() Überprüft ob ein String mit einer bestimmten Zeichenkette beginnt

endsWith() Überprüft ob ein String mit einer bestimmten Zeichenkette endet(Ergebnis:Boolescher Wert)

compareTo() Überprüft neben der Gleichheit der Zeichenketten die alphabetische Abhängigkeiten (vgl. Wörterbuch). Das Ergebnis ist eine ganze Zahl: Steht die aufrufende Zeichenfolge im Wörterbuch vor der angegebenen, so liefert compareTo() einenegative Zahl; bei Gleichheit Null. Steht die aufrufende Zeichenkette im Wörterbuch nach der angegebenen, so ist das Ergebnis eine positive Zahl.

regionMatches() Vergleicht zwei gleich lange String-Regionen, die in zwei unterschiedlichen Strings an zwei unterschiedlichen Positionen liegen können auf Gleichheit

Syntax: regionMatches(int <Position 1. Zeichenkette>, String<2. Zeichenkette>, int <Position 2. Zeichenkette>, int <Länge der

Mag. Stefan Hagmann

Seite -25-

Region>)

Wenn die Groß- und Kleinschreibung ignoriertwerden soll, wird als zusätzlicher Parameter an erster Stelle ignoreCase hinzugefügt.

Kleines Beispiel zu compareTo() :

String s = new String("hallo"); System.out.println("hallo: " + s.compareTo("hallo"));System.out.println("ha: " + s.compareTo("ha"));System.out.println("Hallo: " + s.compareTo("Hallo"));System.out.println("abc: " + s.compareTo("abc"));System.out.println("hallo - ist da jemand: " + s.compareTo("hallo -ist da jemand"));System.out.println("huch: " + s.compareTo("huch"));

liefert folgende Ausgabe:

hallo: 0ha: 3

Hallo: 32abc: 7

hallo - ist da jemand: -16huch: -20

Kleines Beispiel zu regionMatches():

System.out.println(„Grüße aus Baden“.regionMatches(8,“Greetings from Austria“,8,2);//Vergleicht, ob eine Region der Länge 2 jeweils an der Position 8 der beiden Strings ident ist und liefert in diesem Falle „true“

11.3.4. Anwendungsbeispiel „BUBBLESORT“

String satz[] = {"informatik", "ist", "schön", "und", "lehrer", "lügen", "nicht"};for (int i = 0; i < satz.length; i++) { for (int j = i+1; j < satz.length; j++) { if (satz[j].compareTo(satz[i]) < 0) { String wort = satz[i]; satz[i] = satz[j]; satz[j] = wort; } } System.out.println(satz[i]); }

Mag. Stefan Hagmann

Seite -26-

11.4. Klasse StringBuilder

Ebenso wie bei Arrays kann man an Strings grundsätzlich keine zusätzlichen Zeichen anhängen oder auch nur die zumindest die Länge verändern. Zu diesem Zwecke hat man zwei Klassen implementiert: StringBuffer und StringBuilder. Da StringBuilder als neuere die ressourcenschonendere und schneller Klasse darstellt, werden wir uns vorerst einmal auf diese Klasse beschränken, wobei ja beide Klassen soundso dieselben Methoden besitzen.

Ein leerer StringBuilder wird erzeugt mit StringBuilder(). Wird ein String übergeben, so wird ein StringBuilder-Objekt erzeugt, das eine Kopie der übergebenen Zeichenkette enthält (StringBuilder(String a) ).

11.4.1. Methoden

Methoden der StingBuilder-Klasse

append(String s) String s wird am Ende des Objektes angehängt

insert (int offset, Sting s)

An der Position offset wird String s in das Objekt eingefügt

deleteCharAt(int index)

Einzelnes Zeichen wird an der Position index gelöscht wird

delete(int start, int end)

Entfernt einen Teilstring

setCharAt(int index,char c)

Ersetzt ein Zeichen an angegebener Position

replace(int start, intend, String str)

length() Länge

capacity() Wert des belegten Pufferspeichers

11.4.2. Konvertierung in einen String

Wenn man mit der Manipulation der Zeichenkette fertig ist, kann man ein StringBuilder-Objekt wieder in einen String verwandeln. Mit der Methode String toString() kann man dies effizient machen, wobei erst bei erneuter Veränderung des StringBuilder-Objektes eine Kopie der Zeichenkette erstellt wird. Ansonsten wird nur ein Zeiger auf den Zeichenspeicher gelegt, was Ressourcen spart.

Mag. Stefan Hagmann

Seite -27-

12. Arbeiten mit Dateien

12.1. Dateien und Streams

Es gibt Klassen mit denen man Dateien lesen und beschreiben kann.

File f = new File( dateiname ); byte[] buffer = new byte[ (int) f.length() ]; InputStream in = new FileInputStream( f ); in.read( buffer ); in.close();

In diesem Beispiel wird die gesamte Datei in einen InputStream gelesen, das kann bei großen Dateien sehr lange dauern, und ist daher nicht zu empfehlen.

Für Textdateien steht eine spezielle Klasse FileWriter und FileReader zur Verfügung. Dazu muss aber das entsprechende Package eingebunden werden.

class java.io.FileWriter

Writer fw = null; try { fw = new FileWriter( "TextDatei.txt" ); fw.write( "Das ist eine Zeile!" ); //Zeilenvorschub fw.append( System.getProperty("line.separator") ); } catch ( IOException e ) { System.err.println( "Konnte Datei nicht erstellen" ); } fw.close();

Für das Lesen von Dateien würde man folgende Struktur verwenden

public void ReadFile(String filename){try{ BufferedReader rd = new BufferedReader(new FileReader(filename)); //bis zum Ende der Datei lesen String buffer =""; while((buffer = rd.readLine()) != null){ //Ausgabe auf die Konsole System.out.println(buffer); } } catch(FileNotFoundException ex){ } catch(IOException ex){ }}

Der entscheidende Teil ist der BufferedReader, der die Aufgabe hat, den Datenstrom aus der

Mag. Stefan Hagmann

Seite -28-

Datei in Strings umzuwandeln. Beachte auch diese Zeile while((buffer = rd.readLine())!= null). Das ist eine sehr kurze Schreibweise für die Laufbedingung der While-Schleife. Das bedeutet, das so lange eine Zeile gelesen wird, bis der Datenstrom aus ist, also null.

Für das Schreiben in eine Datei verwendet man den BufferedWriter,siehe anschl. Beispiel.

Beispiel: Lesen von der Tastatur und Schreiben in eine Datei

Um eine Eingabe von der Tastatur zu verarbeiten, gibt es (vgl. zur Standardausgabe) auch die Standardeingabe mit System.in. Der Eingabe-Stream System.in ist ein Exemplar der Klasse InputStream und besitzt somit auch deren Methoden. Die Eingabe wird in diesem Fall mit der Methode read() vorgenommen. Hierdurch wird das Array buffer mit den vom Benutzer auf der Standardeingabe eingegebenen Zeichen Byte-weise gefüllt:

read = System.in.read(buffer, 0, 80);

Im folgenden Beispiel wird nun die Tastatureingabe in die Datei daten.txt gespeichert.

public static void main(String args[]) { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Tastatureingabe: "); try { String s = in.readLine(); System.out.println("Kontrollausgabe: "+s); try{ BufferedWriter out =new BufferedWriter( new OutputStreamWriter(new FileOutputStream("daten.txt"))); out.write(s); out.newLine(); out.close(); System.out.println("Ihre Daten wurden in daten.txt gespeichert"); } catch(FileNotFoundException e){ System.out.println(e.getMessage());}} catch(IOException e){System.out.println(e.getMessage());}}

13. Rekursion

Methoden können in JAVA nicht nur andere Methoden sondern auch sich selbst aufrufen, was manals rekursiven Aufruf bezeichnet. Diese Technik gehört zum Grundwerkzeug jedes erfahrenen Programmierers, da es meist weit elegantere Lösungen bietet als iterative Lösungsmöglichkeiten.

Am besten sieht man den Nutzen der Rekursion anhand eines Beispieles:

Wir wollen die Fakultät einer natürlichen Zahl berechnen.

n !=1⋅2⋅3⋅⋅n−1⋅n

Mag. Stefan Hagmann

Seite -29-

Das wäre eine iterative Definition.

Rekursiv versucht man nun das „Problem“ auf sich selbst zurück zu führen.

Wir erkennen, dass die ersten n-1 Faktoren des Produkts die Zahl (n – 1)! ergeben, was uns zu einer rekursiven Definition führt:

n! = (n – 1) ! * n für n > 1n! = 1 für n = 1

Somit wird das Problem auf ein etwas kleineres gleichartiges Problem zurückgeführt, was man solange macht, bis die Berechnung abgeschlossen ist.

Die Implementierung könnte nun so aussehen:

long fact(int n){if(n==1) {return 1;}else { return fact(n-1)*n;}}

Man könnte vereinfacht sagen:

Wenn (Problem klein genug)

führe nichtrekursiven Zweig ausführung

sonst

führe rekursiven Zweig aus

13.1. Bespiel: Fibonacci Zahlen

Die Fibonaccifolge stellt ein sehr einfaches Beispiel für die rekursive Programmierung dar. Allerdings muss man leider auch beachten, dass die rekursive Lösung in diesem Fall die ressourcenintensivste darstellt, da die Funktion mehrfach mit denselben Parametern aufgerufen wird, was wiedeum viel Speicher benötigt.

Trotzdem kann man anhand dieses Beispieles Rekursionen sehr leicht analysieren und verstehen.

public static long fib(int a){ if (a==1||a==2) return 1; else return fib(a-1)+fib(a-2);}

Für die Parameter 1 und 2 wird jeweils 1 zurückgegeben, bei allen anderen Zahlen wird die Funktion mit den Parametern a-1 und a-2 aufgerufen.

13.2. Beispiel Quicksort

Mag. Stefan Hagmann

Seite -30-

Ein wichtige Anwendung der Rekursion stellen Sortier- und Suchalgorithmen dar. Man nimmt eine Liste von Elementen und teilt diese in zwei Hälften. Zunächst wird die zu sortierende Liste in zwei Teillisten („linke“ und „rechte“ Teilliste) getrennt. Dazu wählt Quicksort ein sogenanntes Pivotelement aus der Liste aus. Alle Elemente, die kleiner als das Pivotelement sind, kommen in die linke Teilliste, und alle, die größer sind, in die rechte Teilliste. Die Elemente, die gleich dem Pivotelement sind, können sich beliebig auf die Teillisten verteilen. Nach der Aufteilung sind die Elemente der linken Liste kleiner oder gleich den Elementen der rechten Liste.Anschließend muss man also nur noch jede Teilliste in sich sortieren, um die Sortierung zu vollenden. Dazu wird der Quicksort-Algorithmus jeweils auf der linken und auf der rechten Teilliste ausgeführt. Jede Teilliste wird dann wieder in zwei Teillisten aufgeteilt und auf diese jeweils wieder der Quicksort-Algorithmus angewandt, und so fort. Diese Selbstaufrufe werden als Rekursion bezeichnet. Wenn eine Teilliste der Länge eins oder null auftritt, so ist diese bereits sortiert und es erfolgt der Abbruch der Rekursion, d.h. für diese Teilliste wird Quicksort nicht mehr aufgerufen.Die Längen der Teillisten ergeben sich aus der Wahl des Pivotelements. Idealerweise wählt man das Pivot so, dass sich zwei etwa gleich lange Listen ergeben, dann arbeitet Quicksort am effizientesten. Es sollte also etwa gleich viele Elemente kleiner als das Pivot und größer als das Pivot geben.

daten[0], daten[1],... , daten[n-1].

funktion quicksort(links, rechts)

falls links < rechts dann

teiler := teile(links, rechts)

quicksort(links, teiler-1)

quicksort(teiler+1, rechts)

ende

ende

Die folgende Implementierung der Funktion teile teilt das Feld so, dass sich das Pivotelement anseiner endgültigen Position befindet und alle kleineren Elemente davor stehen, während alle größeren danach kommen:

funktion teile(links, rechts) i := links // Starte mit j links vom Pivotelement j := rechts – 1 pivot := daten[rechts]

wiederhole // Suche von links ein Element, welches größer als das Pivotelement ist wiederhole solange daten[i] ≤ pivot und i < rechts i := i + 1 ende

Mag. Stefan Hagmann

Seite -31-

// Suche von rechts ein Element, welches kleiner als das Pivotelement ist

wiederhole solange daten[j] ≥ pivot und j > links j := j - 1 ende falls i < j dann tausche daten[i] mit daten[j]

solange i < j // solange i an j nicht vorbeigelaufen ist

// Tausche Pivotelement (daten[rechts]) mit neuer endgültiger Position (daten[i])

falls daten[i] > pivot tausche daten[i] mit daten[rechts] ende

// gib die Position des Pivotelements zurück antworte i ende

14. OOP – Objektorientiertes Programmieren

Alle modernen Programmiersprachen setzen auf Objekte beim Programmieren. Die Programmierung wird dadurch viel einfacher in der Handhabung. Anstatt eines linearen Codes hat man Objekte zur Verfügung, die gewisse Aufgaben erledigen können. Diese Objekte erstellt man, wenn man sie benötigt und teilt ihnen Aufgaben zu. Im Allgemeinen ist OOP flexibler, leistungsfähiger und bei größeren Programmen einfach übersichtlicher.Die Übersichtlichkeit kann man mit diversen Zugriffsmodifizierer (vergl. 14.1. Zugriffsmodifizierer auf Seite 35) steuern.

Sehen wir uns ein Beispiel aus der Mathematik an

● Alle angeführten Objekte sind abgeleitet von der Basisklasse Shape.

● Die Eigenschaften der Basisklasse werden an die nachfolgenden Objekte vererbt

● Jedes Objekt hat Eigenschaften und Methoden

● Methoden der Basisklasse könne überschrieben werden

Mag. Stefan Hagmann

Shape

Rechteck Ellipse

KreisQuadrat

Seite -32-

Warum leitet sich z.B. ein Quadrat von einem Rechteck ab? Die Antwort kennst du aus der Mathematik. Jedes Quadrat ist auch ein Rechteck, das Quadrat ist nur eine spezielle Form des Rechtecks. Wenn also die Fläche eines Rechtecks mit Seite x Seite zu berechnen ist, dann ist es auch beim Quadrat so.Shape ist das allgemeinste Objekt. Es hat allgemeine Eigenschaften eines Körpers in 2D, also eine Begrenzungslinie, eine Fläche und einen Umfang etc.Die Definition könnte so aussehen

Objektnamen

Eigenschaften

Methoden

Von dieser Klasse leiten wir nun das Rechteck ab, das ist eine Spezialisierung des Shapes.

Länge und Breite sind eine spezielle Eigenschaft von eine Rechteck, während Linie, Linienfarbe bereits von Shape geerbt worden sind,

Die Methode Diagonale() ist wieder eine spezielle Eigenschaft, der Rest wurde geerbt.

Der dazu passende Quellcode sieht so aus:

public class Shape2D {protected int Linie;protected int Linienfarbe;protected double dichte = 1.0;

public Shape2D () {

}public abstract void Zeichnen ();public abstract double Volumen ();

Mag. Stefan Hagmann

Zeichnen()Flaeche(); Umfang();Volumen();Masse()

Linie: 2pxLinenfarbe:rotDichte: 3.4

Shape

Zeichnen()Flaeche()Umfang()Diagonale()

Linie, LinenfarbeLaengeBreite

Rechteck

Seite -33-

public double Masse (){return Volumen * dichte; /* Hier wird bereits mit dem Volumen gerechnet, obwohl esabstrakt ist! */

}

public void Flaeche () {

}

public void Umfang () {

}}

Die Methode Zeichnen() ist abstrakt, es muss nur der Kopf definiert werden. Man kann zwar jedesObjekt der Klasse Shape zeichnen, allerdings muss dies für jedes Objekt extra implementiert werden. Man nennt Klassen, die zumindest eine abstrakte Methode enthalten, abstrakte Klassen.Man sollte allerdings beachten, dass man keine Objekte dieser Klasse erzeugen kann, sehr wohl aber von den Unterklassen.

Ein kleines Beispiel soll das verdeutlichen:

abstract class Animal{boolean likes(String food){return false;}abstract void speak();void getAngry(){speak();}

Wir haben also eine abstrakte Tierklasse, in der zwar jedes Tier speaken kann, allerdings spricht jedes Tier anders. Wenn wir jetzt ein neues Objekt erzeugen wollen, müssen wir vorsichtig agieren:

Animal a1 = new Animal(); //ist nicht erlaubtAnimal a2 = new Bird(); //ist erlaubta2.speak(); // liefert „beep“

Wieder zurück zur Geometrie:Die Methode Flaeche() hingegen ist nicht abstrakt, und muss bereits hier aus programmiert werden.

Das abgeleitete Rechteck sieht nun so aus:

public class Rechteck extends Shape2D { public int Laenge; public int Breite; public Rechteck () { } public void Diagonal () { }

Mag. Stefan Hagmann

Seite -34-

public void Zeichnen () { } @Override public void Umfang () { } @Override public void Flaeche () { }}

Eine Klasse wird von einer anderen Klasse abgeleitet mit der Schreibweise Neue Klasse extends Mutterklasse.

Die Methode Flaeche() muss mit @Override neu definiert werden. Ansonsten weiß man nicht ob die Methode Flaeche() von der Klasse Shape oder von der Klasse Rechteck kommt!

Rechteck definiert neu Laenge und Breite, hat aber zusätzlich noch die Eigenschaften Linie und Linienfarbe der Klasse Shape (vererbt).

Überlege selbst, wir die Klasse Quadrat aussehen muss!

14.1. Zugriffsmodifizierer

Zugriffsmodifizierer steuern die Sichtbarkeit von Elementen eines Objektes. Die wichtigsten für unssind

• public• private• protected

Eigenschaften oder Methoden die mit public gekennzeichnet sind, dürfen von außerhalb des Objektes angesprochen werden. Mit private gekennzeichnete Element sind NUR innerhalb des Objektes verwendbar. Wenn man eine Spezialisierung einer Klasse vornimmt (mit extend ableitet), sollte man mit protected arbeiten.Fehlt der Zugriffsmodifizierer, das ist das Element immer als public anzusehen.

14.2. Getter und Setter

Getter und Setter sind Methoden, die die Eigenschaften eines Objektes schützen sollen. Diese Methoden können Fehlerbehandlungen oder Umwandlungen durchführen.

public class Kreis { private int Radius=0; //Getter public int getRadius () { return Radius; }

Mag. Stefan Hagmann

Seite -35-

//Setter public void setRadius (int val) { if(Radius > 0){ this. Radius = val; } }}

Die eigentliche Eigenschaft ist private, also geschützt. Die Getter heißen get<Eigenschaft> und set<Eigenschaft>.Wie man im Beispiel erkennen kann, wird nur dann ein Radius gespeichert, wenn dieser größer 0 ist, also hier wird auf die Eingabe reagiert, und so die Eigenschaft geschützt.

14.3. Konstruktoren

Konstruktoren dienen dazu, beim Erstellen des Objektes Aufgaben zu erledigen.Ein Konstruktor heißt immer so wie die Klasse / Objekt selbst.

public class Rechteck extends Shape2D { public int Laenge; public int Breite; public Rechteck (int b, int l) { this.Laenge = l; this.Breite = b; }}

Im obigen Beispiel werden dem Konstruktor 2 Parameter mit übergeben. Diese Parameter sind dieLänge und die Breite des Rechtecks. Das Erstellen des Objektes sieht so aus

Rechteck = new Rechteck(12,10);

Es sind nun zwingend diese beiden Parameter notwendig.

Man kann aber auch mehrere Konstruktoren schreiben, und so steuern, wie man das Objekt anlegen möchte.

public class Rechteck extends Shape2D { public int Laenge; public int Breite; public Rechteck () { } public Rechteck (int b, int l) { this.Laenge = l; this.Breite = b; }}

Im obigen Beispiel sieht man 2 Konstruktoren. Man kann nun den einen oder den anderen beim Erstellen des Objektes verwenden. Diesen Vorgang nennt man Überladung einer Methode.

Mag. Stefan Hagmann

Seite -36-

Man kann auch den einen Konstruktor aus dem anderen Konstruktor aufrufen. Sehen wir uns dieses Beispiel an

Konto(String inhaber) {this.inhaber = inhaber;

}

Konto(String inhaber, double stand) {this(inhaber); /* Aufruf des Konstruktors Konto(String inh) */this.stand = stand;

}Konto(String inhaber, double stand, boolean gesperrt) {

this(inhaber, stand); this.gesperrt = gesperrt;

}

Mit this() werden hier die anderen Konstruktoren geladen.

14.4. Die static Methode

Man kann eine Methode einer Klasse als static definieren, z.B.

public class FileManagement {

public static String[] ReadDir(String path){… tu was ...

}}

Was ist damit erreicht. Eine static gekennzeichnete Methode, kann per Klassen Namen aufgerufen werden. Das Erzeugen einer Instanz ist nicht mehr nötig.

String[] ergebnis = FileManagement.ReadDir(Path);

anstatt von

FileManagement fm = new FileManagement();String[] ergebnis = fm.ReadDir(Path);

ist ausreichend.

14.5. Mehrfachvererbungen - Interfaces

Das Problem: Eine Klasse soll von zwei Vorgängern abgeleitet werden, also eine Mehrfachvererbung. Wie geht das?Das Geheimnis sind Interfaces. Das sind rein abstrakte Klassen, die nur die Aufgabe haben, an Subklassen zu vererben.Schauen wir uns folgendes Beispiel an:

Mag. Stefan Hagmann

Seite -37-

Die einzelnen Baumarten sollen sowohl von der abstrakten Klasse Holzarten, als auch von einer Klasse Kostenabrechnung abgeleitet werden. Die Klassen könnten so aussehen

public interface kostenrechnung { public double laenge = 0; public double breite = 0; public double hoehe = 0; public abstract void Kosten(); public abstract void Festmeter();}

Vererbt werden folgende Eigenschaften:

public interface holzarten { public double preis = 0; public byte lieferzeit = 0; public String bezeichnung = "";}

Jetzt wollen wir, das alle Holzarten von beiden Klassen, also holzarten und kostenrechnung erben.

public class holz implements kostenrechnung, holzarten{ public double Kosten(){ return Volumen() * preis; } public double Volumen(){ return laenge * breite * hoehe; }}

Und schon sind wir fertig. Getrennt durch einen Beistrich kann man beliebig viele Interfaces für eine Klasse bekommen.

14.6. Verwendung der UML - Unified Modeling Language

Wenn das Modul UML installiert ist, kann man diese Sprache verwenden um ein Rohgerüst vonKlassen zu erzeugen. Man zeichnet einfach die Klassen und kann sich auf Knopfdruck denQuellcode erstellen lassen. Dazu muss man ein bestehendes Projekt angeben, in dem die *.javaDateien erstellt werden. Zusätzlich werden auch die entsprechenden Get- und SetMethodenerstellt (siehe dazu 14.2. Getter und Setter).

Mag. Stefan Hagmann

Seite -38-

Das obige Beispiel sieht dann so aus:

Der Pfeil bedeutet die Abhängigkeit der Klassen zueinander. Der Pfeil zeigt dabei auf die Mutterklasse. Mit einem Rechten Mausklick und Generate Code, wird die Java Datei erstellt. Diese sehen dann so aus.

public class Shape2D { private int Linie; private int Linienfarbe; public Shape2D () { } public int getLinie () { return Linie; } public void setLinie (int val) { this.Linie = val; } public int getLinienfarbe () { return Linienfarbe; } public void setLinienfarbe (int val) { this.Linienfarbe = val; } public abstract void Zeichnen () { } public abstract void Flaeche () { } public abstract void Umfang () { }}

und

public class Rechteck extends Shape2D {

Mag. Stefan Hagmann

Abbildung 14.1: UML Modell aus Netbeans

Seite -39-

private int Laenge; private int Breite; public Rechteck () { } public void Diagonal () { } public int getBreite () { return Breite; } public void setBreite (int val) { this.Breite = val; } public int getLaenge () { return Laenge; } public void setLaenge (int val) { this.Laenge = val; } public void Zeichnen () { } public void Umfang () { } public void Flaeche () { }}

Also bekommt man ein Grundgerüst, das nur noch aus programmiert werden muss!

15. Fragen wir Dr. Java, Good to know

15.1. Bildschirmauflösung abfragen

Wie zentriere ich ein Fenster? Wie passe ich ein Fenster an den Monitor an?Nun so

Dimension screenResolution = sys.getScreenResolution();MainForm f = new MainForm();Dimension fsize = new Dimension(

(int)(screenResolution.width*0.75),(int)(screenResolution.height*0.9)

);f.setSize(fsize);f.setVisible(true);

Zuerst frage ich die Bildschirmauflösung ab, und dann kann ich wie hier gezeigt, die Größe des Fensters an den Monitor anpassen.

Mag. Stefan Hagmann

Seite -40-

15.2. Dynamisches Erstellen von Elementen

Was tun, wenn zur Laufzeit dynamische Elemente erzeugt werden müssen? Als Beispiel wollen wireinige Buttons dynamisch erzeugen.

Collection btnList = new LinkedList<JButton>();

/*Erstellen von 10 Buttons*/for(int i=0; i<10; i++){

JButton btn = new Jbutton("Button"+i);btn.setVisible( true );

/*KlickMethode per Listener zuweisen*/btn.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){ String buttonText = e.getActionCommand();

}});

/*Button zur Collection hinzufügen*/btnList.add(btn);/*der Form zuordnen*/this.add(btn);/*neuzeichnen auslösen*/this.setVisible(true);

15.3. Warum erfolgt kein Repaint einer Komponente?

Wenn dir das passiert, dann denke an folgendes• mache ein invalidate()• mache ein repaint()

z.B. hast du ein Panel das sich neu zeichnen muss, das macht du also so

PanelKlassen.invalidate();PanelKlassen.repaint();

Nun sollte es klappen!

16. Threads mit Java

16.1. Threads über das Interface Runnable

Threads können über ein so genanntes Interface erzeugt werden.

interface java.lang.Runnable

Dieses Interface bietet nur die run() Methode und lässt den Thread parallel zum Hauptprogrammablaufen.

Mag. Stefan Hagmann

Seite -41-

public class DateCommand implements Runnable { @Override public void run(){ for ( int i = 0; i < 20; i++ ) System.out.println( new java.util.Date() ); } }

in Arbeit

Starten im Hauptprogrammworker()

16.2. wait() und notify()

Manchmal möchte man auf das Ende eines Threads warten, weil dieser z.B. sehr lange etwas berechnen muss. In diesem Fall hält man den aufrufenden Thread an, und schickt diesen schlafen.

Hier ein Beispiel (Quelle: www.tutorials.de/java/):Der MasterThread wartet solange, bis der ClientThread ihn wieder aufweckt.

public class MasterThread extends Thread { private ExecutorService service = Executors.newCachedThreadPool(); @Override public void run() { System.out.println("MasterThread start"); synchronized (this) { service.execute(new ChildThread(this)); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("MasterThread ende"); }

class ChildThread implements Runnable { private MasterThread masterThread; ChildThread(MasterThread masterThread) { this.masterThread = masterThread; }

@Override public void run() { try { System.out.println("ChildThread start");

Mag. Stefan Hagmann

Seite -42-

System.out.println("ChildThread ende"); } finally { // Sicherstellen, dass Parent geweckt wird synchronized (masterThread){ masterThread.notify(); } } } }

16.3. Zugriff auf Daten aus einem Thread heraus

Um auf eine gemeinsame Klasse aus Threads heraus zugreifen zu können, muss der Zugriff threadsicher sein. Wenn ein Thread gerade auf sagen wir eine Variable zugreift, muss ein andererThread warten bis er dran ist. Das erreicht man mit dem synchronized() Statement.

public class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; } public synchronized void decrement() { c--; } public synchronized int value() { return c; }}

Im Thread selbst, spricht man die obigen Methoden so an

synchronized(counter){counter.increment();

}

Das synchronized() Statement macht den Zugriff threadsischer, d.h. das ein anderer Thread solange wartet bis er dran ist.

16.3.1. Synchronisieren mit einem Objekt

Man kann auch so einen Zugriff starten

public class MsLunch { private long c1 = 0; private long c2 = 0; private Object lock1 = new Object(); private Object lock2 = new Object();

public void inc1() { synchronized(lock1) { c1++; } }

Mag. Stefan Hagmann

Seite -43-

public void inc2() { synchronized(lock2) { c2++; } }}

16.4. Executors

Liefern ein Thread Management und ist nützlich für größere Anwendungen.

Mit Zum Beispiel Threadpools, kann man eine fixe Anzahl von Threads arbeiten lassen. Der Executor startet dann automatisch die nächsten anstehenden Threads.Man muss sich also nicht um die Abarbeitung der Threads mehr kümmern. Sehen wir uns ein Beispiel an

//Anzahl der CpU Cores ermittelnint processors = Runtime.getRuntime().availableProcessors();//Thread PoolExecutorService executor =Executors.newFixedThreadPool(processors);//100 Bilder laden un umrechnenfor(int i=0; i<100; i++){ ThumbLoadWorker thumbworker = new ThumbLoadWorker( new StaticThumbLoader(), filename[i]); executor.submit(thumbworker);}//keine Threads werden mehr akzeptiertexecutor.shutdown();

Hier werden 100 Bilder in Threads geladen und zu einem Thumbnail verkleinert. Es arbeiten immerso viele Threads, so viele CPU Cores der Computer hat.Die fertigen Thumbnails werden über das statische Objekt StaticThumbLoader weiter verarbeitet.

17. Grafische Anwendungen mit SWING

Grafische Oberflächen programmieren wir mit der SWING Oberfläche. Dazu erstellt man eine entsprechende Desktop Application. Es steht nun eine grafische (Design) und eine Quellcode (Source) Oberfläche bereit.

Im Design Modus kann man Buttons, Panels und andere Steuerelemente auf dem Fenster platzieren, z.B.

Mag. Stefan Hagmann

Seite -44-

Das Aussehen kann man für jedes Steuerelement über die Eigenschaften einstellen.

17.1. Mehrzeilige Labels

Sind kein Problem, wenn man genau die Hilfe liest.Stellt man <html> vor den Text, kann man den Text mit html-Tags behandeln. Also zum Beispiel ergibt

jLabel3.setText("<html>Hier stellst du Parameter der Fotogallerie ein<br>alle die du möchtest");

einen zweizeiligen Label.

17.2. Actions und Events

Jedes Steuerelement kann diverse Aufgaben bekommen. Nehmen wir als Beispiel einen Button. Dessen Eigenschaften und Events sehen so aus:

Mag. Stefan Hagmann

Seite -45-

Events sind so was wie: Maus ist über dem Steuerelement, Angeklickt u.s.w.Klickt man in das Feld <none> eines Events, wird ein Name vorgeschlagen. Bestätigt man den Namen mit Enter, springt man an die entsprechende Stelle im Quellcode.

mit dem Quellcode

private void jButton1ActionPerformed(java.awt.event.ActionEventevt){ // TODO add your handling code here: int test = 0; System.exit(0);}

17.3. Mausereignisse erstellen

Mausereignisse werden als erstes per Interface „geladen“.

public class AnimApplet extends Applet implements Runnable, MouseListener, MouseMotionListener {

Je nach dem, welche Ereignisse man benötigt, wählt man ein Interface aus. Mit dem Netbeans Editor kannst du alle Ereignisse auch per grafischer Oberfläche aktivieren, aber im Prinzip passiertgenau das, was nun beschrieben wird.

Mag. Stefan Hagmann

Seite -46-

Nehmen wir an, wir haben ein Panel erstellt, das auf Mausereignisse reagieren soll:

mainPanel = new Jpanel();this.add(mainPanel, BorderLayout.CENTER);mainPanel.addMouseMotionListener(new MausMove()); mainPanel.addMouseListener(new MausPanel());

Wie man sieht, werden hier zwei unterschiedliche Maus-Listener verwendet, denen zwei Klassen zugewiesen werden, nämlich: MausMove() und MausPanel().

Diese Inline Klassen, werden innerhalb der aktuellen Klasse erzeugt.

class MausMove implements MouseMotionListener{public void mouseDragged(MouseEvent e){

} public void mouseMoved(MouseEvent e) { }}

und

class MausPanel implements MouseListener {public void mouseClicked(MouseEvent e) {}public void mousePressed(MouseEvent e) {}

}

Netbeans hilft uns hier, und setzt auf Knopfdruck alle möglichen Mausereignisse ein. Und nun braucht man nur noch in die entsprechenden Klassen eintragen, was passieren soll, wenn dieses Ereignis eintritt.

17.4. Layout Manger

Die Ausrichtung von Elementen kann man mit 3 Methoden steuern1. FlowLayout: Zeilenweise Anordnung 2. BorderLayout: Anordnung in den vier Himmelrichtungen (Rahmen) und einem

Mittelbereich 3. GridLayout: Anordnung in einem Gitter mit n gleichgroßen Zellen

17.4.1. FlowLayout

this.setLayout(new FlowLayout());JButton MyButton1 = new JButton("MyButton 1");JButton MyButton2 = new JButton("MyButton 2");JButton MyButton3 = new JButton("MyButton 3");add(MyButton1);add(MyButton2);add(MyButton3);

liefert dieses Ergebnis

Mag. Stefan Hagmann

Seite -47-

Abbildung 17.1: FlowLayout

FlowLayout fügt zeilenweise in die Oberfläche ein, und jeweils zentriert. Ist die erste Zeile voll, wirddie nächste Zeile eröffnet.

17.4.2. BorderLayout

initComponents();this.setLayout(new BorderLayout());JButton MyButton1 = new JButton("MyButton 1");JButton MyButton2 = new JButton("MyButton 2");JButton MyButton3 = new JButton("MyButton 3");add(MyButton1, BorderLayout.NORTH);add(MyButton2, BorderLayout.SOUTH);add(MyButton3, BorderLayout.LINE_END);

liefert

Abbildung 17.2: BorderLayout

Hier kann man in die vier Himmelsrichtungen ausrichten.

17.4.3. GridLayout

kein Beispiel, Verwendung wie die anderen Layouts

Mag. Stefan Hagmann

Seite -48-

17.4.4. LayoutManager deaktivieren

mit

setLayout(null);

17.4.5. Weitere Beispiele zum Layout

public class Flow2 extends Applet{ public void init() { setLayout(new FlowLayout(FlowLayout.RIGHT)); for (int i = 0; i < 4; i++) add(new Button("Button #" + i)); }}

Ein Beispiel um einen Button auszurichten

setLayout(new BorderLayout);Start = new Button("Start");add(Start, BorderLayout.CENTER);

17.5. Dialoge

17.5.1. FileOpen Dialog

Hierzu gibt es ein eigenes Objekt, das man z.B. bei einer Button Action anwenden kann

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

JFileChooser fs = new JfileChooser();int returnVal = fs.showOpenDialog(this);if (returnVal == JFileChooser.APPROVE_OPTION) {

File file = fs.getSelectedFile();} else {

System.out.println("File access cancelled by user.");}

}

Das Ergebnis sieht dann in etwa so aus

Mag. Stefan Hagmann

Seite -49-

Den angezeigten Dateityp kann man mit einem Filter einstellen, das könnte dann so aussehen

ExampleFileFilter filter = new ExampleFileFilter(); filter.addExtension("jpg");filter.addExtension("gif");filter.setDescription("JPG & GIF Images"); chooser.setFileFilter(filter);

17.6. Die Sache mit den Pfaden, Icons, Images und Dateien

Öfters kommt es vor, das man ein Image aus einem Verzeichnis laden möchte. Wie mache ich daszur Laufzeit?

Nehmen wir an, wir wollen aus dem Package rimages das Bild bird24.png als Icon für unser Fenster verwenden. Wir bekommenhier eine getResource() Methode zur Verfügung gestellt. Das istnicht der einzige Weg, aber es reicht uns hier, diese Möglichkeit zu sehen. Und so geht es

URL imgURL = getClass().getResource(

"/rimages/bird24.png");

this.setIconImage((new ImageIcon(imgURL)).getImage());

Damit haben wir die Möglichkeit, Images, Icons oder alle anderen Dateien aus einem Package zu laden. Daher gilt ab jetzt folgender Ratschlag:

Mag. Stefan Hagmann

Seite -50-

Dateien die man zur Laufzeit einbinden möchte, sollten immer in einem Package

liegen!

17.7. Die Sache mit dem JAR-File

Wenn allerdings aus einem JAR File der Befehl getClass().getResource() verwendet wird, funktioniert das nicht!(bin mir nicht ganz sicher)Es funktioniert dann nur getClass().getResourceAsStream(), was einen InputStream liefert.

Das sollte man beachten und auch ausführlich testen!

18. SWING Komponenten im Detail

18.1. JTable Model

Das TableModel definiert die Daten, die die Tabelle anzeigt. Das Model liefert Aufschluss darüber, welche Werte eine Zelle hat, wobei es auch die Anzahl der Spalten und Zeilen definiert. Abhängig von Zeile und Spalte entscheidet das Model darüber, ob die Zelle editierbar ist, wobei der erfolgreich geänderte Wert mittels setValue(Object value) ins Model zurückgeschrieben wird.

Wichtig ist die Zeile types, denn hier wird angegebne welche Daten dargestellt werden.

z.B. eine Tabelle TabellePersonen extends JTable könnte so aussehen

public TabellePersonen(Object[] columnNames, Object[][] data) {super();/* Was wird gespeichert */setModel(new DefaultTableModel(data,columnNames){

Class[] types = new Class [] {Integer.class, String.class, String.class, String.class,String.class

};/* Editierbar? */boolean[] canEdit = new boolean [] {

false, true, true, false, false};

@Overridepublic Class getColumnClass(int columnIndex) {

return types [columnIndex];

Mag. Stefan Hagmann

Seite -51-

}@Overridepublic boolean isCellEditable(int rowIndex, int columnIndex) {

return canEdit [columnIndex];}

});

18.2. Auf Ereignisse reagieren

Wenn sich etwas in der Tabelle ändert möchte man darauf reagieren, da könnte so ablaufen

/* Daten in der Tabelle haben sich geändert */this.getModel().addTableModelListener(new TableModelListener() {

@Overridepublic void tableChanged(TableModelEvent e) {

System.out.println(e);}

});/* welche Zeile ist selektiert? */this.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

@Overridepublic void valueChanged(ListSelectionEvent e) {

if(e.getValueIsAdjusting()) return;}

});

18.3. Zellen darstellen un bearbeiten

Oft möchte man eine Zelle bestimmt darstellen, z.B. mit einem Button, oder man möchte auf eine Eingabe reagieren. Dazu bnietet die Tabelle zwei Dinge an

1. Renderer, der die Darstellung der Zelle übernimmt2. Editor, der die Bearbeitung der Zelle übernimmt.

18.3.1. Ein Renderer

Angenommen wir haben so ein Model

setModel(new DefaultTableModel(data,columnNames){Class[] types = new Class [] {Integer.class, String.class, String.class, String.class,String.class

};

Dann kann man für eine Klasse einen eigenen Renderer angeben, z.B.

this.setDefaultRenderer(Integer.class, new ZahlenRenderer());this.setDefaultRenderer(Object.class, new IrgendwasRenderer());

Mag. Stefan Hagmann

Seite -52-

18.4. Ein konkretes Beispiel

Angenommen eine Zelle soll einen Button bekommen. Wie macht man das?Wir brauchen für die Zelle einen Renderer und einen Editor.Die Tabelle wird so angelegt

setModel(new DefaultTableModel(data,columnNames){Class[] types = new Class [] {

Integer.class, String.class, String.class, String.class, Note.class, Aktionen.class};

Wir legen hier eine eigene Klasse Aktionen an. Sie dient eigentlich nnur zur Identifikation der Klasse in der Zelle, und kann daher inline, leer definiert werden.

private class Aktionen{}

Nun können wir den entsprechenden Renderer zuweisen

this.setDefaultRenderer(Aktionen.class, new AktionenRenderer());

Wir sehen hier unser Dummy Klasse. Der Renderer selbst sieht so aus

private class AktionenRenderer extends JPanel implements TableCellRenderer {

@Overridepublic Component getTableCellRendererComponent(JTable table,

Object value,boolean isSelected, boolean hasFocus, int row, int column) {

this.removeAll();this.setLayout(new FlowLayout(FlowLayout.RIGHT, 4, 0));JButton btn1 = new JButton();btn1.setIcon(

new ImageIcon(getClass().getResource("/icons/add.png")));

btn1.setPreferredSize(new java.awt.Dimension(25, 25));this.add(btn1);return this;

}}

Dieser Renderer ist von JPanel abgeleitet, das this bezieht sich darauf. Darin können wir nun unseren Button definieren (muss nicht in einem Panel sein, aber warum nicht).

Nun kommt noch der Editor, mit dem wir auf die Benutzung des Buttons reagieren!Hier muss man beachten, das der Editor wiederum einen neuen Button zeichnet, der sich von demdes Renderes unterscheidet. Am besten übergibt man beiden den selben Button!

class AktionenEditor extends JButton implements TableCellEditor {private List<CellEditorListener> listeners =

new ArrayList<CellEditorListener>();

public AktionenEditor() {addActionListener(new ActionListener() {

@Overridepublic void actionPerformed(ActionEvent e) {

Mag. Stefan Hagmann

Seite -53-

throw new UnsupportedOperationException("Button: Not supported yet.");

}});

}

@Overridepublic JButton getTableCellEditorComponent( JTable table,

Object value, boolean isSelected, int row, int column ) {/* Diese Methode wird von der JTable aufgerufen, wenn der

Editor angezeigt werden soll */return this;

}

@Overridepublic void addCellEditorListener( CellEditorListener l ) {

listeners.add( l );}

@Overridepublic void cancelCellEditing() {

/* Falls abgebrochen wird, werden alle Listeners informiert */ChangeEvent event = new ChangeEvent( this );for( CellEditorListener listener : listeners.toArray( new

CellEditorListener[ listeners.size() ] ))listener.editingCanceled( event );

}

@Overridepublic Object getCellEditorValue() {

/* Button hat keinen Wert */return null;

}

@Override/* Immer editierbar, d.h. Button immer anklickbar */public boolean isCellEditable( EventObject anEvent ) {

return true;}

@Overridepublic void removeCellEditorListener( CellEditorListener l ) {

listeners.remove( l );}

@Overridepublic boolean shouldSelectCell( EventObject anEvent ) {

return true;}

@Overridepublic boolean stopCellEditing() {

Mag. Stefan Hagmann

Seite -54-

/* Ansonsten werden die Listener vom stop unterrichtet */ChangeEvent event = new ChangeEvent( this );for( CellEditorListener listener : listeners.toArray( new

CellEditorListener[ listeners.size() ] ))listener.editingStopped( event );

return true;}

}

Diese Klasse ist etwas größer, man kann aber im Prinzip alles kopieren!

18.5. Renderer und Editor in einer Klasse

Im obigen Beispiel gab es zwei verschiedene Buttons für Editor und Renderer. Besser ist es nur einen Button zu haben, und alles in einer Klasse zusammenzufassen.In der Tabelle wird so der Button aktiviert

ButtonInColumn btnCol = new ButtonInColumn(this, mybtn, delete, 4);this.setDefaultRenderer(Aktionen.class, btnCol); this.setDefaultEditor(Aktionen.class, btnCol);

Die Klasse ButtonInColumn bekommt dabei übergebn• die Tabelle• den Button der angezeigt wird• die Action die beim Klicken ausgeführt wird• die Spalte in der Tabelle

Änderungen an Tabelle this.getModel().addTableModelListener(new TableModelListener() { @Override public void tableChanged(TableModelEvent e) { System.out.println(e); } });

Mag. Stefan Hagmann

Seite -55-

19. GDI

19.1. Zeichnen in einem Panel

Wo man zeichnet ist relativ egal. Ich zeichne meistens in ein Panel, weil ich das Panel auf der Seite beliebig positionieren kann. Dazu erstellen wir eine eigene Klasse die so aussieht

package MyPanel;import java.awt.Color;import java.awt.Dimension;import java.awt.Graphics;import java.awt.image.BufferedImage;import javax.swing.*;public class DrawPanel extends Jpanel{ @Override protected void paintComponent( Graphics g ){

//hier wird gezeichnet }}

Wir leiten also vom JPanel ab, und überschreiben dessen Paint Methode. Die Paint Methode wird automatisch aufgerufen, um das brauchen wir uns nicht kümmern.Schreiben wir hier unsere Zeichenroutinen hinein, zeichnen wir innerhalb des Panel's.Das war's auch schon, so einfach ist das :) .

19.2. Transformationen

Der Koordinatenursprung von Objekten liegt immer links oben. Möchte man z.B. den Koordinatenursprung in die Mitte des Objektes verschieben, kann man eine Transformation wie folgt verwenden

public void paintComponent(Graphics gIn){ Graphics2D g = (Graphics2D)gIn.create();

g.translate(getWidth() / 2, getHeight() / 2);g.rotate(30.0 * Math.PI / 180.0);g.setFont(new Font("Sans", Font.BOLD, 24)); g.drawText("M");g.destroy();

}

Hier wird mit dem Graphics2D Objekt der Koordinatenursprung in die Mitte der Komponente geschoben, und das Koordinatensystem um 30° gedreht. Das Ergebnis sieht so aus

Mag. Stefan Hagmann

Seite -56-

19.3. Affine Transformation

Man kann auch dieses Objekt verwenden, um eine Transformation als ein „Makro“ zu speichern.

AffineTransform a = new AffineTransformgetTranslateInstance (getWidth() / 2, getHeight() / 2); public void paintComponent(Graphics gIn){ Graphics2D g = (Graphics2D)gIn.create();

g.setTransform(a);

g.setFont(new Font("Sans", Font.BOLD, 24)); g.drawText("M");g.destroy();

}

Weitere Informationen findest du hier http://java.sun.com/j2se/1.5.0/docs/api/java/awt/geom/AffineTransform.html.

19.4. Punktierte Linie zeichnen

Als Beispiel in der Paint Methode

g2.setColor(new Color(c, c, c));Stroke stroke = new BasicStroke(1,BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] { 2, 2 }, 0);g2.setStroke(stroke);… Linie zeichnen …

20. Erstellen von Java Applets für Webseiten

http://java.sun.com/docs/books/tutorial/deployment/applet/

20.1. Grundlagen

Applets werden in Webseiten dargestellt, was die Möglichkeit bietet, JAVA Programme im Internet zu verbreiten. Es gibt aber einige Einschränkungen zu einem vollwertigen Projekt, immerhin wird ein Programm aus dem Internet auf den Computer geladen, und das ist eine Sicherheitslücke. Daher gilt

• Applets dürfen nicht ohne weiteres auf Dateien des Computers zugreifen• Ladezugriffe aus dem Internet sind nur auf den Server zulässig, von dem das Applet

geladen wurde

Der Aufruf eines Applets sieht so aus

<applet code=“HalloWWW.class“ width=“200“ height=“300“></applet>

oder so

Mag. Stefan Hagmann

Seite -57-

<applet width="300" height="433" code="Nature.class" align="left" hspace="20" vspace="12"> <param name="accumulate" value="yes"> <param name="background" value="FFFFFF"> <param name="backimg" value="pixel.gif"> <param name="DeveloperInfo" value="Michael Chancey Jr."> <param name="speed" value="75"> <param name="foreground" value="FFFFFF"> <param name="graphic" value="winterbild.jpg"> <param name="randomdir" value="yes"> <param name="season" value="winter"> <param name="fallcount" value="400"> </applet>

Ein Applet hat statt dem Haupteinstiegspunkt main() die Methoden init(), start(), paint(), stop() und destroy().

Diese Methoden werden vom Browser aus gestartet und sind relativ selbsterklärend.

20.2. Der HtmlConverter

Möchte man unabhängig von diversen Browsertypen ein Applet korrekt einbinden, dann findet manim bin Ordner des JDK ein Programm mit Namen HtmlConverter.exe.

??? Bild

Man gibt hier den Pfad zur HTML Seite an (üblicherweise nach dem Build Befehl im Ordner build/), und der Rest wird automatisch erledigt!Der Html Code wird dabei sehr unübersichtlich, liefert aber ein passendes Ergebniss.

20.3. Applets und jar-Dateien

Für größere Projekte oder Datenmengen bietet sich das jar-Format an (vergl. 3.3 Die Struktur der Dateien). Das ist im Prinzip nichts anderes als ein zip File von allen nötigen Daten. Jar kann von der Konsole aus gestartet werden.Der Aufruf des Applets sieht dann so aus

<applet code=“HalloWWW.class“ archive=“Pack.jar“ width=“200“ height=“300“></applet>

20.4. Erstellen und testen eines Applets

Möchte man ein komplett neues Projekt eröffnen, oder doch eine bestehende Anwendung in ein Applet einbinden?

Wir erstellen ein neues Projekt vom Typ Java Class Library. In der Projektverwaltung erstellen wir mit New → Others erstellen wir in eine

• Applet Class • JApplet Class• Japplet Form (hier erhältst du den Form Designer)

Mag. Stefan Hagmann

Seite -58-

etc

So sieht der Projektordner aus.

Wenn du die den Quellcode ansiehst, erkennst du, das es eine Methode init() gibt. Diese Methodewird vor dem anzeigen des Applets geladen. Daher bereitet man hier alles vor, was für den Betrieb nötig ist.

public void init() { /*TODO start asynchronous download of heavy resources*/}/*TODO overwrite start(), stop() and destroy() methods*/

Weiters sehen wir hier einen Hinweis auf weitere Methoden des Applets. Diese kann man, wenn man sie benötigt, überschreiben und verändern.

20.4.1. Projekteigenschaften erstellen

Bevor wir den ersten Test laufen lassen können, müssen wir noch die Eigenschaften des Projektesetwas verändern.

Mag. Stefan Hagmann

Seite -59-

Der Webstart muss so angepasst werden.Das Allow Offline kann man aktivieren, wenn man möchte.

Wichtig ist die CodeBase, hier muss man den Speicherort am Webserver einstellen! Im Beispiel istdas http://www.bgbaden-frauen.ac.at/ext/kochapplet/.

20.5. Testen des Projektes

Das Java Network Launching Protocol (JNLP) ist ein XML-Format, das festlegt, wie Anwendungen per Java Web Start aufgerufen werden. JNLP-Dateien enthalten Informationen wie den Ablageort von JAR-Dateien, den Namen der Hauptklasse einer Anwendung und zusätzliche Parameter für das aufzurufende Programm. Ein korrekt konfigurierter Webbrowser übergibt JNLP-Dateien an die Java-Laufzeitumgebung, die dann ihrerseits die Anwendung auf den PC des Anwenders herunterlädt und startet.

Zum testen lass die die Files deines Projektes anzeigen.

Mag. Stefan Hagmann

Seite -60-

Mit dem Befehl Build F11 lassen wir unser Projekt erstellen.

Im Ordner dist/ erhält man dann das gepackte JAR-File,das html-Dokument und die *.jnlp Datei.

Optional:Im bin Ordner des JDK (z.B. C:\Programme\JDK\bin) findet man den HtmlConverter.exe. Mit dessen Hilfe kann man die HTML Datei noch für alle Browsertypen anpassen.

Man gibt die html-Datei aus dem /dist Ordner an.

20.6. Automatischr Größenanpasseung des Applets an das Fenster

<body onresize="resize()" onload="resize()" topmargin="0" leftmargin="0"

Mag. Stefan Hagmann

Seite -61-

marginwidth="0" marginheight="0"><script language="JavaScript" type="text/javascript">function resize(){

var w_newWidth,w_newHeight;var w_maxWidth=1600, w_maxHeight=1200;if (navigator.appName.indexOf("Microsoft") != -1){

w_newWidth=document.body.clientWidth-15; w_newHeight=document.body.clientHeight-15;

}else{ var netscapeScrollWidth=50; w_newWidth=window.innerWidth-netscapeScrollWidth; w_newHeight=window.innerHeight-netscapeScrollWidth;

} if (w_newWidth>w_maxWidth)

w_newWidth=w_maxWidth; if (w_newHeight>w_maxHeight)

w_newHeight=w_maxHeight; document.myApplet.setSize(w_newWidth,w_newHeight); window.scroll(0,0);

}window.onResize = resize; window.onLoad = resize; </script><applet name="myApplet" width="300" height="300"> <param name="jnlp_href" value="launch.jnlp"/> </applet>

Bufferd Image

http://staff.science.uva.nl/~heck/JAVAcourse/ch6/s2.html

21. Java Documentation erstellen

Mit einem rechten Mausklick auf ein Projekt kann man einen Dokumentation aller Programmteile anfertigen lassen. Das ist eine gewöhnliche HTML Seite.Wichtig ist dabei, dass alle Programmteile bereits beim Programmieren dokumentiert wird, und zwar auf eine bestimmte Art und Weise.Um die Dokumentation einzuleiten schreibt man/**

Ein Beispiel könnte so aussehen

Mag. Stefan Hagmann

Seite -62-

/** * Der Port der Tcp Verbindung */private int port = 0;/** * Liefert den Port des Servers zurück * @return port Nummer */public int getPort(){ return port;}/** * Setzt den Port der Serveranwendung * @param _port Nummer des Ports*/public void setPort(int _port){ this.port = _port;}

22. Virtuelle Maschine VM

22.1. Paramter

Oft reicht z.B. der reservierte Speicher der VM nicht aus. Dann kann man mit diversen Parameterndie VM steuern.Das passiert bei Netbeans in den Eigenschaften des Projektes

Abbildung 22.1: Parameter für die VM

-Xms1024M.................reserviert 1024 Mbyte für die VM-Xmx1536M.................max. Anteil am Arbeitsspeicher Das Verhältnis von -Xms:-Xmx sollte 1:1 oder z.B. 1:1,5 sein.

Eine ausführliche Beschreibung aller Parameter, findest du im Internet!

Mag. Stefan Hagmann

Seite -63-

22.2. Speicherauslastung - OutOfMemoryError

Sollte trotzdem einmal der Speicher ausgehen, z.B. mit der Fehlermeldung java.lang.OutOfMemoryError: Java heap space dann liegt wohl ein Fehler im Programm vor. Nehmen wir als Beispiel das Laden von großen Bildern.

class A{BufferedImage image;BufferedImage work_image;

public void Rotate(){}

}

hier wird eine Eigenschaft image in der Klasse angelegt. D.h. Das Image reserviert Speicher. Die Eigenschaft work_image dient zu Berechnungen, z.B. Rotieren des Bildes. Nun liegt aber das Bild2x im Speicher!

Die Lösung wäre hier das work_image nicht in der Klasse zu definieren sondern in der Methode Rotate().

class A{BufferedImage image;

public void Rotate(){BufferedImage work_image;…work_image.flush();work_image=null;

}}

work_image kann nach dem rotieren vom GarbageCollector wieder gelöscht werden, da es nur innerhalb von Rotate() benötigt wird. Und schon verbrauchen wir weniger Speicher!Das flush() und =null setzen soll lt. Internet eventuell auch den Speicher sofort freigeben, hier bin ich mir aber nicht sicher (am besten einen Profi fragen!).

Um den Speicherverbrauch in Echtzeit zu analysieren, bietet sich das Tool http://visualvm.java.net/an. Damit wird eine Überwachung der VM angeworfen, und man kann dann fast alles analysieren.

Mag. Stefan Hagmann

Seite -64-

Abbildung 22.2: Überwachung der Speicherlast

23. Netzwerkprogrammierung

Wie funktioniert denn das?Eine gute Anlaufstelle für erste Informationen ist hierhttp://download.oracle.com/javase/tutorial/networking/index.html

Im folgenden zeige ich, wie man mit Sockets programmiert. Der Ablauf einer Kommunikation zwischen Server <> Client sieht so aus

Mag. Stefan Hagmann

Seite -65-

Server wartet auf eineVerbindung mit Client

Start

Client verbindetsich mit Server

Client sendetDaten

Server verarbeitetDaten u. sendet

Antwort

?

ja

Weitere Anfragendes Clients?

nein

Client beendetdie Verbindung

Die Daten werden zu den Sockets per Streams geschickt. So kannst du z.B. sehr leicht Strings verschicken, nur was tust du, wenn du String, Integer, Date etc. versenden möchtest?

Wir erstellen uns ein Übermittlungsprotokoll und halten das ein. Und zwar senden wird Byte-Arrays über die Sockets (in JAVA würde auch Serialisieren mit Object*Streams funktionieren).

23.1. Datenpakete - TcpPackages

Die Kommunikation erfolgt über Datenpakete. Es gelten folgende Bezeichnungen:

GL {4 Bytes} ... Gesamtlänge des Daten-PaketesT {1 Byte} ... Typ des Paketes bestimmtD {x Bytes} ... die Daten

23.2. Paketarten

23.2.1. Flag – Paket:

(3 Bytes)

PL F

Mag. Stefan Hagmann

Seite -66-

24. SWING und Update von Komponenten

Es stellt sich z.B. das Problem, dass gleichzeitig ein Algorithmus ablaufen, und ein Fortschittsbalken gezeichnet werden soll.Man kann dies mit Multithreading, also dem Aufteilen des Programmes in mehrere Prozesse, erreichen.

Da der Aufbau von Swing (bzw. AWT) es nicht erlaubt, Teile der graphischen Oberfläche in einen anderen Thread auszulagern, muss man in jedem Fall den Algorithmus auslagern.

Und da Swing nicht threadsicher ist, darf man von dem ausgelagerten Algorithmus eigentlich nicht auf den Fortschrittsbalken zugreifen!

Ab JRE6 gibt es den SwingWorker, der genau das für uns macht. Hier ein einfaches Beispiel für einen Label

final JLabel label; class MeaningOfLifeFinder extends SwingWorker<String, Object> { @Override public String doInBackground() { return findTheMeaningOfLife(); }

@Override protected void done() { try { label.setText(get()); } catch (Exception ignore) { } } } (new MeaningOfLifeFinder()).execute();

oderpublic void Invoke(final String msg, final Color col){ if(output != null){ javax.swing.SwingUtilities.invokeLater(new Runnable() { @Override public void run() { output.append(msg, col); } }); } }

Mag. Stefan Hagmann

Seite -67-

25. Zwischenablage und JAVA

Die Zwischenablage ist in Java durch ein Clipboard-Objekt repräsentiert. Es gibt bei grafischen Oberflächen ein System-Clipboard, welches sich über das Toolkit-Objekt erfragen lässt.

Clipboard systemClip = Toolkit.getDefaultToolkit().getSystemClipboard();

DataFlavor beschreibt das Format der Daten in der Zwischenablage

Die Klasse DataFlavor beschreibt das Format der Daten, die in der Zwischenablage liegen. Die Klasse kommt neben dem Einsatz in der Zwischenablage auch bei Drag&Drop-Operation und auch beim Dateisystem vor.

public static void main( String args[] ) throws Exception { Clipboard systemClipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

Transferable transferData = systemClipboard.getContents( null );

DataFlavor dataFlavor[] = transferData.getTransferDataFlavors();

Object content = transferData.getTransferData( dataFlavor[1] );

System.out.println( content ); }

http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=412https://rz-static.uni- hohenheim.de/anw/programme/prg/java/tutorials/javainsel4/ javainsel_15_028.ht m#Rxx365java15028040005531F039100

import java.awt.datatransfer.*;import java.awt.image.*;

public DataFlavor[] getTransferableDataFlavors() { DataFlavors flavors = {DataFlavor.imageFlavor, DataFlavor.stringFlavor}; return flavors; }

Mag. Stefan Hagmann