437
Inhalt Intensivkurs Java Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen Netzwerk-Programmierung Die Java-Klasse Graphische Benutzerober߬ achen Vererbung Applets Ausnahmebehandlung Datenbankanbindung 1

Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

  • Upload
    phamdan

  • View
    228

  • Download
    0

Embed Size (px)

Citation preview

Page 1: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

1

Page 2: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Inhalt Advanced Java

Serialisierung Java BeansRemote Method Invocation Enterprise Java BeansServlets SicherheitNative Methoden InternationalisierungReflexion Entwicklungswerkzeuge

2

Page 3: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

3

Page 4: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣”Hello-World”-Programm

public class GutenTag

{public static void main (String[] argument)

{System.out.println ("Guten Tag!");

}}

4

Page 5: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Klassenname, Filenamen

GutenTag.java

$ javac GutenTag.java

GutenTag.class

$ java GutenTag

Guten Tag!

5

Page 6: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣main-Methode

public static void main (String[] argument)

{}

6

Page 7: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

import java.io.*;

public class Produkt

{public static void main (String[] argument)

{double[] zahl = new double[2];

7

Page 8: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

for (int i = 0; i < 2; i++)

{System.out.print ("Bitte Zahl ");

System.out.print (i + 1);

System.out.print (" eingeben: ");

System.out.flush ();

8

Page 9: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

try{zahl[i] = new Double (

new BufferedReader (new InputStreamReader (System.in)).readLine ()).doubleValue ();

// oder ausfuhrlich:

//InputStreamReader s = new InputStreamReader (System.in);

//BufferedReader t = new BufferedReader (s);

//Double d = new Double (t.readLine ());

//zahl[i] = d.doubleValue ();

}

9

Page 10: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

catch (IOException e)

{System.err.println ("IOException wurde geworfen!");

}catch (NumberFormatException e)

{System.err.println ("NumberFormatException "

+ "wurde geworfen!");

}}

10

Page 11: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

System.out.print ("Das Produkt von ");

System.out.print (zahl[0]);

System.out.print (" mit ");

System.out.print (zahl[1]);

System.out.print (" betragt ");

System.out.println (zahl[0] * zahl[1]);

}}

11

Page 12: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Produkt von zwei Zahlen

$ javac Produkt.java

$ java Produkt

Bitte Zahl 1 eingeben: 3.2

Bitte Zahl 2 eingeben: 6

Das Produkt von 3.2 mit 6 betragt 19.200000000000003

$

12

Page 13: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class Schmier extends JApplet

implements ActionListener,

ItemListener, MouseMotionListener

{// ...

}

13

Page 14: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

private Container behalter;

private int altesX = 0;

private int altesY = 0;

private Color aktuelleFarbe = Color.black;

private JButton loeschKnopf;

private JComboBox farbWahl;

private JButton endeKnopf;

14

Page 15: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

private static final String schwarz = "Schwarz";

private static final String rot = "Rot";

private static final String gelb = "Gelb";

private static final String grun = "Grun";

private static final String blau = "Blau";

15

Page 16: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void init ()

{behalter = this.getContentPane ();

behalter.setLayout (new FlowLayout ());

behalter.setBackground (Color.gray);

loeschKnopf = new JButton ("Loschen");

loeschKnopf.addActionListener (this);

loeschKnopf.setForeground (Color.black);

loeschKnopf.setBackground (Color.lightGray);

behalter.add (loeschKnopf);

16

Page 17: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

farbWahl = new JComboBox ();

farbWahl.addItemListener (this);

farbWahl.addItem (schwarz);

farbWahl.addItem (rot);

farbWahl.addItem (gelb);

farbWahl.addItem (grun);

farbWahl.addItem (blau);

farbWahl.setForeground (Color.black);

farbWahl.setBackground (Color.lightGray);

behalter.add (new JLabel ("Farbe: "));

behalter.add (farbWahl);

behalter.addMouseMotionListener (this);

}

17

Page 18: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void actionPerformed (ActionEvent ereignis)

{Object ereignisQuelle = ereignis.getSource ();

if (ereignisQuelle == loeschKnopf)

{repaint ();

}

18

Page 19: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

else if (ereignisQuelle == endeKnopf)

{System.exit (0);

// Nur bei Applikation erlaubt,

// bei Applet nicht erlaubt.

}}

19

Page 20: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void itemStateChanged (ItemEvent e)

{if (e.getItem () == schwarz)

aktuelleFarbe = Color.black;

else if (e.getItem () == rot)

aktuelleFarbe = Color.red;

else if (e.getItem () == gelb)

aktuelleFarbe = Color.yellow;

else if (e.getItem () == grun)

aktuelleFarbe = Color.green;

else if (e.getItem () == blau)

aktuelleFarbe = Color.blue;

}

20

Page 21: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void mouseDragged (MouseEvent e)

{Graphics g = behalter.getGraphics ();

g.setColor (aktuelleFarbe);

g.drawLine (

altesX, altesY, e.getX (), e.getY ());

altesX = e.getX ();

altesY = e.getY ();

}

21

Page 22: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void mouseMoved (MouseEvent e)

{altesX = e.getX ();

altesY = e.getY ();

}

22

Page 23: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public void addiere (JComponent komponente)

{behalter.add (komponente);

}

23

Page 24: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

public static void main (String[] argument)

{Schmier s = new Schmier ();

s.init ();

s.endeKnopf = new JButton ("Ende");

s.endeKnopf.addActionListener (s);

s.endeKnopf.setForeground (Color.black);

s.endeKnopf.setBackground (Color.lightGray);

s.addiere (s.endeKnopf);

24

Page 25: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-Programm

JFrame f = new JFrame ("Schmier");

f.pack (); // Trick: Erzeugt Peer-Frame

f.getContentPane ().add (s, BorderLayout.CENTER);

f.setSize (600, 400);

s.start ();

f.setVisible (true);

}

25

Page 26: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-HTML-Datei

<HTML>

<HEAD>

<TITLE>Das Schmier-Applet</TITLE>

</HEAD>

<BODY>

Wenn Sie einen Java-fahigen Browser benutzen,

bitte schmieren Sie im unten angegebenen Applet rum.

Ansonsten haben Sie Pech gehabt.

<P>

<APPLET code="Schmier.class" width=600 height=400>

</APPLET>

</BODY>

</HTML>

26

Page 27: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier-HTML-Datei

$ javac Schmier.java

$ java Schmier

$ appletviewer Schmier.html

$ netscape file:‘pwd‘/Schmier.html

27

Page 28: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Geschichte von Java

• 1990: James Gosling ”Oak”

• 1993: Java-Team(Gosling, Joy, Steele, Tuck, Yellin, van Hoff)

• 1995: Erstes Java Developer Kit (JDK 1.0)

• 1996: JDK 1.0.2 erste brauchbare Version

• 1997: Version JDK 1.1

• 1998: Version JDK 1.2, Java 2

• 1999: Java 2, J2SE, J2ME, J2EE

28

Page 29: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Merkmale von Java

• Plattformunabhangigkeit(Einsatz in allen moglichen Systemen: Mobiltelefon,Modem, Drucker, Fernsehen, Waschmaschine, Prozes-sautomatisierung, Bankensoftware)

• JVM (Java Virtual Machine) kann Betriebssystem furalle Computer sein. Ist etwa 200 KByte groß.

• Funktionalitat und Interaktivitat fur WWW

• Software muss nicht mehr gespeichert werden, sondernkann ubers Netz auf aktuellem Stand geholt werden.

29

Page 30: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Merkmale von Java

• einfach • architekturunabhangig• objekt-orientiert • portabel• verteilt • hochleistungsfahig• interpretiert • Multithread-fahig• robust • dynamisch• sicher

30

Page 31: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Objektorientierte Programmierung

• Identitat von Objekten

• Klassifizierung

• Polymorphismus

• Vererbung

31

Page 32: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

32

Page 33: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Java-Programm

• Klassen- und Schnittstellendefinitionen

• Eigenstandige Anwendung: Irgendeine Klasse mussmain definieren.

• public static void main (String[] arg)

• arg[0] ist wirklich erstes Argument,nicht Klassenname.

• Kein Ruckgabewert. Workaround:System.exit (intRueckgabeWert)

33

Page 34: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Argumente von main

public class GutenTagArg

{public static void main (String[] argument)

{System.out.println ("Guten Tag!");

for (int i = 0; i < argument.length; i++)

{System.out.print ("Argument ");

System.out.print (i);

System.out.print (" war: ");

System.out.println (argument[i]);

}System.out.println ();

}}

34

Page 35: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Umgebungsvariable

String heimVerzeichnis

= System.getProperty ("user.home");

Weitere Umgebungsvariable sind z.B.:

user.name

user.dir

java.version

java.home

java.class.version

os.name

35

Page 36: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Namensraum

•Weltweit eindeutige Namen.

• Keine globalen Variablen oder Methoden.

• Variable und Methoden sind Klassenelemente.

• Klassen gehoren zu Paketen.

• Paketnamen leiten sich vom Verzeichnis ab,sind damit an den Ort gekoppeltund dadurch automatisch eindeutig.

36

Page 37: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Namensraum

PaketName.KlassenName.variablenNamePaketName.KlassenName.methodenName ()

Beispiel:

//ba-stuttgart.de/kfg/lang/java/GutenTagArg.class

Paketname : de.ba-stuttgart.kfg.lang.java

Klassenname : GutenTagArg

Methodenname : main

37

Page 38: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Quellcode-Datei .java

• Quellcode-Datei hat Erweiterung .java .

• Kann mehrere Klassen enthalten.

• Nur eine Klasse darf public sein.

• Quellcode-Dateiname = Name dieser Klasse + .java

38

Page 39: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CLASSPATH

Unix:

setenv CLASSPATH .:/home/kfg/jvKlassen:/usr/local/jvKlassen

Windows:

SET CLASSPATH=.;a:\kfg\jvKlassen;c:\lokal\jvKlassen

39

Page 40: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Statement package

• package lang.java.konten;

• Erstes Statement nach Kommentaren.

• Datei muss in dem entsprechenden Verzeichnis liegen.

•Wenn Statement fehlt, dann Default-Paket.

40

Page 41: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Statement import

• Spart Schreibarbeit. Abgekurzte Namen.

• Nichts wird ”eingelesen”.

• Erscheinen nach dem optionalenpackage-Statement.

41

Page 42: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Statement import

1. import Pa.cka.ge.name;

2. import Pa.cka.ge.name.Klasse;

3. import Pa.cka.ge.name.*;

42

Page 43: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Sichtbarkeit – Scope

globalpublic

Paketdefault

Klasseprivate

Subklasseprotected

43

Page 44: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Lokale Variable

•Werden innerhalb von Blocken definiert und

• sind nur dort bekannt.

• Argumente von Methoden sind lokal.

44

Page 45: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konstanten

public class Mathematik

{public static final double EULER = 2.7182;

public final double FAKTOR;

}

45

Page 46: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Unicode

• 16-Bit Zeichen

• Zeichen, Strings, Identifikatoren

• 0x0000 bis 0x00FF ist gleich ISO8859-1

• Escape-Sequenzen \uxxxx, \xxx, \n, \t usw

• Beispiel: "\"" lautet alternativ "\\u0022" .

46

Page 47: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Standarddatentypen

Typ enthalt Default Bit Bereich

boolean Bool’scher Wert false 1 true oder false

char Unicode-Zeichen \u0 16 \u0000 bis \uFFFF

byte ganze Zahl 0 8 -128 bis 127

short ganze Zahl 0 16 -32768 bis 32767

int ganze Zahl 0 32 -2147483648 bis2147483647

long ganze Zahl 0 64 -9223372036854775808 bis9223372036854775807

float IEEE-754 Zahl 0.0 32 ±3.40282347E+38 bis±1.40239846E-45

double IEEE-754 Zahl 0.0 64 ±1.797693134862231570E+308±4.94065645841246544E-324

47

Page 48: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Standarddatentypen

• boolean-Werte konnen nicht von oder in einen anderenTyp gewandelt werden.

•Werte vom Typ char haben kein Vorzeichen.

• Konstanten vom Typ long: 387L oder 387l

• float und double Gleitkommazahlen: 1.4F, 1.4f,3.9D, 3.9d

48

Page 49: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Standarddatentypen

• In den Klassen java.lang.Float und java.lang.Double

sind die Konstanten POSITIVE_INFINITY, NEGATIVE_INFINITY,

NaN (not a number), MAX_VALUE (großter Absolutwert),

MIN_VALUE (kleinster Absolutwert) definiert.

• Ganzzahlige Division durch Null wirft eine

ArithmeticException.

Gleitkommadivision durch Null:

POSITIVE_INFINITY oder NEGATIVE_INFINITY.

• Schnittstelle java.util.Enumeration.

49

Page 50: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Referenzdatentypen

•Objekte (object)

• Felder (array)

50

Page 51: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Referenzdatentypen

• In Java gibt es keine Zeiger,

(bzw alle Referenzdatentypen sind eigentlich Zeiger.)

• Es gibt keine ”Adresse-von”- oder Dereferenzierungs-Operatoren.

• Ein Objekt wird mit new erzeugt.

• Zwei Referenzdatentypen konnen auf dasselbe Objekt zeigen.

• Es gibt keine Zeigerarithmetik, keine Berechnung von Objekt-

großen, keine Manipulation von Speicheradressen.

• Defaultwert ist null.

51

Page 52: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Zuweisung

a = b;

a zeigt jetzt auf dasselbe Objekt wie b.a ist keine Kopie von b.

Kopie:a = b.clone ();

52

Page 53: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vergleichbare Klasse

public class Zei implements Cloneable

{public char c;

public Zei (char c) { this.c = c; }

public boolean equals (Object z)

{ return c == ( (Zei)z).c; }

53

Page 54: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Kopierbare Klasse

public class Zei implements Cloneable

{public Object clone ()

{Object kopie = null;

try

{kopie = super.clone ();

}catch (CloneNotSupportedException e)

{e.printStackTrace ();

}return kopie;

}}

54

Page 55: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vergleich

a == b;

Pruft, ob a auf dasselbe Objekt wie b zeigt.

Gleichheit von Objekten wird gepruft mit:a.equals (b);

55

Page 56: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeugung von Objekten

Zei c;

c = new Zei (’X’);

Zei d = new Zei (’Y’);

String s = new String ("Guten Tag!");

String t = "Guten Tag!";

String r = "Guten Tag!";

56

Page 57: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Felder

byte[] f1 = new byte[20];

Zei[] f2 = new Zei[20];

int[] f3 = {27, 47, 67, 114};String[] s = {"Gu", "ten", " ", "Tag"};

Klasse[] f = {new Klasse (...), new Klasse (...),

new SubKlasse (...), ... };

int[] f4 = new int[] {27, 47, 56, 67}

57

Page 58: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Mehrdimensionale Felder

short[][] m1 = new short[47][114];

long[][][][] m2 = new long[36][][][];

long[][][][] m3 = new long[36][12][][];

long[][][][] m4 = new long[36][][12][]; // Fehler

long[][][][] m5 = new long[][17][12][]; // Fehler

58

Page 59: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��verschiedene Zeilenlangen

int[][] dreieck = new int[17][];

for (int i = 0; i < dreieck.length; i++)

{dreieck[i] = new int[i + 1];

}

59

Page 60: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Verschachtelte Initialisierung

int[][] m6

= { {5, 2}, {7, 9, 1, 6, 7}, {5, 3, 9} };

60

Page 61: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Boxing und Unboxing

Integer ib = 5; // box

int i = ib; // unbox

ib++; // unbox, increment, box

Integer jb = ib + 7;

// unbox ib, calculate, box result int jb

List<Integer> n = new ArrayList<Integer> ();

n.add (47); // box

int i = n.get (0); // unbox

61

Page 62: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Modifikatoren

• final : Kann auf Klassen, Methoden und Variable angewendet

werden.

• native : Kann auf Methoden angewendet werden.

• synchronized : Kann auf Klassen- und Instanzmethoden ange-

wendet werden.

• transient : Kann auf Variable angewendet werden, die nicht zum

dauerhaften (persistent) Zustand eines Objekts gehoren.

• volatile : Kann auf Variable angewendet werden und bedeutet,

dass die Variable ihren Wert asynchron andern kann.

62

Page 63: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Modifikatoren

• volatile : Kann auf Datenelemente angewendet werden und

bedeutet, dass das Datenelement seinen Wert asynchron andern

kann.

• transient : Kann auf Datenelemente angewendet werden, die

nicht zum dauerhaften (persistent) Zustand eines Objekts

gehoren. Transiente Felder werden nicht mit dem Objekt seriali-

siert.

63

Page 64: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Typen-Literale

Class intTyp = int.class

Class intFeldTyp = int[].class

Class zeiTyp = Zei.class

Class intTyp = Integer.TYPE

64

Page 65: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Zeichenketten

• Klasse java.lang.String

• nicht \0-terminiert

• Konkatenierung mit Operator ”+”

• ”Hallo” ist String-Objekt

• String-Objekte sind nicht veranderbar.Dafur gibt es die Klasse StringBuffer.

65

Page 66: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von String

int length ()

char charAt (int i)

boolean equals (Object s2)

int compareTo (String s2)

String substring (int von)

String substring (int von, int bis)

String replace (char alt, char neu)

66

Page 67: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��String Pool

String t = new String ("irgendetwas");

t == "irgendetwas" ergibt false.String s = new String ("irgendetwas").intern ();

s == "irgendetwas" ergibt true.t = t.intern ();

t == "irgendetwas" ergibt nun auch true.

67

Page 68: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von java.util.ArrayList

public ArrayList ();

public int size ();

public void add (Object ob);

public Object get (int i);

public Object remove (int i);

public Object[] toArray ();

68

Page 69: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von java.util.ArrayList<T>

public ArrayList<T> ();

public int size ();

public void add (T t);

public T get (int i);

public T remove (int i);

public T[] toArray (T[] at);

69

Page 70: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von java.util.ArrayList

public ArrayList ();

public int size ();

public void add (Object ob);

public Object get (int i);

public Object remove (int i);

public Object[] toArray (Object[] ob);

70

Page 71: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von java.util.Vector

public Vector ();

public int size ();

public synchronized void add (Object ob);

public synchronized Object get (int i);

public synchronized boolean remove (Object ob);

public synchronized Object remove (int i);

public synchronized Enumeration elements ();

public synchronized int copyInto (Object[] ob);

71

Page 72: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Feld als Liste

import java.util.*;

public class FeldAlsListe

{public static void main (String[] argument)

{// Definition eines Feldes:

String[] a = new String[] { "A", "B" };

// Verwandlung des Feldes in eine Liste:

List b = new ArrayList (Arrays.asList (a));

72

Page 73: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Feld als Liste

// Manipulation der Liste:

b.add ("C");

// Ruckverwandlung der Liste in ein Feld:

a = (String[]) b.toArray (new String[0]);

// Ausdruck des Feldes:

for (int i = 0; i < a.length; i++)

{System.out.print (a[i] + " ");

}System.out.println ();

}}

73

Page 74: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Aufzahlungstyp enum

import java.util.*;

public class EnumDemo

{enum Wochentag {Montag, Dienstag, Mittwoch, Donnerstag, Freitag,

Samstag, Sonntag};

public static void main (String[] arg)

{ArrayList<Wochentag> wtliste = new ArrayList<Wochentag> ();

wtliste.add (Wochentag.Montag);

wtliste.add (Wochentag.Mittwoch);

wtliste.add (Wochentag.Freitag);

wtliste.add (Wochentag.Sonntag);

74

Page 75: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Aufzahlungstyp enum

System.out.println ("Wir arbeiten nur an den Tagen:");

for (Wochentag wt : wtliste)

{System.out.println ("\t" + wt);

}System.out.println ();

75

Page 76: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Aufzahlungstyp enum

System.out.println ("Als Argumente wurden gelesen:");

Wochentag next;

for (String s : arg)

{next = null;

try

{next = Wochentag.valueOf (Wochentag.class, s);

}catch (Exception e) { e.printStackTrace (); }

System.out.println ("Gelesener String: \"" + s

+ "\" Wochentag: " + next);

}

76

Page 77: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

int i = 0;

do {next = wtliste.get (i);

switch (next)

{case Montag:

case Dienstag:

case Mittwoch:

case Donnerstag:

case Freitag: System.out.println (next + " ist ein Arbeitstag.");

break;

case Samstag: System.out.println ("Am " + next + " wird nur manchmal gearbeitet.");

break;

case Sonntag: System.out.println ("Am " + next + " wird ganz selten gearbeitet.");

break;

}i++;

} while (next != Wochentag.Sonntag);

77

Page 78: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

78

Page 79: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Uberladung von Operatoren ?

Die Uberladung von Operatoren ist in Java nicht moglich.

Ausnahme: Der binare Operator ”+” ist auch fur Objekteder Klasse String definiert und bedeutet dort Konkate-nierung.

79

Page 80: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Unare Operatoren

Unare Operatoren wirken auf ein Datenelement.

Sie sind rechts-assoziativ,d.h. -++a wird als -(++a)nicht als ++(-a) interpretiert.

80

Page 81: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Binare Operatoren

Die binaren Operatoren verknupfen zwei Datenelementeund sind alle – mit Ausnahme der Zuweisungsoperatoren– links-assoziativ.

81

Page 82: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Binare Operatoren

a + b + c + d bedeutet ((a + b) + c) + d .

Aber a = b = c = d = 1 bedeutet a = (b = (c = (d = 1))) .

a *= b += c = d -= 1 bedeutet

a *= (b += (c = (d -= 1))) .

82

Page 83: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ternarer Operator

x ? y : z

83

Page 84: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Reihenfolge der Auswertung

ist unbestimmt.

int a = 0;

(a *= 2) == ++a;

Nur ”&&” und ”||” garantieren,dass der linke Ausdruck zuerst ausgewertet wird.

84

Page 85: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Keine Operatoren sind

• Subskript (”[]”)

• Funktionsaufruf (”()”)

• new• Namensauflosung (”.”)

• Kommaoperator außer in for-Schleife

• sizeof gibt es nicht.

85

Page 86: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Division und Modulo

• Division ”/” wird bei ganzzahligen Großen ganzzahligdurchgefuhrt.

• 11 mod 3 wird dargestellt als 11 % 3

86

Page 87: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Bitweises Verschieben

• a << b

• a >> b

• a >>> b

87

Page 88: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Logische Operatoren

• Bei den logischen Operatoren ”&” und ”|” werden im-mer beide Seiten ausgewertet.

• Bei den logischen Operatoren ”&&” und ”||” wird even-tuell nur die linke Seite ausgewertet.

88

Page 89: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Typvergleich

Ausdruck instanceof Typ

89

Page 90: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

90

Page 91: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Anweisungen

• Einfachste Anweisung: ”;”

• ”a = b + c;”

• Block: ”{ }”

{int b = 0;

a = b + c;

b++;

}

91

Page 92: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Bedingte Anweisung

if (a > 0)

{b = c / a;

c++;

}else

{System.out.println ("a nicht positiv!");

b = 0;

}

92

Page 93: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Fallunterscheidung

char c;

// ---

switch (c)

{case ’a’:

x = xa;

break;

case ’b’:

case ’c’: x = xb; break;

default:

x = 0;

break;

}

93

Page 94: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��while-Schleife

a = 10;

while (a > 0)

{b = c / a;

a--;

}

94

Page 95: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��do-while-Schleife

a = 10;

do {b = c / a;

a--;

} while (a > 0);

95

Page 96: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��for-Schleife

for (int i = 0; i < 10; i++)

{a[i] = i;

b[i] = i * i;

}

96

Page 97: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Enhanced for-Loop

for (Klasse x :k)

{x.methode ();

}

97

Page 98: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Sprunge

• Es gibt kein Goto, aber goto ist reserviert.

• break• break Sprungmarke

• continue• continue Sprungmarke

98

Page 99: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Sprunge

int a = 0;

hierher: for (int i = 0; i < 10; i++)

{a++;

for (int j = 0; j < 20; j++)

{a++;

if (a == 5) continue;

if (a == 6) break;

if (a == 7) continue hierher;

if (a == 8) break hierher;

a++;

}a++;

}

99

Page 100: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Wertruckgabe

Mit der return Anweisung wird die Kontrolle wieder andie aufrufende Methode zuruckgegeben, wobei ein Aus-druck des Resultattyps der aufgerufenen Methode zuruck-zugeben ist.

100

Page 101: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methodendefinition

Modifikatoren Ruckgabetyp Methodenname (Kommalistevon Argumenten){Implementation}

101

Page 102: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methodendefinition

public double methode (int a, double x, char z)

{double y;

y = a * (z - ’0’);

return x * y;

}

102

Page 103: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Argumente variabler Lange

public static int min (int a, int... b)

{int min = a;

for (int i : b)

{if (i < min) min = i;

}return min;

103

Page 104: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Argumente variabler Lange

min (5)

min (7, 4)

min (7, 4, 12, 3, 6)

min (7, new int[] {4, 12, 3, 6})

104

Page 105: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Argumente variabler Lange

public static int min (int a, int[] b)

public void methode (Object... o)

105

Page 106: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Zusicherungen

assert assertion;

oder

assert assertion : errorcode;

java -ea:Klasse Klasse

AssertionError

106

Page 107: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��♣Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

107

Page 108: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenmerkmale

• Bildung neuer Typen, die den Bedurfnissen der ProgrammierIn

Daten zu reprasentieren genugen.

• Kontrolle des Zugangs zu Daten: Datenstrukturen konnen vor

dem direkten Zugriff des Benutzers geschutzt werden (Daten-

abstraktion, Datenkapselung, information hiding).

• Initialisierung und Aufgabe von Objekten kann fur den Benutzer

transparent erfolgen.

• Vermeidung von Code-Wiederholungen durch Vererbungsmecha-

nismen.

• Bildung von typunabhangigen Datenstrukturen.

108

Page 109: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassendefinition

public class Klassenname // Klassenkopf,

// class head

{ // Klassenkorper,

} // class body

Konvention: Klassenname beginnt mit Großbuchstaben.

109

Page 110: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Datenabstraktion

private Daten

public Elementfunktionen, Methodenpublic Zugriffsfunktionen

oder weitere Moglichkeiten mit:protected und default

110

Page 111: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Klausurnote

public class Klausurnote

{private String fach;

private char[] note = new char[3];

public void setFach (String Fach) { }public int setNote (String Note) { }public String getNumerisch () { }public String getVerbal () { }public void drucke () { }}

111

Page 112: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse HauptKlausurnote

public class HauptKlausurnote

{public static void main (String[] argument)

{Klausurnote bio = new Klausurnote ();

bio.setFach ("Biologie");

bio.setNote ("2,3");

bio.drucke ();

}}

112

Page 113: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��setFach

public void setFach (String Fach)

{fach = Fach;

}

113

Page 114: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��setNote

public int setNote (String Note)

{int n = Note.length ();

if ((n > 3) || (n == 0)

|| (n > 1 && Note.charAt (1) != ’,’)

)

{System.out.print ("Note \"" + Note);

System.out.println ("\" ist keine gultige Note!");

return -1;

}

114

Page 115: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��setNote

switch (Note.charAt (0))

{case ’5’:

if (n == 3 && Note.charAt (2) != ’0’)

{ /* Fehlermeldung */ return -1; }case ’4’: case ’3’: case ’2’: case ’1’:

note[0] = Note.charAt (0);

note[1] = ’,’;

115

Page 116: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��setNote

if (n < 3) note[2] = ’0’;

else if (Note.charAt (2) >= ’0’ && Note.charAt (2) <= ’9’)

note[2] = Note.charAt (2);

else

{System.out.print ("Note \"" + Note);

System.out.println ("\" ist keine gultige Note!");

return -1;

}return 0;

default: // Fehlermeldung

return -1;

}}

116

Page 117: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��getNumerisch

public String getNumerisch ()

{return new String (note);

}

117

Page 118: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��getVerbal

public String getVerbal ()

{double x = zahl ();

if (x < 0.99) return "ungultig";

else if ( x < 1.51) return "sehr gut";

else if ( x < 2.51) return "gut";

else if ( x < 3.51) return "befriedigend";

else if ( x < 4.01) return "ausreichend";

else return "nicht ausreichend";

}

118

Page 119: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��drucke

public void drucke ()

{System.out.print ("Die Note ");

System.out.print (fach);

System.out.print (" ist ");

System.out.print (getVerbal ());

System.out.print (" (");

System.out.print (getNumerisch ());

System.out.println (").");

}

119

Page 120: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��private Elemente

private double zahl ()

{double x = note[0] - ’0’;

x = x + (note[2] - ’0’) / 10.0;

return x;

}}

120

Page 121: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��this

Mit der Variablen this wird immer das geradevorliegende Objekt referenziert.

this.note[1]

Klarung von Namenskonflikten.

Falls Methodenresultat vorliegendes Objekt ist,return this;

121

Page 122: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konstruktor

•Wird ein einziges Mal beim Erzeugen eines Objekts mitnew aufgerufen.

• Eine Klasse kann mehrere Konstruktoren haben.

• Hat den gleichen Namen wie die Klasse.

• Hat keinen Ruckgabewert; erzeugt Objekt.

122

Page 123: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konstruktoren

public class Klassenname

{public Klassenname (int i, int j) {}public Klassenname (double x) {}public Klassenname () {}}

123

Page 124: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Klausurnote

public Klausurnote (String Note, String Fach)

{if (setNote (Note) == -1)

{ note[0] = ’0’; note[1] = ’,’; note[2] = ’0’; }setFach (Fach);

}public Klausurnote (String Note)

{this (Note, "N.N.");

}public Klausurnote ()

{this ("");

}

124

Page 125: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��this ()

•Mit dem Schlusselwort this () werden andereKonstruktoren derselben Klasse aufgerufen.

• Der Konstruktoraufruf this () kann nur inKonstruktoren erfolgen und muss dort als erstesStatement erscheinen.

125

Page 126: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Anwendung von Konstruktoren

public class HauptKlausurnote

{public static void main (String[] argument)

{Klausurnote bio = new Klausurnote ();

bio.setFach ("Biologie");

bio.setNote ("2,3");

Klausurnote phy = new Klausurnote ("1,8");

Klausurnote che = new Klausurnote ("3,1", "Chemie");

}}

126

Page 127: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Default-Konstruktor

Ein Konstruktor ohne Argumente heißtDefault-Konstruktor.

Der Default-Konstruktor wird vom Compiler nur dannautomatisch erzeugt, wenn es keine vom Klassen-Implementor definierte Konstruktoren gibt.

127

Page 128: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Instanz-Initialisatoren

sind namenlose Code-Blocke, die an beliebiger Stelle in derKlasse auftreten konnen.Sie werden in der Reihenfolge ihres Auftretens nach demSuperklassen-Konstruktor, aber vor allen anderen Kon-struktoren abgearbeitet.Damit kann man z.B. Objektfelder an der Stelle ihres Auf-tretens initialisieren, was die Lesbarkeit des Codes erhohenkann, und anonyme Klassen initialsisieren.

128

Page 129: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Aufgabe von Objekten

• ist nicht Sache des Programmierers.garbage collection, GC

• Empfehlung an GC moglich:int[] riesig = new int[1000000];

// benutzt riesig

// riesig wird nicht mehr benotigt

riesig = null;

• Vor Deallokierung wird finalize aufgerufen.

• System.gc ();

129

Page 130: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Destruktor-Methode finalize

• Der Java-Interpreter kann verlassen werden, ohne dass der

Garbage-Kollektor die Moglichkeit hat, alle Objekte zu deallokie-

ren.

• Es ist nicht spezifiziert, wann und in welcher Reihenfolge der

Garbage-Kollektor die Objekte deallokiert.

• Eine finalize-Methode kann das Objekt wieder zum Leben er-

wecken, indem this wieder einer Variablen zugewiesen wird. In

solch einem Fall wird finalize nicht wieder aufgerufen, wenn

das Objekt schließlich deallokiert werden kann.

• finalize-Methoden konnen Exceptions werfen. Wenn diese Ex-

ceptions nicht gefangen werden, werden sie ignoriert.

130

Page 131: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel finalize

protected void finalize () throws Throwable

{System.out.print ("Die Note ");

System.out.print (fach);

System.out.print (" (");

System.out.print (getVerbal ());

System.out.print (" (");

System.out.print (getNumerisch ());

System.out.println (")) wird gleich deallokiert.");

super.finalize ();

}

131

Page 132: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Die Aktivitat des GC

kann man mit der Option -verbosegc beobachten:public class Speicherfresser

{public static void main (String[] arg)

{int i = 0;

while (true)

{i++;

System.err.println ("Iteration " + i);

double[] d = new double[10000];

for (int j = 0; j < d.length; j++) d[j] = Math.random ();

}}

}

132

Page 133: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenvariable und -methoden

•Werden static deklariert.

• Klassenvariable sind Datenelemente, auf die alleInstanzen der Klasse zugreifen konnen.

• Klassenvariable und -methoden konnen ohne Instanzangesprochen werden, nur mit dem Klassennamen.

•Moglichkeit zur Emulation von”globalen” Variablen.

133

Page 134: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Klassenvariable

public class Klausurnote

{// ---

static int anzKlausurnoten = 0;

// ---

}

134

Page 135: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Verwendung von Klassenvariablen

Klausurnote a = new Klausurnote ();

a.anzKlausurnoten = 5;

Klausurnote.anzKlausurnoten = 6;

135

Page 136: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenmethoden

public class Klausurnote

{// ---

public Klausurnote besser (Klausurnote b)

{if (zahl () < b.zahl ()) return this;

else return b;

}

public static Klausurnote besser (Klausurnote a, Klausurnote b)

{if (a.zahl () < b.zahl ()) return a;

else return b;

}// ---

}

136

Page 137: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��static-Initialisator

public class Klausurnote

{// ---

static int[] feld;

static

{feld = new int[20];

for (int i = 0; i < 20; i++)

{feld[i] = i;

}}

// ---

}

137

Page 138: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��static-Initialisator

• Beliebig viele Initialisatoren sind moglich.

• native Methoden werden typischerweisemit System.load oder System.loadLibraryin einem Initialisator geladen.

• static Methoden konnen von Erbennicht uberschrieben werden.

138

Page 139: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

139

Page 140: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vererbung

”Ist-ein”- oder Erweiterungs- oderSubstitutions-Beziehung

Angestellter ist eine PersonDampflokomotive ist eine LokomotiveLokomotive ist ein FahrzeugGirokonto ist ein KontoQuadrat ist ein Rechteck?

140

Page 141: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vererbung

• Erweiterung oder Spezialisierung:Erzeugung neuer Typen durch Anfugen vonzusatzlichen Eigenschaften an alte Typen(Angestellter – Person)

• Reduktion auf Gemeinsamkeiten oder Generalisierung:Definition einer gemeinsamenSchnittstelle fur verschiedene Typen

141

Page 142: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Syntax des Vererbungsmechanismus

public class B extends A

{// ---

}

A heißt Basisklasse, Obertyp oder Superklasse,von der B abgeleitet wird oder von der B erbt.B heißt Untertyp oder Subklasse.

142

Page 143: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Graphische Darstellung

A

B

C

A

B

143

Page 144: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Mehrfachvererbung nicht moglich!

A B C

D

Aber beliebig viele Schnittstellen konnen geerbt wer-den.

144

Page 145: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��final Klassen

Von einer als final deklarierten Klasse kann nicht geerbtwerden.

z.B. String, Integer, Double usw.

145

Page 146: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Object

Object ist Basisklasse aller Klassen (außer von Object).

Die Methoden, die in Object definiert sind, konnen vonjedem Java-Objekt aufgerufen werden.

146

Page 147: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von Object

public final Class getClass ();

public String toString ();

public boolean equals (Object obj);

protected native Object clone ()

throws CloneNotSupportedException;

protected void finalize () throws Throwable;

147

Page 148: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Polymorphismus

Jedes Objekt einer abgeleiteten Klasse ist auch ein Objektder Basisklasse.

class B extends A {}// ---

B b = new B ();

A a = b;

148

Page 149: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Polymorhismus

class A

{void f (String s)

{System.out.println (s + ": f kommt von A.");

}}

class B extends A

{void f (String s)

{System.out.println (s + ": f kommt von B.");

}

void g (String s)

{System.out.println (s + ": g kommt von B.");

}}

149

Page 150: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Polymorphismus

public class Polymorphismus

{public static void main (String[] argument)

{A a = new A ();

B b = new B ();

a.f ("a.f ()");

a = b;

a.f ("a.f ()");

// a.g ("a.g ()"); // Fehler

b.g ("b.g ()");

}}

150

Page 151: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��mehr zur Syntax

• ”uberschreiben” und ”uberladen”

• Eine final-deklarierte Methode kann in einerabgeleiteten Klasse nicht uberschrieben werden.

• Alle static und alle private Methoden– wie auch alle Methoden einer final Klasse –sind implizit final.

• Uberschreibende Methode kann hohere Sichtbarkeit ha-ben.

151

Page 152: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Referenz hat

• statischen Typ: Wird bei Deklaration festgelegt.

• dynamischen Typ: Wird durch das referenzierteObjekt bestimmt.

dynamic method lookup

152

Page 153: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Uberschreiben von Variablen

class A { int z = 1; void f () {}}class B extends A { int z = 2; void f () {}}class C extends B

{int z = 3;

void f () {}

public void zugriff ()

{

153

Page 154: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Uberschreiben von Variablen

z = 5; // z von C

f (); // f von C

this.z = 5; // z von C

this.f (); // f von C

((B) this).z = 5; // z von B

super.z = 5; // z von B

((B) this).f (); // f von C

super.f (); // f von B

((A) this).z = 5; // z von A

super.super.z = 5; // Fehler

((A) this).f (); // f von C

super.super.f (); // Fehler

}}

154

Page 155: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konstruktoren

class A

{private int a;

public A (int k) { a = k; }}

class B extends A

{public B ()

{super (17);

// ---

}}

155

Page 156: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��finalize

protected void finalize () throws Throwable

{// ---

super.finalize ();

}

156

Page 157: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Reihenfolge der Initialisierung

1. Speicher fur Datenelemente aller Klassen einer Verer-bungshierarchie und Initialisierung mit Defaultwerten

2. Fur jede Klasse einer Vererbungshierarchie(beginnend mit der obersten Basisklasse)

(a) Instanzinitialisatoren

(b) Konstruktor(en)

Bemerkung: Polymorphes Verhalten der Methodenin Initialisatoren und Konstruktoren.

157

Page 158: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Abstrakte Klassen

• Durch den Modifikator abstract wird eine Klasse abstrakt.

public abstract class AbtrakteKlasse {}

Von einer abstrakten Klasse konnen keine Objekte angelegt wer-

den.

• Durch den Modifikator abstract wird eine Methode abstrakt.

Eine abtrakte Methode hat anstatt einer Implementation ein Se-

mikolon.

public abstract void methode ();

Eine Klasse mit einer abtrakten Methode ist automatisch abstrakt

und muss auch so deklariert werden.

158

Page 159: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ZweiDimGebilde

public abstract class ZweiDimGebilde

{public String name;

public ZweiDimGebilde (String name)

{this.name = name;

}public abstract double flaeche ();

public abstract double umfang ();

public static void main (String[] argument)

{}

}

159

Page 160: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ZweiDimGebilde

public abstract class ZweiDimGebilde

{public static void main (String[] argument)

{ZweiDimGebilde[] zdg = new ZweiDimGebilde[2];

zdg[0] = new Kreis ("Rundes", 12.0);

zdg[1] = new Rechteck ("Eckiges", 17.0, 9.5);

for (int i = 0; i < zdg.length; i++)

{System.out.print (zdg[i].name + " : ");

System.out.print ("Flache = ");

System.out.print (zdg[i].flaeche ());

System.out.print (" Umfang = ");

System.out.println (zdg[i].umfang ());

}}

160

Page 161: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ZweiDimGebilde

class Kreis extends ZweiDimGebilde

{private double radius;

public Kreis (String name, double radius)

{super (name);

this.radius = radius;

}public double flaeche ()

{return java.lang.Math.PI * radius * radius;

}public double umfang () { return 2 * java.lang.Math.PI * radius; }}

161

Page 162: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ZweiDimGebilde

class Rechteck extends ZweiDimGebilde

{private double laenge;

private double breite;

public Rechteck (String name, double x, double y)

{super (name);

if (x > y) { laenge = x; breite = y; }else { laenge = y; breite = x; }}

public double flaeche () { return laenge * breite; }public double umfang () { return 2 * laenge + 2 * breite; }}

162

Page 163: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schnittstelle – interface

public interface DarstGebilde

{void zeige ();

}

Alle Methoden einer Schnittstelle sind implizitabstract und public.Nur Klassenkonstanten sind definierbar (static final).

163

Page 164: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schnittstelle – interface

<<interface>>

Schnittstelle

Klasse

164

Page 165: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel DarstGebildeMain

public class DarstGebildeMain

{public static void main (String[] argument)

{DarstGebilde[] zdg = new DarstGebilde[2];

zdg[0] = new DarstKreis ("Rundes", 12.0);

zdg[1] = new DarstRechteck ("Eckiges", 17.0, 9.5);

for (int i = 0; i < zdg.length; i++)

{zdg[i].zeige ();

}}

}

165

Page 166: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel DarstGebildeMain

class DarstKreis extends Kreis implements DarstGebilde

{public DarstKreis (String name, double radius)

{super (name, radius);

}

public void zeige ()

{System.out.print ("Kreis " + name + " : ");

System.out.print ("Flache = ");

System.out.print (flaeche ());

System.out.print (" Umfang = ");

System.out.println (umfang ());

}}

166

Page 167: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel DarstGebildeMain

class DarstRechteck extends Rechteck implements DarstGebilde

{public DarstRechteck (String name, double x, double y)

{super (name, x, y);

}

public void zeige ()

{System.out.print ("Rechteck" + name + " : ");

System.out.print ("Flache = ");

System.out.print (flaeche ());

System.out.print (" Umfang = ");

System.out.println (umfang ());

}}

167

Page 168: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schnittstellen

• Eine Klasse, die eine Schnittstelle implementiert, mussalle Methoden der Schnittstelle implementieren.

• Eine Klasse kann beliebig viele Schnittstellenimplementieren.

• Konstanten, die in einer Schnittstelle definiert wurden,konnen in der implementierenden Klasse und derenSubklassen ohne Referenz auf den Namen der Schnitt-stelle verwendet werden.

168

Page 169: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Sub-Schnittstellen

public interface S1 extends S01, S02, S03

{// eigene Methoden

}

Bei Schnittstellen ist Mehrfachvererbung moglich!

169

Page 170: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse java.lang.Class

Bietet Informationen uber Klassen.

Class c = Class.forName ("Klausurnote");

// oder: Class c = Klausurnote.class;

Klausurnote k = (Klausurnote)c.newInstance ();

170

Page 171: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel fur Class

// in main:

Class c = Class.forName (argument[0]);

S s = (S) c.newInstance ();

s.zeige ();

interface S

{void zeige ();

}

class A implements S

{public void zeige ()

{System.out.println ("Es grußt Sie A!");

}}

171

Page 172: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Implementation von clone

public class A implements Cloneable

{private int intDatenElement;

private String stringDatenElement;

private B cloneableDatenElement;

public Object clone ()

{}

}

172

Page 173: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Implementation von clone

public Object clone ()

{A kopie = null;

try

{kopie = (A) super.clone ();

kopie.stringDatenElement = new String (stringDatenElement);

kopie.cloneableDatenElement = (B) cloneableDatenElement.clone ();

}catch (CloneNotSupportedException e)

{e.printStackTrace ();

}return kopie;

}

173

Page 174: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Ist-ein”-Beziehung (is-a)

B ist ein A. Alles, was fur A zutrifft, trifft auch fur B zu.Die Objekte von B sind eine Teilmenge der Objekte von A.Objekte von B konnen Objekte von A voll ersetzen(Substitutionsprinzip).

class B extends A

{//---

}

174

Page 175: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Ist-ein”-Beziehung (is-a)

• private Methoden von A sind Methoden, die nichtgeerbt werden.

• final Methoden von A sind Methoden, deren Schnitt-stelle und deren Implementation geerbt werden. Siekonnen nicht uberschrieben werden.

• abstract Methoden von A sind Methoden, derenSchnittstelle nur geerbt wird. Sie mussen implementiertwerden.

• Bei allen anderen Funktionen wird die Schnittstelle ge-erbt. Außerdem konnen sie neu implementiert werden.

175

Page 176: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beziehung ”Ist-fast-ein” (is-like-a)

Bei dieser Beziehung sollte man die Gemeinsamkeiten derPartner A und B in einer abstrakten Klasse, etwa G, zu-sammenfassen, von der A und B erben.

176

Page 177: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beziehung ”Ist-fast-ein” (is-like-a)

A B

G

177

Page 178: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Hat-ein” – Beziehung (has-a)

”Ist-implementiert-mit”-Beziehung,Layering, Containment, Embedding,Einbettung, Komponente und Komponentengruppe,”tiefe” Kopie bezuglich Komponente

class A {---}

class B

{private A a;

private A[] a = new A[10];

}

178

Page 179: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Benutzt-ein” – Beziehung (uses-a)

”flache” Kopie bezuglich Benutztem

class A {---}

class B

{private A a;

}

179

Page 180: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Andere Beziehungen

• Definition einer eigenen Klasse fur die Beziehung

• Diese Klasse enthalt dann die Partner der Beziehungals Datenelemente.

• Zusatzlich konnen – aus Effizienzgrunden – Objekteoder Felder von Objekten der Beziehung in den Part-nerklassen verwaltet werden.

180

Page 181: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Botschaften

In der Objektorientierung spielen Botschaften messagesan Objekte von anderen Objekten eine große Rolle. In Ja-va wird das Senden einer Botschaft an ein anderes Objektdadurch implementiert, dass eine Methode des die Bot-schaft empfangenden Objekts aufgerufen wird.

181

Page 182: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Mehrfachvererbung

Java kennt keine Mehrfachvererbung. Sie kann nur so im-plementiert werden, dass hochstens eine der Basisklassengeerbt wird. Fur die anderen Basisklassen mussen Schnitt-stellen definiert werden. Die Mehrfacherbin hat von diesennicht geerbten Basisklassen je ein Datenelement und im-plementiert mit diesen Datenelementen die Schnittstellen,wobei zu empfehlen ist, dass die Basisklassen die entspre-chenden Schnittstellen auch implementieren.

182

Page 183: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Mehrfachvererbung

Land- raeder :int+ fahren () :void

Wasser- wasserverdr :double+ schwimmen () :void

Amphibie

183

Page 184: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Mehrfachvererbung

Land- raeder :int+ fahren () :void

<<interface>>

WasserSchnittstelleschwimmen () :void

Wasser- wasserverdr :double+ schwimmen () :void

Amphibie

1

184

Page 185: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

185

Page 186: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Signale

• Zeigt besondere Situation an.

• Ein Signal Werfen (throw) bedeutet, das Signal zugeben.

• Ein Signal Fangen (catch) bedeutet, die entspre-chende Ausnahmesituation zu behandeln (handle).

186

Page 187: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Syntax

// ---

try

{// ---

throw objekt;

// ---

}catch (Typ_des_Objekts e)

{ // ---

}catch (Typ_von_anderen_Objekten e)

{ // ---

}finally

{ // ---

}// ---

187

Page 188: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��finally-Block

1. Normalerweise nach Abarbeitung des try-Blocks.

2. Nach Werfen einer Exception und Abarbeitung des catch-Blocks.

3. Nach Werfen einer Exception, fur die es hier kein catch gibt.

4. Nach einem break, continue oder return im try-Block.

• Wenn der finally-Block selbst ein throw, break, continue

oder return macht, dann wird die laufende Abbruchs-Aktion ab-

gebrochen und diese neue Abbruchs-Aktion weiterverfolgt.

188

Page 189: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ausnahme-Objekte

mussen von java.lang.Throwable erben.

• java.lang.Error : Diese Fehler betreffen Probleme des

Bindens im Zusammenhang mit dynamischem Laden von Code

oder Probleme der virtuellen Maschine (Speicherplatz).

• java.lang.Exception : Von diesen Fehlern kann sich ein Pro-

gramm meistens erholen (z.B. java.io.EOFException oder

java.lang.ArrayAccessOutOfBounds). Diese Klassen enthal-

ten meistens eine Diagnose-Methode und Status-Methoden oder

-Variablen, die im catch-Block verwendet werden konnen.

189

Page 190: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Object

Throwable

ExceptionError

RuntimeException

anormal

190

Page 191: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Deklaration von Exceptions

void methode () throws Ausnahme1, Ausnahme2 {}

• Eine Methode muss Exceptions deklarieren, wenn sienicht von ihr behandelt werden.

• Nur ”normale” Exceptions mussen deklariert werden.”Nicht-normal” sind Error und RuntimeException

• Es genugt eine Superklasse zu deklarieren.

• Fehler- oder Ausnahmehierarchien.

191

Page 192: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Basisklasse Throwable

• printStackTrace ()

printStackTrace (PrintWriter s)

• fillInStackTrace () :

throw e;

throw (Ausnahmetyp)(e.fillInStackTrace ());

192

Page 193: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Best Practices

• Arbeite mit einer moglichst spezifischen Exception.

• Vermeide leere catch-Blocke.

• Javadoc kennt das @throws-Tag.

• RuntimeExceptions mussen nicht deklariert und abgefangen wer-

den. Es ist nicht Best Practice, RuntimeExceptions in einem

try-catch-Block zu behandeln. Es ist besser den Fehlerfall durch

geeigneten Code abzufangen.

• Anstatt eigene Fehlerklassen zu schreiben sollte man versuchen,

die vom JSDK zur Verfugung gestellten Klassen zu verwenden.

193

Page 194: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

public class Ausnahme

{public static void main (String[] argument) throws A1

{ // ---

a.f (ubergebenesIntegerargument);

}void f (int i) throws A1

{ // abhangig von i verschiedene Abbruchaktion

// Ruft evtl. auch ff (i) auf.

}void ff (int i) throws A1, A2, A4

{ // Ruft fff (i) auf.

// Behandelt einige Fehler selbst.

}void fff (int i) throws A1, A2, A3, A4, A5

{ // Wirft in Abhangigkeit von i verschiedene Fehlerobjekte.

// Behandelt einige davon.

}}

194

Page 195: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

class A extends Throwable

{A (String diag) { this.diag = diag; }

void diagnose ()

{Ausnahme.bem ("Ausnahme " + diag + " wurde geworfen.");

}private String diag;

}class A1 extends A { A1 () { super ("A1"); } }class A2 extends A { A2 () { super ("A2"); } }class A3 extends A

{A3 () { super ("A3"); }A3 (String diag) { super (diag); }}

class A4 extends A { A4 () { super ("A4"); } }class A31 extends A3 { A31 () { super ("A31"); } }

195

Page 196: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

196

Page 197: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Innere Klassen

• Block-Struktur und Klassen-Struktur

• Adapter-Klassen

• Syntax:

– als Klassenelement

– im Block

– anonym im Block

– static innere Klasse oder Schnittstelle

• Bezug auf außeres Objekt muss klar sein.

197

Page 198: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel innere Klassen

public class AeussereKlasse

{public static void main (String[] argument)

{AeussereKlasse ak = new AeussereKlasse ();

ak.f ();

InnereKlasse ik = ak.new InnereKlasse ();

ik.f ();

ak.ff ();

ak.fff ();

}// ---

}

198

Page 199: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel innere Klasse als Element

void f ()

{System.out.println ("Kommt von der außeren Klasse.");

InnereKlasse k = new InnereKlasse ();

k.f ();

}

class InnereKlasse

{void f ()

{System.out.print ("Kommt von der inneren Klasse, ");

System.out.println ("die als Element definiert ist.");

}}

199

Page 200: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel innere Klasse im Block

void ff ()

{class InBlockKlasse

{void f ()

{System.out.print ("Kommt von der inneren Klasse, ");

System.out.println ("die im Block definiert ist.");

}}

new InBlockKlasse ().f ();

}

200

Page 201: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel innere Klasse anonym

interface KlasseOderSchnittstelle { void f (); }

void fff ()

{(new KlasseOderSchnittstelle ()

{public void f ()

{System.out.print ("Kommt von der inneren Klasse, ");

System.out.println ("die im Block anonym definiert ist.");

}}

).f ();

}

201

Page 202: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schmier mit anonymen Klassen

loeschKnopf.addActionListener

(

new ActionListener ()

{public void actionPerformed (ActionEvent event)

{Graphics g = Schmier.this.getGraphics ();

Rectangle r = Schmier.this.getBounds ();

g.setColor (Schmier.this.getBackground ());

g.fillRect (r.x, r.y, r.width, r.height);

}}

);

202

Page 203: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Callable und anonyme Klassen

package java.util.concurrent;

public interface Callable<V>

{V call () throws Exception;

}

Beispiel Rechner.java

203

Page 204: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

204

Page 205: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Scheduler

• Prioritatsgesteuertes unterbrechendes Schedulingohne Zeitscheiben.(priority based preemptive schedulingwithout time slicing)

• Abgabe des Prozessors durch yield, sleep oder wait

• Bei gleicher Prioritat nimmt Scheduler den Thread, deram langsten gewartet hat.

•Man muss aber die Gegebenheiten des zugrundeliegen-den Betriebssystems beachten: evtl. doch Zeitscheibenund weniger Prioritatsstufen.

205

Page 206: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erben von Thread

public class MeinThread1 extends Thread

{public void run ()

{// Eigentlicher Threadcode

}}

Anwendungscode:MeinThread1 p = new MeinThread1 ();

p.start ();

206

Page 207: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Implementation von Runnable

public class MeinThread2 implements Runnable

{public void run ()

{// Eigentlicher Threadcode

}}

Anwendungscode:MeinThread2 ob = new MeinThread2 ();

Thread p = new Thread (ob);

p.start ();

207

Page 208: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ErbtThread

public class ErbtThread

{public static void main (String[] argument)

{MeinThread1 herr = new MeinThread1 ("Herr");

herr.start ();

MeinThread1 knecht = new MeinThread1 ("Knecht");

knecht.start ();

}}

208

Page 209: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ErbtThread

class MeinThread1 extends Thread

{private String name;

public MeinThread1 (String name) { this.name = name; }

public void run ()

{while (true)

{System.out.println ("Thread " + name + " lauft.");

yield ();

}}

}

209

Page 210: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ImpleRunnable

public class ImpleRunnable

{public static void main (String[] argument)

{MeinThread2 herr = new MeinThread2 ("Herr");

Thread herrTh = new Thread (herr);

herrTh.start ();

MeinThread2 knecht = new MeinThread2 ("Knecht");

Thread knechtTh = new Thread (knecht);

knechtTh.start ();

}}

210

Page 211: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel ImpleRunnable

class MeinThread2 implements Runnable

{private String name;

public MeinThread2 (String name) { this.name = name; }

public void run ()

{while (true)

{System.out.println ("Thread " + name + " lauft.");

Thread.yield ();

}}

}

211

Page 212: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von Thread

• start () startet Thread.

• Thread.yield () gibt Kontrolle an anderen Thread gleicher

Prioritat ab.

• Thread.sleep (long ms) oder

Thread.sleep (long ms, int nanos)

• p.join (), p.join (long ms) oder

p.join (long ms, int nanos) warten,

bis p zu Ende gekommen ist oder ein Timeout eintritt.

• interrupt () unterbricht sleep, join und wait

212

Page 213: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methoden von Thread

• isAlive ()

• Thread.currentThread ()

• setName (String s), getName ()

213

Page 214: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Threadgruppen

• Jeder Thread gehort einer Threadgruppe an.

• Jede Threadgruppe außer der ”Wurzel”-Threadgruppegehort einer Threadgruppe an.

• Konstruktoren:ThreadGroup (String name)

ThreadGroup (ThreadGroup gruppe, String name)

Thread (ThreadGroup gruppe, String name)

Thread (ThreadGroup gruppe, Runnable objekt,

String name)

214

Page 215: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��GroupTree

Ubung:

GroupTree.dumpAll ()

215

Page 216: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Prioritat

public final void setPriority (int prioritaet)

Je hoher die Zahl, desto hoher ist die Prioritat.Thread.MIN_PRIORITY bis Thread.MAX_PRIORITY.Default ist Thread.NORM_PRIORITY.

216

Page 217: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Abbruch eines Threads?

• stop () ?

• suspend () ?

• resume () ?

217

Page 218: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Synchronisation

• Monitorkonzept zum Schutz von ”kritischen Bereichen”. Jedes Ob-

jekt mit kritischem Bereich bekommt zur Laufzeit einen Monitor.

• Kritischer Bereich durch synchronized gekennzeichnet.

• synchronized (irgendeinObjekt) { irgendeinCode }

• synchronized (this) { Methodencode }

• synchronized (this.getClass ()) { staticMethCode }

• Lock-Implementation uber Zahler.

• Keine automatische Vererbung.

218

Page 219: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��synchronized

Mit synchronized werden Codestucke definiert,die atomar oder unteilbar bezuglich eines Objektsdurchzufuhren sind.

•Modifikator einer Methode

• synchronized (Ausdruck) Block

• synchronized (Ausdruck.getClass ()) Block

Vermeidung von Prioritatsinversion durch Prioritats-Vererbung ist fur JVM nicht verpflichtend.

219

Page 220: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

ParkhausfreiePlatze :intlassEinfahren ()

lassAusfahren ()

status ()warte (Nachricht :String)

cstr (Kapazitat :int)main (arg :String[*])

Thread

AutoNummer :intcstr (Nummer :int, p :Parkhaus)

run ()

dreimal:

lassEinfahrenstatuswarte (...)

lassAusfahrenstatuswarte (...)

Parkhaus mitKapazitat 5erzeugen.

Zehn Autos mit

demselben

Parkhausstarten.

220

Page 221: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

ParkhausfreiePlatze :intlassEinfahren ()

lassAusfahren ()

status ()warte (Nachricht :String)

Parkhaus (Kapazitat :int)main (arg :String[*])

Thread

AutoNummer :intAuto (Nummer :int, p :Parkhaus)

run ()

dreimal:

lassEinfahrenstatuswarte (...)

lassAusfahrenstatuswarte (...)

Parkhaus mitKapazitat 5erzeugen.

Zehn Autos mit

demselben

Parkhausstarten.

221

Page 222: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��wait, notify und notifyAll

•Methoden der Klasse Object

• Aufrufbar nur in kritischen (synchronized) Bereicheneines Objekts x.

• x.wait () :Thread kommt in wait-Warteschlange fur x.

• x.notify () :ein Thread verlasst wait-Warteschlange fur x.

• x.notifyAll () :alle Threads verlassen wait-Warteschlange fur x.

222

Page 223: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��andere Sichten

Ressourcen-Sicht:"beantrage Lock" und "gib Lock frei"

"synchronized (x) {" und "}"Ereignis-Sicht:

"warte auf Event" und "sende Event"

"x.wait ()" und "x.notify ()"

(oder "x.notifyAll ()")

223

Page 224: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public class Puffer

{private boolean belegbar = true;

private Object transferObjekt;

public synchronized void legeAb (Object x)

{while (!belegbar)

{wait ();

}transferObjekt = x;

belegbar = false;

notify ();

}

224

Page 225: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public synchronized Object entnehme ()

{while (belegbar)

{wait ();

}belegbar = true;

notify ();

return transferObjekt;

}

} // end class Puffer

225

Page 226: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public class Erzeuger extends Thread

{private Puffer puffer;

public Erzeuger (Puffer puffer) { this.puffer = puffer; }

public void run ()

{while (true)

{Object x = new Position ();

puffer.legeAb (x);

}}

} // end class Erzeuger

226

Page 227: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public class Verbraucher extends Thread

{private Puffer puffer;

public Verbraucher (Puffer puffer) { this.puffer = puffer; }

public void run ()

{while (true)

{Object x = puffer.entnehme ();

// x wird verbraucht.

}}

} // end class Verbraucher

227

Page 228: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public class ErzeugerVerbraucher

{public static void main (String[] arg)

{Puffer puffer = new Puffer ();

Erzeuger erzeuger = new Erzeuger (puffer);

Verbraucher verbraucher = new Verbraucher (puffer);

erzeuger.start ();

verbraucher.start ();

}} // end class ErzeugerVerbraucher

228

Page 229: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Erzeuger – Verbraucher

public class VieleErzeugerVerbraucher

{public static void main (String[] arg)

{Puffer puffer = new Puffer ();

for (int i = 0; i < 10; i++)

{Erzeuger erzeuger = new Erzeuger (puffer);

Verbraucher verbraucher = new Verbraucher (puffer);

erzeuger.start ();

verbraucher.start ();

}}

} // end class VieleErzeugerVerbraucher

229

Page 230: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��notify – notifyAll

Im Zweifelsfall sollte anstatt von

notify ()

notifyAll ()

verwendet werden!!!(Aber siehe ausfuhrliche Diskussion spater.)

230

Page 231: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��RingPuffer

Erzeuger

Verbraucher

XXXenqueue (X) dequeue ()

groesse - 1 0

tail head

anzahl

231

Page 232: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse RingPuffer

private Object[] f;

private int groesse;

private int anzahl = 0;

private int tail = 0;

private int head = -1;

232

Page 233: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konstruktor

public RingPuffer (int groesse)

{this.groesse = groesse;

f = new Object[groesse];

}

233

Page 234: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methode enqueue (Object ob)

synchronized public void enqueue (Object ob)

{while (anzahl >= groesse) wait ();

f[tail] = ob;

anzahl = anzahl + 1;

tail = tail + 1;

if (tail == groesse) tail = 0;

notifyAll ();

}

234

Page 235: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Methode dequeue ()

synchronized public Object dequeue ()

{while (anzahl == 0) wait ();

anzahl = anzahl - 1;

head = head + 1;

if (head == groesse) head = 0;

notifyAll ();

return f[head];

}

235

Page 236: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel: Emulation von Semaphoren

Semaphor

# zaehler :intcstr (:int)p ()v ()# zaehlHoch ()# zaehlRunter ()

AllgemeinerSemaphor

# zaehlHoch ()# zaehlRunter ()

BinaererSemaphor

cstr (:boolean)# zaehlHoch ()# zaehlRunter ()

236

Page 237: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel: Emulation von Semaphoren

public abstract class Semaphor

{public Semaphor (int zaehler) { ... }

public synchronized void p () { ... }public synchronized void v () { ... }

protected int zaehler;

protected abstract void zaehlHoch ();

protected abstract void zaehlRunter ();

}

237

Page 238: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel: Emulation von Semaphoren

public abstract class Semaphor

{public Semaphor (int zaehler)

{if (zaehler < 0) this.zaehler = 0;

else this.zaehler = zaehler;

}

238

Page 239: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel: Emulation von Semaphoren

public synchronized void p ()

{while (zaehler == 0)

{try { wait (); } catch (InterruptedException e) {}}

zaehlRunter ();

}public synchronized void v ()

{zaehlHoch ();

notify ();

}

239

Page 240: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel: SchweissRoboter

// ArmThread

public void run ()

{while (true)

{r.uB ();

r.s1.p ();

r.kP ();

r.s2.v ();

}}

|

|

|

|

|

|

|

|

|

|

|

// SchweissThread

public void run ()

{while (true)

{r.uV ();

r.s2.p ();

r.kS ();

r.s1.v ();

}}

240

Page 241: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Damonen

• Lauft immer im Hintergrund.

• Java-Interpreter wird verlassen, wenn alle Threads, dienicht Damonen sind, aufgehort haben zu laufen.

• setDaemon (boolean x) (vor Thread-Start) undisDaemon ()

• Sparsame Verwendung sei empfohlen.

241

Page 242: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread Safety

Thread-Sicherheit bedeutet, dass die Datenelemente einesObjekts oder einer Klasse immer einen korrekten oder kon-sistenten Zustand haben aus der Sicht anderer Objekteoder Klassen, auch wenn von mehreren Threads gleichzei-tig zugegriffen wird.

242

Page 243: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread Safety

Was kann man tun? Drei Moglichkeiten:

1. Kritische Bereiche erhalten ein synchronized.

2. Die Datenelemente werden unveranderbar (final) ge-macht (immutable objects).

3. Man benutzt einen Thread-sicheren Wrapper.

243

Page 244: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Kritische Bereiche

synchronized ist notwendig, wenn mehrere Threads auf gemeinsame

Daten (Objekte) zugreifen und mindestens ein Thread diese Daten

(Objekte) verandert. Alle Methoden, die auf die Daten (Objekte)

zugreifen, mussen als synchronized deklariert werden unabhangig

davon, ob nur gelesen oder auch verandert wird.

Methoden-Aufrufe anderer Objekte sollten nicht in einer

synchronized Umgebung erfolgen.

244

Page 245: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread Safety

Warum nicht alles einfach synchronized?

1. Synchronisierte Methoden-Aufrufe sind etwa 5 mallangsamer als nicht-synchronisierte Aufrufe.

2. Unnotige Synchronisationen (etwa bei Lesezugriffen)haben uberflussiges Blockieren von Threads zur Folge.

3. Immer besteht die Gefahr eines Deadlocks.

4. Ein Codestuck mit mehreren synchronisierten Aufrufenist trotzdem nicht Thread-sicher.

245

Page 246: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread Safety

if (!vector.contains (element))

{vector.add (element);

}

246

Page 247: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread Safety

synchronized (vector)

{if (!vector.contains (element))

{vector.add (element);

}}

247

Page 248: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��volatile Variable

Wenn es nur darum geht, Variable fur andere Threadssichtbar zu machen (und nicht um Atomizitat) (se-quential consistency), dann kann– als mildere Form der Synchronisation –die Variable als volatile deklariert werden.

248

Page 249: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��final Variable

Alle Datenelemente sollten final deklariert werden, es seidenn, dass sie veranderlich sein sollen.

Achtung: final Referenzen!

249

Page 250: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln

Wenn durch einen Methodenaufruf der Zustand eines Objekts

verandert wird und diese Anderung nur erfolgen darf, wenn eine

gewisse Wartebedingung nicht mehr vorliegt, dann hat diese

Methode folgende Form:

synchronized void methode ()

{while (Wartebedingung)

{wait ();

}// Mach Zustandsanderung.

}

250

Page 251: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln

Wenn eine Zustandsanderung dazu fuhrt, dass eventuell wartende

Threads weiterlaufen konnen, muss ein notify oder allgemeiner ein

notifyAll gegeben werden:

synchronized void methode ()

{// Mach Zustandsanderung.

notifyAll ();

}

251

Page 252: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln

synchronized void methode ()

{while (Wartebedingung)

{wait ();

}

// Mach Zustandsanderung.

notifyAll ();

}

252

Page 253: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln

Nach rein lesenden Zugriffen muss grundsatzlichkein Thread geweckt werden (also kein notify odernotifyAll).

253

Page 254: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Spurious Wakeup

254

Page 255: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Timeout

Timeout ”0” bedeutet ”kein Timeout”, also unendlichlanges Warten.

Timeout-Flag.

255

Page 256: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Zusammenfassung wait, notify, notifyAll

1. wait, notify, notifyAll in Sync

2. while (Wartebedingung) wait ();

3. Sync muss notify oder notifyAll haben, wenn es mindestens

ein wait gibt und wenn das Sync die Wartebedingung eines

waits moglicherweise false macht.

4. Ein notify genugt, wenn die Anwendung so ist, dass hochstens

ein Thread die wait-Warteschlange verlassen soll.

5. In allen anderen Fallen: notifyAll

256

Page 257: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��notify oder interrupt ?

x.notify () gibt irgendeinen Thread aus der wait-Warteschlange fur x

frei.

t.interrupt () gibt genau den Thread t aus einer wait-Warteschlange frei.

x.notify () kann nur in einer bezuglich x synchronized Umgebungaufgerufen werden. Abgesehen davon, dass man einen Monitor-Kontextbraucht, ist notify performanter als interrupt, da keine Exception geworfenwird.

notify ”verpufft” wirkungslos, wenn sich kein Thread in der wait-Warteschlange befindet.interrupt ”verpufft” nicht.

t.interrupt weckt einen Thread t auch aus einem sleep oder join.Bei t.interrupt wird eine InterruptedException geworfen.

257

Page 258: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Verklemmungen

Vorranggraph:

T1 T2

T3

T4

T5

T6

258

Page 259: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Verklemmungen: Strategien

• Voranforderungsstrategie

• Anforderung nach einer vorgegebenen Reihenfolge

• Anforderung von Betriebsmitteln mit Bedarfsanalyse

259

Page 260: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Verklemmung von Zugen

260

Page 261: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln: Prioritat

Faustregeln:

• Prio (kleine Prozesszeit) > Prio (große Pro-zesszeit)

• Prio (I/O-intensiv) > Prio (rechen-intensiv)

Grundsatz:

• Korrektheit unabhangig von Prioritat!

261

Page 262: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Entwurfs-Regeln: Prioritat

Prioritat Thread-Typ

10 Krisen-Management7 – 9 interaktiv, ereignisgesteuert4 – 6 I/O-abhangig2 – 3 Berechnung im Hintergrund

1 wenn wirklich nichts anderes ansteht

262

Page 263: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Kapselung durch Komposition

public class MeinThread

{private Thread task;

MeinThread ()

{task = new Thread (new MeinRunnable ());

task.start ();

}private class MeinRunnable implements Runnable

{public void run ()

{// ...

}}

}

263

Page 264: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Komposition kompakter

public class MeinThread

{MeinThread ()

{new Thread

(

new Runnable ()

{public void run ()

{// ...

}}

).start ();

}}

264

Page 265: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vorzeitige Objekt-Veroffentlichung

Wenn ein Objekt innerhalb seines Konstruktors irgend-wo veroffentlicht wird (z.B. durch Registrierung des Ob-jekts oder durch Starten eines Threads, der das Objektbenutzt), dann kann es passieren, dass das Objekt benutztwird, ehe es vollstandig konstruiert ist.

265

Page 266: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vorzeitige Objekt-VeroffentlichungAbhilfe:

class Klasse extends Thread

{protected String a;

protected Klasse () { a = "SuperKlasse"; }

protected Klasse publish ()

{start (); // Starte als Thread oder registriere irgendwo

return this;

}

public static Klasse newInstance ()

{return new Klasse ().publish ();

}// ...

266

Page 267: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Zeitliche Auflosung

void Thread.sleep (long ms)

void thr.join (long ms)

void ob.wait (long ms)

long System.currentTimeMillis ()

long System.nanoTime ()

267

Page 268: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��JVMPI

Java Virtual Machine Profile Interface

268

Page 269: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Adhoc-Thread

//... sequentiell

//... nun adhoc-Thread:

new Thread ()

{public void run ()

{//... paralleler Code

}}.start ();

//... ab jetzt zwei Threads

269

Page 270: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread-sichere API-Klassen

Thread-sicher:java.util.Vector

java.util.Hashtable

Nicht Thread-sicher:java.util.ArrayList

java.util.HashMap

java.util.Collections.synchronizedList (List<E> x)

270

Page 271: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Timer, TimerTask

public class Timer

{public Timer (String name, boolean isDaemon);

public void cancel (); // Beendet den Timer.

// Eingeplante Tasks werden ausgeplant.

public int purge (); // Entfernt alle ausgeplanten TimerTasks.

public void schedule (TimerTask task, Date time);

public void schedule (TimerTask task, Date firstTime, long period);

public void schedule (TimerTask task, long delay);

public void schedule (TimerTask task, long delay, long period);

public void scheduleAtFixedRate (TimerTask task,

Date firstTime, long period);

public void scheduleAtFixedRate (TimerTask task,

long delay, long period);

}

271

Page 272: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��TimerTask

public abstract class TimerTask implements Runnable

{public TimerTask ();

public boolean cancel (); // Task wird ausgeplant.

// Wenn die Task gerade lauft,

// lauft sie zu Ende.

public abstract void run ();

public long scheduledExecutionTime ();

}

272

Page 273: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread-Pools

Vermeidung des Thread-Start-OverheadsBegrenzung der Anzahl der Threads

public interface Executor

{void execute (Runnable task);

}

273

Page 274: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread-Pools

ThreadPoolExecutor bietet viele Moglichkeiten.

Bequem:

ExecutorService es

= Executors.newFixedThreadPool (int anz);

274

Page 275: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

public class Task

implements Runnable

{private String name;

private int wartezeit;

public Task (String name, int wartezeit)

{this.name = name;

this.wartezeit = wartezeit;

}

public void run ()

{System.out.println ("Task " + name + " beginnt um "

+ System.currentTimeMillis () + ".");

try

{Thread.sleep (wartezeit);

}catch (InterruptedException e ) {}

System.out.println ("Task " + name + " ist fertig um "

+ System.currentTimeMillis () + ".");

}}

275

Page 276: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

import java.util.concurrent.*;

public class ExecuteTask

{public static void main (String[] arg)

{ExecutorService executor

= Executors.newFixedThreadPool (3);

// Wir erzeugen einen Thread-Pool mit 3 Threads.

int sumWartezeit = 1000;

// Wir summieren alle Wartezeiten, damit wir

// wissen, wann wir den executor schließen konnen.

java.util.Random zufall = new java.util.Random ();

for (int i = 0; i < 10; i++)

{String name = "" + i;

int wartezeit = zufall.nextInt (1000);

sumWartezeit = sumWartezeit + wartezeit;

Runnable task = new Task (name, wartezeit);

// Tasks werden erzeugt

System.out.println ("Task " + name +

" mit Wartezeit " + wartezeit

+ " wird an den Threadpool ubergeben.");

executor.execute (task);

// Tasks werden dem Executor ubergeben.

}

try

{Thread.sleep (sumWartezeit);

executor.shutdown ();

executor.awaitTermination (sumWartezeit,

TimeUnit.MILLISECONDS);

}catch (InterruptedException e) {}

}}

276

Page 277: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Task 0 mit Wartezeit 406 wird hinzugefugt.

Task 1 mit Wartezeit 935 wird hinzugefugt.

Task 2 mit Wartezeit 247 wird hinzugefugt.

Task 3 mit Wartezeit 993 wird hinzugefugt.

Task 4 mit Wartezeit 402 wird hinzugefugt.

Task 5 mit Wartezeit 839 wird hinzugefugt.

Task 6 mit Wartezeit 14 wird hinzugefugt.

Task 7 mit Wartezeit 131 wird hinzugefugt.

Task 8 mit Wartezeit 613 wird hinzugefugt.

Task 9 mit Wartezeit 229 wird hinzugefugt.

Task 0 beginnt um 1103561602040.

Task 1 beginnt um 1103561602040.

Task 2 beginnt um 1103561602040.

Task 2 ist fertig um 1103561602280.

Task 3 beginnt um 1103561602280.

Task 0 ist fertig um 1103561602441.

Task 4 beginnt um 1103561602441.

Task 4 ist fertig um 1103561602841.

Task 5 beginnt um 1103561602841.

Task 1 ist fertig um 1103561602971.

Task 6 beginnt um 1103561602971.

Task 6 ist fertig um 1103561602981.

Task 7 beginnt um 1103561602981.

Task 7 ist fertig um 1103561603122.

Task 8 beginnt um 1103561603122.

Task 3 ist fertig um 1103561603272.

Task 9 beginnt um 1103561603272.

Task 9 ist fertig um 1103561603502.

Task 5 ist fertig um 1103561603682.

Task 8 ist fertig um 1103561603732.

277

Page 278: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.Semaphore

Semaphore (int permits)

Semaphore (int permits, boolean fair)

278

Page 279: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.Semaphore

void acquire ()

void acquire (int permits)

void acquireUninterruptibly ()

void acquireUninterruptibly (int permits)

279

Page 280: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.Semaphore

boolean tryAcquire ()

boolean tryAcquire (int permits)

boolean tryAcquire (long timeout, TimeUnit unit)

boolean tryAcquire (int permits, long timeout,

TimeUnit unit)

280

Page 281: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.Semaphore

void release ()

281

Page 282: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.Semaphore

Beispiel Postschalter

282

Page 283: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.locks.Lock

Lock s = ...;

s.lock ();

try

{// Verwendung des geschutzten

// Betriebsmittels

}finally

{s.unlock ();

}

283

Page 284: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Lock s = ...;

try

{s.lockInterruptibly ();

try

{// Verwendung des geschutzten Betriebsmittels

}finally

{s.unlock ();

}}catch (InterruptedException e)

{System.err.println ("Thread bekam interrupt.");

}

284

Page 285: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Lock s = ...;

if (s.tryLock (200, TimeUnit.MILLISECONDS))

{try

{// Verwendung des geschutzten Betriebsmittels

}finally

{s.unlock ();

}}

else

{// Tu was anderes ...

}

285

Page 286: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Interface Lock

public Interface Lock

{void lock ();

void lockInterruptibly () throws InterruptedException;

Condition newCondition ();

boolean tryLock ();

boolean tryLock (long time, TimeUnit unit);

void unlock ();

}

286

Page 287: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Lock wird realisiert von:

• ReentrantLock• ReentrantReadWriteLock.ReadLock• ReentrantReadWriteLock.WriteLock

287

Page 288: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.locks.Lock

ReadWriteLock rwl

= new ReentrantReadWriteLock ();

Lock readLock = rwl.readLock ();

Lock writeLock = rwl.writeLock ();

288

Page 289: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��java.util.concurrent.locks.Lock

Kompatibilitats-Matrix:

readLock writeLock

readLock ja neinwriteLock nein nein

289

Page 290: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��newCondition

Lock s = new ...

Condition c = s.newCondition ();

s.lock ();

try

{// ...

c.await ();

// ...

c.signal ();

// ...

c.signalAll ();

// ...

}finally { s.unlock (); }

290

Page 291: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CyclicBarrier

CyclicBarrier (int parties)

CyclicBarrier (int parties,

Runnable barrierAction)

291

Page 292: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CyclicBarrier

void await ()

void await (long timeout, TimeUnit unit)

292

Page 293: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

barrierAction

Task 1run

{barrier.await ()}

Task 2run

{barrier.await ()}

Task 3run

{barrier.await ()}

Task 1continue

Task 2continue

Task 3continue

293

Page 294: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CyclicBarrier

Beispiel: Roboter-Achsen

294

Page 295: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CountDownLatch

CountDownLatch (int count)

void await ()

void await (long timeout, TimeUnit unit)

void countDown ()

int getCount ()

295

Page 296: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

T1run

{await}

T2run

{await}

T3run

{await}

T4run

{count-down}

T5run

{count-down}

T1cont.

T2cont.

T3cont.

T4cont.

T5cont.

296

Page 297: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CountDownLatch

Beispiel: Arbeiter und Chef

297

Page 298: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Exchanger<V>

Exchanger<V> exch = new Exchanger<V> ();

Task 1 Task 2

// ... | // ...

// ... | V v2 = ...

V v1 = ... | // ...

v1 = exch.exchange (v1); | v2 = exch.exchange (v2);

// v1 ist nun das v2 | // v2 ist nun das v1

// von rechts. | // von links.

298

Page 299: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

Task 1run

{v1 = exch.

exchange (v1)}

Task 2run

{v2 = exch.

exchange (v2)}

Task 1continue

Task 2continue

v1 v2

v1v2

299

Page 300: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Exchanger<V>

Beispiel: Tonerkassette

300

Page 301: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

FutureTask<Result>

:FutureTask

client

<<create>>

start ()

get () :Result

301

Page 302: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

FutureTask<Result>

:FutureTask

client

<<create>>

start ()

get () :Result

302

Page 303: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��FutureTask<Result>

public class Vorausberechnung

{public Resultat berechne () { ... return aResultat; }public FutureTask<Resultat> future

= new FutureTask<Resultat>

(

new Callable<Resultat> ()

{public Resultat call ()

{return berechne ();

}}

);

303

Page 304: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��FutureTask<Result>

public static void main (String[] arg)

{Vorausberechnung vb = new Vorausberechnung ();

new Thread (vb.future).start ();

// ...

// Tut Dinge, fur die das Resultat noch nicht benotigt wird.

// ...

Resultat r = vb.future.get ();

}}

304

Page 305: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Interface java.util.Queue<E>

public interface Queue<E>

{boolean add (E e) throws IllegalStateException;

E element () throws NoSuchElementException;

boolean offer (E e);

E peek ();

E poll ();

E remove () throws NoSuchElementException;

}

305

Page 306: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Interface BlockingQueue<E>

package java.util.concurrent;

public interface BlockingQueue<E>

{boolean offer (E e, long time, TimeUnit unit);

void put (E e);

E poll (long time, TimeUnit unit);

E take ();

// und weitere Methoden

}

306

Page 307: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Queues

Schnittstelle BlockingQueue

ArrayBlockingQueue

DelayQueue

LinkedBlockingQueue

PriorityBlockingQueue

SynchronousQueue

307

Page 308: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��ArrayBlockingQueue<E>

public ArrayBlockingQueue<E> (int capacity)

public ArrayBlockingQueue<E> (int capacity,

boolean fair)

public void clear ()

308

Page 309: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Atomare Variable

package java.util.concurrent.atomic;

AtomicInteger

AtomicLong

AtomicReference<V>

...

309

Page 310: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Atomare Variable

int addAndGet (int delta)

int getAndAdd (int delta)

int decrementAndGet ()

int getAndDecrement ()

int incrementAndGet ()

int getAndIncrement ()

int getAndSet (int newValue)

boolean compareAndSet (int expect, int update)

310

Page 311: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Thread-sichere Collections

List<E> liste

= Collections.synchronizedList (

new ArrayList<E> ());

Map<K, E> map

= Collections.synchronizedMap (

new HashMap<K, E> ());

311

Page 312: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schwach Thread-sichere Collections

ConcurrentHashMap

Thread-sicher:get, put, containsKey, remove, putIfAbsent, replace

Nicht Thread-sicher:size, isEmpty

lock striping

312

Page 313: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schwach Thread-sichere Collections

CopyOnWriteArrayList

CopyOnWriteArraySet

313

Page 314: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��GUI-Frameworks

• single-threaded:event dispatch threadProblem: responsivenessDaher schnelle Ereignisbehandlung oderAuslagerung in eigene Thread.

•Multithreaded Frameworks hatten immer Probleme mitgegenseitigem Ausschluss und Deadlocks.

314

Page 315: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

315

Page 316: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ein- und Ausgabestrome

• Abstrakte Stream-Basis-Klassen:InputStream bzw. OutputStream

•Methode close ()

• Reziproke read- und write-Methoden

316

Page 317: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse InputStream

• int read ()

• int read (byte[] b)

• int read (byte[] b, int von, int anz)

• Alle read-Methoden warten (block), bis ihre Einlese-forderung befriedigt ist oder das Ende des Stroms er-reicht ist.

• int available ()

• skip (long n)

• Objekt System.in ist Standard-Eingabe.

317

Page 318: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse OutputStream

• void write (int b) Schreibt ein Byte!

• void write (byte[] b)

• void write (byte[] b, int von, int anz)

• Alle write-Methoden warten (block) bis alles ge-schrieben ist.

• void flush ()

318

Page 319: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��ByteArrayInputStream

byte[] feld = new byte[256];

// fulle feld mit sinnvollen Daten

ByteArrayInputStream s1

= new ByteArrayInputStream (feld);

// oder

InputStream s2

= new ByteArrayInputStream (feld, 47, 127);

• reset ()

319

Page 320: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��ByteArrayOutputStream

• ByteArrayOutputStream ()

• ByteArrayOutputStream (int groesse)

• reset ()

• int size () Gibt Anzahl der geschriebenen Bytes.

• public synchronized byte[] toByteArray ()

• public String toString ()

• public String toString (int oberesByte)

320

Page 321: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Datei-Strome

• FileInputStream (String dateiname)

• FileInputStream (File datei)

• FileInputStream (FileDescriptor fd)

• FileOutputStream hat entsprechende Konstruktoren.

• FileDescriptor getFD ()

321

Page 322: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Filter-Klassen

• FilterInputStream (InputStream s)

• FilterOutputStream (OutputStream s)

•Methoden emulieren ubergebene Stream-Klassen.

• Subklassen konnen Methoden sinnvoll uberschreiben.

322

Page 323: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

1. Filter, das jedes Leerzeichen durch ein ”e” ersetzt.

2. Filter, das jedes ”e” entfernt.

323

Page 324: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

public static void main (String[] argument)

{String text = "Das Wetter ist heute besonders schon.";

byte[] feld = new byte[text.length ()];

for (int i = 0; i < feld.length; i++)

feld[i] = (byte)text.charAt (i);

InputStream s = new ByteArrayInputStream (feld); gibStreamAus (s);

InputStream s1 = new FilterBlankZuKleinE (s); gibStreamAus (s1);

InputStream s2 = new FilterEntferntKleinE (s); gibStreamAus (s2);

InputStream s3 = new FilterBlankZuKleinE (s2); gibStreamAus (s3);

InputStream s4 = new FilterEntferntKleinE (s1); gibStreamAus (s4);

}

324

Page 325: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

class FilterBlankZuKleinE extends FilterInputStream

{public FilterBlankZuKleinE (InputStream s)

{super (s);

}

public int read () throws IOException

{int c = super.read ();

if (c == ’ ’) return ’e’;

else return c;

}}

325

Page 326: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

class FilterEntferntKleinE extends FilterInputStream

{public FilterEntferntKleinE (InputStream s)

{super (s);

}

public int read () throws IOException

{int c = super.read ();

while (c == ’e’) c = super.read ();

return c;

}}

326

Page 327: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Resultat Beispiel

Das Wetter ist heute besonders schon.

DaseWettereisteheuteebesonderseschon.

Das Wttr ist hut bsondrs schon.

DaseWttreistehutebsondrseschon.

DasWttristhutbsondrsschon.

327

Page 328: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Gepufferte Strome

public BufferedInputStream (InputStream s);

public BufferedInputStream (InputStream s, int groesse);

public BufferedOutputStream (OutputStream s);

public BufferedOutputStream (OutputStream s, int groesse);

• erben von den entsprechenden Filterstromen

• public synchronized void mark (int leseGrenze)

• public synchronized void reset () throws IOException

328

Page 329: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Data-Strome

• DataInputStream• DataOutputStream• implementieren SchnittstelleDataInput bzw. DataOutput

•Methoden zur Ein- bzw. Ausgabe der Bit-Sequenzen(d.h. keine formatierte oder textuelle Ausgabe als Zei-chenkette) von Standardtypen

• Lesemethoden werfen EOFException, wenn das Datei-ende erreicht ist.

329

Page 330: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

try

{while (true)

{int i = s.readInt ();

// verarbeite i

}}

catch (EOFException e)

{// Stream-Ende wurde erreicht. Da muss man nichts tun.

}catch (IOException e)

{// Eingabefehler ist aufgetreten. Da muss man irgendetwas machen.

}

330

Page 331: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Pipe-Verbindung

PipedInputStream ein;

PipedOutputStream aus;

aus = new PipedOutputStream ();

ein = new PipedInputStream ();

aus.connect (ein);

oder

PipedInputStream ein = new PipedInputStream ();

PipedOutputStream aus = new PipedOutputStream (ein);

oder umgekehrt.

331

Page 332: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Konkatenierung von Streams

public SequenceInputStream (InputStream a, InputStream b);public SequenceInputStream (Enumeration e);

InputStream s1, s2, s3;

Vector v = new Vector ();

v.addElement (s1);

v.addElement (s2);

v.addElement (s3);

InputStream s = new SequenceInputStream (v.elements ());

332

Page 333: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse RandomAccessFile

• implementiert DataInput und DataOutput

• Konstruktoren:public RandomAccessFile (String dateiname, String modus);

public RandomAccessFile (File datei, String modus);

• modus kann entweder "r" oder "rw" sein.

• public long length () Lange der Datei

• public void seek (long pos) Positionierung desLese- oder Schreibzeigers.

333

Page 334: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse File

Objekte der Klasse File reprasentieren Dateien oderVerzeichnisse. Es werden die typischen Betriebssystem-Funktionen eines Datei-Managers als Methoden zurVerfugung gestellt.

334

Page 335: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��char-Streams

Reader Writer

BufferedReader BufferedWriter

LineNumberReader

CharArrayReader CharArrayWriter

InputStreamReader OutputStreamWriter

FileReader FileWriter

FilterReader FilterWriter

PushbackReader

PipedReader PipedWriter

StringReader StringWriter

PrintWriter

335

Page 336: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��BufferedReader

Eine sehr nutzliche Methode von BufferedReader ist:

public String readLine () throws IOException;

336

Page 337: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��PrintStream und PrintWriter

• Textuelle Ausgabe von Standard- und Referenztypen.

• PrintWriter ist vorzuziehen.

• print () und println ()

•Methode toString () wird dabei verwendet.

• Objekte System.out und System.err

sind PrintStreams.

337

Page 338: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

338

Page 339: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse URL

•Uniform Resource Locator

• URL url = new URL (urlAdresse);

• urlAdresse = file:/var/home/kfg/dy.java

oderurlAdresse = http://www.ba-stuttgart.de/~kfg/dy.java

• (String)(url.getContent ())

• c.createImage ((ImageProducer)(url.getContent ()))

• InputStream ein = url.openStream ();

339

Page 340: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse URLconnection

• URLconnection uc = url.openConnection ();

• InputStream ein = uc.getInputStream ();

• OutputStream aus = uc.getOutputStream ();

• Ermittlung von Datei-Informationen

340

Page 341: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Datagramme

•UDP – universal datagram protocol

• Klassen DatagramPacket und DatagramSocket

• Senden:

InetAddress adr = InetAddress.getByName (argument[0]);

DatagramPacket paket = new DatagramPacket

(botschaft, botschaft.length, adr, port);

DatagramSocket socket = new DatagramSocket ();

socket.send (paket);

341

Page 342: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Datagramme

• Empfangen:byte[] botschaft = new byte[256];

DatagramPacket paket = new DatagramPacket

(botschaft, botschaft.length);

DatagramSocket socket = new DatagramSocket (port);

socket.receive (paket);

342

Page 343: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Client/Server

• Fur eine zuverlassige (TCP – reliable) Verbindung zwischen

Client und Server wird die Klasse Socket verwendet.

• Objekte der Klasse ServerSocket warten auf Verbindungsan-

forderungen und liefern im Falle einer Verbindung neue Socket-

Objekte zur Kommunikation mit dem Client.

• Der Server ist multithreaded.

• Der Client erzeugt einen Socket:

Socket s = new Socket (adresse, port);

InputStream ein = s.getInputStream ();

OutputStream aus = s.getOutputStream ();

343

Page 344: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Dienst

public class Dienst extends Thread

{public static void main (String[] argument)

{int lokalerPort = Integer.parseInt (argument[0]);

new Dienst (lokalerPort);

}

protected ServerSocket dienstSocket;

344

Page 345: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Dienst

public Dienst (int lokalerPort)

{dienstSocket = new ServerSocket (lokalerPort);

this.start ();

}

public void run ()

{while (true)

{Socket kundenSocket = dienstSocket.accept ();

Verbindung v = new Verbindung (kundenSocket);

}}

}

345

Page 346: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Verbindung

class Verbindung extends Thread

{protected Socket kundenSocket;

protected BufferedReader ein;

protected PrintWriter aus;

public Verbindung (Socket kundenSocket)

{this.kundenSocket = kundenSocket;

ein = new BufferedReader (new InputStreamReader (

kundenSocket.getInputStream ()));

aus = new PrintWriter (new OutputStreamWriter (

kundenSocket.getOutputStream ()));

this.start ();

}

346

Page 347: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Verbindung

public void run ()

{String zeile;

while ((zeile = ein.readLine ()) != null)

{aus.print ("Naturlich ");

aus.println (zeile.replace (’?’, ’.’));

aus.flush ();

if (zeile.equals ("quit")) break;

}}

}

347

Page 348: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Kunde

public class Kunde

{public static void main (String[] argument)

{int entfernterPort = Integer.parseInt (argument[1]);

Socket s = new Socket (argument[0], entfernterPort);

BufferedReader sein =

new BufferedReader (

new InputStreamReader (s.getInputStream ()));

PrintWriter saus =

new PrintWriter (

new OutputStreamWriter (s.getOutputStream ()));

BufferedReader eingabe =

new BufferedReader (

new InputStreamReader (System.in));

348

Page 349: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Kunde

while (true)

{System.out.println ("Eingabe der Frage:");

System.out.print ("> ");

System.out.flush ();

String frage = eingabe.readLine ();

saus.println (frage); saus.flush ();

System.out.println ("Antwort:");

String antwort = sein.readLine ();

if (antwort == null) break;

System.out.println (antwort);

if (frage.equals ("quit")) break;

}}

}

349

Page 350: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse KundeApplet

public class KundeApplet extends Applet

implements ActionListener

{int entfernterPort = DEFAULTPORT;

PrintWriter saus;

BufferedReader sein;

Socket s;

TextField textFeld;

TextArea textBereich;

Empfaenger empfaenger;

350

Page 351: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse KundeApplet

public void init ()

{entfernterPort = Integer.parseInt (

getParameter ("Port"));

s = new Socket (this.getCodeBase ().getHost (),

entfernterPort);

sein = new BufferedReader (

new InputStreamReader (s.getInputStream ()));

saus = new PrintWriter (

new OutputStreamWriter (s.getOutputStream ()));

351

Page 352: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse KundeApplet

this.setLayout (new BorderLayout ());

Panel panel = new Panel ();

Label eingabe = new Label ("Eingabe der Frage: ", Label.LEFT);

panel.add (eingabe);

textFeld = new TextField (40);

textFeld.addActionListener (this);

panel.add (textFeld);

this.add ("North", panel);

textBereich = new TextArea ();

this.add ("Center", textBereich);

empfaenger = new Empfaenger (this, sein, textBereich);

}

352

Page 353: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse KundeApplet

public void actionPerformed (ActionEvent e)

{if (e.getSource () == textFeld)

{saus.println (e.getActionCommand ()); saus.flush ();

textFeld.setText ("");

}}

}

353

Page 354: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Empfaenger

class Empfaenger extends Thread

{Applet applet;

BufferedReader ein;

TextArea aus;

public Empfaenger (Applet applet, BufferedReader sein,

TextArea textBereich)

{this.applet = applet;

ein = sein;

aus = textBereich;

this.start ();

}

354

Page 355: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Empfaenger

public void run ()

{String zeile;

while ((zeile = ein.readLine ()) != null)

{aus.setText (zeile);

if (zeile.endsWith ("quit"))

{applet.stop ();

return;

}}

}}

355

Page 356: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische Benutzeroberflachen

Vererbung AppletsAusnahmebehandlung Datenbankanbindung

356

Page 357: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��AWT und Swing

• Swing ist Teil von JFC.

• Swing baut auf AWT auf.

• Swing benutzt MVC-Design.

• Swing ist flexibler, großer, protabler als AWT.

• Swing ist schneller und weniger Speicher-intensiv alsAWT.

• Swing-Komponenten beginnen mit J.

357

Page 358: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Graphische Benutzeroberflachen

•Komponenten (component) JComponent

• Behalter (container) Container

• Hierarchie: Behalter ist auch Komponente.

• Anordnung mit Layout-Managern

• Anwendungsprogramme gehen von JFrame,

• Applets erben JApplet .

358

Page 359: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Layout-Manager von AWT

• FlowLayout• GridLayout• GridBagLayout• BorderLayout• CardLayout• Setzen eines Layout-Managers mit MethodesetLayout (new FlowLayout ());

359

Page 360: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Layout-Manager von Swing

• BoxLayout• OverlayLayout• ScrollPaneLayout• ViewportLayout

360

Page 361: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��FlowLayout

• Anordnung zeilenweise

• Default zentriert

• Bundigkeit:FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER

• Konstruktor:FlowLayout (

Bundigkeit, Horizontal-, Vertikalabstand)

361

Page 362: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��GridLayout

• Konstruktor:GridLayout (

Zeilen, Spalten, Horizontal-, Vertikalabstand)

362

Page 363: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��BorderLayout

NORTH

WEST CENTER EAST

SOUTH

• Konstruktor: BorderLayout (Horizontal-, Vertikalabstand)

• add (new JButton ("Nord"), BorderLayout.NORTH);

363

Page 364: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CardLayout

JPanel karten = new JPanel ();

CardLayout kartenLayout = new CardLayout ();

karten.setLayout (kartenLayout);

JPanel karte1 = new JPanel ();

String nameKarte1 = "Knopfe";

// Fulle karte1 mit Knopfen oder ahnlichem

karten.add (nameKarte1, karte1);

JPanel karte2 = new JPanel ();

String nameKarte2 = "Textfelder";

// Fulle karte2 mit Textfeldern oder ahnlichem

karten.add (nameKarte2, karte2);

364

Page 365: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��CardLayout

kartenLayout.first (karten);

kartenLayout.next (karten);

kartenLayout.previous (karten);

kartenLayout.last (karten);

kartenLayout.show (karten, nameKarte2);

365

Page 366: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��GridBagLayout

• Zeilen und Spalten

• Komponenten konnen mehrere Zeilen und Spaltenbeanspruchen.

• Zellen gewichtet

• Spezifikation mit GridBagConstraints-Objekt

366

Page 367: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vorgehensweise GridBagLayout

JPanel sack = new JPanel ();

sack.setLayout (new GridBagLayout ());

GridBagConstraints c = new GridBagConstraints ();

// Fur jede Komponente komponente, die zum JPanel sack addiert wird,

// werden die Parameter des GridBagConstraints c gesetzt.

// z.B.

c.gridx = 3;

c.gridy = 4;

// usw

sack.add (komponente, c);

367

Page 368: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��GridBagConstraints

gridx, gridy: Spezifikation der Spalten und Zeilennummer der Zelle begin-nend bei 0 oder RELATIVE (bezuglich zuletzt addierter Komponente).

gridwidth, gridheight: Anzahl Spalten und Zeilen, die die Zelle einnimmt.

fill: Angabe der Art, wie die Komponente die Zelle ausfullen soll (NONE(Default), HORIZONTAL, VERTICAL, BOTH).

ipadx, ipady: Die Minimalgroße der Komponente wird um 2 * ipadx bzw2 * ipady Pixel vergroßert.

insets: Spezifikation des externen Padding durch Angabe eines Insets-Objekt.

anchor: Spezifikation des Ortes innerhalb der Zelle (CENTER (Default), NORTH,NORTHEAST usw).

weightx, weighty: Mit den Gewichten zwischen 0.0 (Default!) und 1.0 wirdspezifiziert, wie ubriger Platz verteilt wird.

368

Page 369: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Insets

public class meinBehaelter extends JPanel

{// ...

public Insets getInsets ()

{return new Insets (17, 8, 20, 5);

// oben, links, unten, rechts

}// ...

}

369

Page 370: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Koordinaten von Komponenten

void setBounds (int x, int y, int breite, int hoehe)

void setBounds (Rectangle r)

void setLocation (int x, int y)

void setLocation (Point p)

void setSize (int breite, int hoehe)

void setSize (Dimension d)

Dimension getScreenSize ()

int getScreenResolution ()

Toolkit.getDefaultToolkit ()

370

Page 371: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Java-Bean

Jede Swing-Komponente ist ein Java-Bean.Z.B. Klasseneigenschaft background:

background {Color, get, set, Color.black}

Der Defaultwert ist Color.blackund es gibt die Methoden:

public Color getBackground ()

public void setBackground (Color farbe)

371

Page 372: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenhierarchie

Toplevel-KlassenObject

(Component)

(Container)

Panel

Applet

JApplet

Window

JWindow

Frame

JFrame

Dialog

JDialog

372

Page 373: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenhierarchie

Komponenten-KlassenObject

(Component)

(Container)

(JComponent)

JComboBox

JLabel

JList

JMenuBar

JPanel

JPopupMenu

JScrollBar

JScrollPane

373

Page 374: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenhierarchie

Komponenten-Klassen(JComponent)

JTable

JTree

JInternalFrame

JOptionPane

JProgressBar

JRootPane

JSeparator

JSlider

JSplitPane

JTabbedPane

374

Page 375: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenhierarchie

Komponenten-Klassen(JComponent)

JToolBar

JToolTip

JViewport

JColorChooser

JTextComponent

JTextArea

JTextField

JPasswordField

JEditorPane

JTextPane

JFileChooser

375

Page 376: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenhierarchie

Komponenten-Klassen(JComponent)

JLayeredPane

JDesktopPane

(AbstractButton)

JToggleButton

JCheckBox

JRadioButton

JButton

JMenuItem

JMenu

JRadioButtonMenuItem

JCheckBoxMenuItem

376

Page 377: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Geerbte Eigenschaften

Von den AWT-Klassen werden viele Eigenschaften geerbt.Fur die Sichtbarkeit interessant sind:

• visible• showing• valid

377

Page 378: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Toplevel-Komponenten

Toplevel-Komponenten sind JWindow, JFrame, JDialogund JApplet.JFrame jf = new JFrame ("Titel");

Container bjf = jf.getContentPane ();

bjf.add (...);

jf.setVisible (true);

jf.setVisible (false);

jf.dispose ();

378

Page 379: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Schnittstelle RootPaneContainer

public Container getContentPane ();

public void setContentPane (Container c);

public Component getGlassPane ();

public void setGlassPane (Component c);

public JLayeredPane getLayeredPane ();

public void setLayeredPane (JLayeredPane c);

public JRootPane getRootPane ();

379

Page 380: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse JRootPane

public JMenuBar getJMenuBar ();

public void setJMenuBar (JMenuBar c);

....................................

______ ____________________________

380

Page 381: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��SwingSet

Suche SwingSet.jar undnimm es in den CLASSPATH, dann

$ java SwingSet

381

Page 382: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel InfoDialog

public class InfoDialog extends JDialog

implements ActionListener

{private JButton knopf;

public static void main (String[] args)

{InfoDialog d = new InfoDialog (

null, "Informations-Dialog Demo",

"Das ist ein Beispiel fur eine\n" +

"graphische Benutzeroberflache.\n");

d.setVisible (true);

}

382

Page 383: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel InfoDialog

public InfoDialog (Frame elter, String titel, String botschaft)

{super (elter, titel, false);

Container c = getContentPane ();

c.setLayout (new BorderLayout (15,15));

MehrzeilenLabel label = new MehrzeilenLabel (botschaft);

c.add (label, BorderLayout.CENTER);

knopf = new JButton ("Weg damit");

knopf.addActionListener (this);

JPanel p = new JPanel ();

p.setLayout (new FlowLayout (FlowLayout.CENTER, 15, 15));

p.add (knopf);

c.add (p, BorderLayout.SOUTH);

this.pack ();

}

383

Page 384: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel InfoDialog

public void actionPerformed (ActionEvent e)

{if (e.getSource () == knopf)

{this.setVisible (false);

this.dispose ();

}

}

384

Page 385: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Weiter Beispiele

• MehrzeilenLabel• JaNeinDialog• AlleKomponenten• RollbaresSchmieren• AlleEreignisse

385

Page 386: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ereignis-Modell

• JDK1.0: Ereignis-Modell basiert auf Vererbung.

• JDK1.1: Ereignis-Modell basiert auf Delegation.

– Es ist leicht zu lernen.

– Saubere Trennung zwischen Anwendungs- und GUI-Code.

– Robuster Ereignis-Behandlungs-Code, ”bei dem der Compiler

schon viel sieht”.

– Gestaltungsmoglichkeiten fur Ereignis-Flusse bzw -

Weiterleitung.

386

Page 387: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ereignis-Modell

• Ereignis-Klassen-Hierarchie beginnt bei:java.util.EventObject

• AWT-Ereignisse leiten sich ab von der Subklasse:java.awt.AWTEvent

• Source und Listener

• EventListener Schnittstelle oder

• EventListener Adapter

387

Page 388: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Registrierung von Empfangern

Source.add<Ereignistyp>Listener

(<Ereignistyp>Listener);

Mehrere Listener sind moglich.

388

Page 389: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ereignis-Klassen

• Daten sind uber set- und get-Methoden zuganglich.

• Bei mehreren Listenern und set-Methode wird Ereig-nis fur jeden Listener kopiert.

• ID-Nummer sollte> java.awt.AWTEvent.RESERVED_ID_MAX sein.

389

Page 390: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Low-Level Ereignisbehandlung

Klasse Component:

• processEvent (AWTEvent e)

• process<X>Event (AWTEvent e)

• enableEvents (long Ereignismaske)

390

Page 391: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ereignis-Testprogramm

public class EreignisTester extends JApplet

implements MouseListener, MouseMotionListener,

FocusListener, KeyListener

{public void init ()

{this.addMouseListener (this);

this.addMouseMotionListener (this);

this.addFocusListener (this);

this.addKeyListener (this);

}public void paint (Graphics g)

{g.drawString ("Mause und Tippe in diesem Fenster!", 20, 20);

g.drawString (botschaft, 20, 50);

}

391

Page 392: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ereignis-Testprogramm

public void mousePressed (MouseEvent e)

{ botschaft = modusTaste (e.getModifiers ())

+ " mousePressed wurde aufgerufen (" + e + ").";

repaint (); }public void mouseReleased (MouseEvent e) { ... }public void mouseEntered (MouseEvent e) { ... }public void mouseExited (MouseEvent e) { ... }public void mouseClicked (MouseEvent e) { ... }public void mouseDragged (MouseEvent e) { ... }public void mouseMoved (MouseEvent e) { ... }public void focusGained (FocusEvent e) { ... }public void focusLost (FocusEvent e) { ... }public void keyPressed (KeyEvent e) { ... }public void keyReleased (KeyEvent e) { ... }public void keyTyped (KeyEvent e) { ... }}

392

Page 393: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

393

Page 394: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Hello-World”-Applet

import java.awt.*;

import javax.swing.*;

public class GutenTagApplet1 extends JApplet

{public void paint (Graphics g)

{super.paint (g);

g.drawString ("Guten Tag", 127, 47);

}}

394

Page 395: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Hello-World”-HTML-Datei

<APPLET code="GutenTagApplet1.class" width=500 height=300>

</APPLET>

395

Page 396: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Hello-World”-Applet – komplizierter

public class GutenTagApplet2 extends JApplet

{protected Font zeichenSatz;

protected int zeichenGroße = 72;

protected Color textFarbe = Color.yellow;

private int ovalx = 20;

private int ovaly = 20;

private int ovalb = 430;

private int ovalh = 200;

private int arcb = 30;

private int arch = 30;

public void init ()

{zeichenSatz = new Font ("sanscerif", Font.BOLD, zeichenGroße);

}

396

Page 397: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��”Hello-World”-Applet – komplizierter

public void paint (Graphics g)

{super.paint (g);

g.setColor (Color.blue);

g.fillRoungRect (ovalx, ovaly, ovalb, ovalh, arcb, arch);

g.setColor (Color.magenta);

for (int i = 0; i < 6; i++)

g.drawRoundRect (ovalx - i, ovaly - i,

ovalb + 2 * i, ovalh + 2 * i, arcb, arch);

g.setColor (textFarbe);

g.setFont (zeichenSatz);

g.drawString ("Guten Tag", ovalx + 25,

ovaly + ovalh / 2 + zeichenGroße / 2);

}

397

Page 398: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Grundlagen

• Ein Applet ist eine Subklasse der Klasse JApplet.

• Der Lebenszyklus eines Applets wird durch dievier Methoden init (), start (), stop () unddestroy () bestimmt.

• repaint (), update (Graphics g)

und paint (Graphics g)

und paintComponent (Graphics g)

398

Page 399: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Graphik-Methoden

• public void repaint ()

public void repaint (long ms)

public void repaint (int x, int y, int width, int height)

public void repaint (long ms, int x, int y, int width, int height)

•public void update (Graphics g)

{g.setColor (getBackground ());

g.fillRect (0, 0, width, height);

g.setColor (getForeground ());

paint (g);

}

• public void paint (Graphics g)

399

Page 400: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Applet-Parameter: Methoden

• public String getParameter (String pn) :Sie gibt den Wert des Parameters mit Namen pn alsString zuruck.

• public String[][] getParameterInfo () : Web-Browsers und Applet-Viewer rufen eventuell diese Me-thode auf, um dem Benutzer die moglichen Parameteranzuzeigen.

• public String getAppletInfo () : Diese Metho-de kann von einer ”Uber”-Dialogbox verwendet werdenund sollte von jedem Applet implementiert werden.

400

Page 401: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Applet-Parameter

public void init ()

{String s = this.getParameter ("Zeichengroße");

try { zeichenGroße = Integer.parseInt (s); }catch (NumberFormatException e) { zeichenGroße = 72; }super.init ();

s = this.getParameter ("Textfarbe");

if (s.equals ("Gelb")) textFarbe = Color.yellow;

else if (s.equals ("Rot")) textFarbe = Color.red;

// ---

401

Page 402: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��HTML-Datei

<APPLET code="GutenTagApplet3"

width=500 height=300>

<PARAM name="Zeichengroße" value="36">

<PARAM name="Textfarbe" value="Grun">

</APPLET>

402

Page 403: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��APPLET-tag-Attribute

codebase

code, object

archive

width, heigth

alt

name

align

vspace, hspace

403

Page 404: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ausschnitt Thread Bewegung

weiter: while (true)

{// ---

while (angehalten)

{try

{sleep (10000);

}catch (InterruptedException e)

{angehalten = false;

}}

if (beendet) break weiter;

// ---

404

Page 405: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ausschnitt Applet Aktiv

public void init ()

{bewegung = new Bewegung ();

bewegung.start ();

bewegung.angehalten = true;

}

public void start ()

{bewegung.angehalten = false;

bewegung.beendet = false;

bewegung.interrupt ();

}

405

Page 406: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ausschnitt Applet Aktiv

public void stop ()

{bewegung.angehalten = true;

}

public void destroy ()

{bewegung.beendet = true;

bewegung.interrupt ();

bewegung.join ();

}

406

Page 407: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Ausschnitt Applet Aktiv

public void paint (Graphics g)

{super.paint (g);

for (int i = 0; i < kreise.size (); i++)

{((Oval) kreise.get (i)).male (g);

}}

407

Page 408: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Inhalt Intensivkurs Java

Einleitung Innere KlassenDatentypen ThreadsOperatoren StreamsKontrollstrukturen Netzwerk-ProgrammierungDie Java-Klasse Graphische BenutzeroberflachenVererbung AppletsAusnahmebehandlung Datenbankanbindung

408

Page 409: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��JDBC und weiter

• JDBC ist ein low-level API → high-level APIMan kann damit SQL-Anweisungen absetzen.

• embedded SQL fur Java

• direkte Abbildung von Tabellen als Java-Klassen(object/relational mapping)

• JDBC, ODBC, ADO.NET

• einstufige, zweistufige Modelle

409

Page 410: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��JDBC-Treiber

• Treiber: Klasse Driver

• Treiber: http://java.sun.com/products/jdbc

• DriverManager.getConnection ()

410

Page 411: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��JDBC-URL

• Standard-Syntax: jdbc:<Subprotokoll>:<Subname>Beispiel: jdbc:postgres://ba-stuttgart.de:47/spielbank

• Registrierung von Subprotokollen:Email an [email protected]

• ODBC:jdbc:odbc:<Datenquellname>[;<Attributname>=<Attributwert>]*

jdbc:odbc:Spielbank;UID=kfg;PWD=Ratatui;CacheSize=20;

411

Page 412: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Treiber laden:

• Class.forName ("TreiberKlassenname");

• Class.forName ("TreiberKlassenname")

.newInstance ();

• System-Eigenschaft jdbc.drivers

412

Page 413: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Verbinding Connection

Class.forName ("org.gjt.mm.mysql.Driver");

String url = "jdbc:mysql://nr5:3306/it96";

Connection verbindung

= DriverManager.getConnection (

url, "Bozo", "hochgeheim");

413

Page 414: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassen fur SQL-Anweisungen

• Statement• PreparedStatement• CallableStatement

414

Page 415: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse Statement

Statement anweisung = verbindung.createStatement ();

ResultSet ergebnis

= anweisung.executeQuery ("SELECT a, b, c FROM tabelle");

while (ergebnis.next ())

{int x = ergebnis.getInt ("a");

String y = ergebnis.getString ("b");

float z = ergebnis.getFloat ("c");

// Tu was mit x, y, z ...

}ergebnis.close ();

anweisung.close ();

verbindung.close ();

415

Page 416: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��execute...

• executeQuery (String sql)

• executeUpdate (String sql)

• execute (String sql)

416

Page 417: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse ResultSet

get<Typ> ("Spaltenname")-Methodenoderget<Typ> (Spaltennummer)-Methoden

ergebnis.next ()

Benannte Kursoren und positionierte Manipulationen sindauch moglich.

417

Page 418: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beliebig lange Datenelemente

SQL: LONGVARBINARY oder LONGVARCHARkann als Stream gelesen werden.

InputStream ein1 = ergebnis.getBinaryStream (spaltennummer);

InputStream ein2 = ergebnis.getAsciiStream (spaltennummer);

Reader ein3 = ergebnis.getUnicodeStream (spaltennummer);

418

Page 419: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse PreparedStatement

PreparedStatement prepAnw

= verbindung.prepareStatement (

"UPDATE SP SET QTY = ? WHERE SNR = ?");

set<Typ> (parameternummer, parameterWert)

Z.B.:

prepAnw.setInt (1, 37);

prepAnw.setString (2, "S3");

execute (), executeQuery (), executeUpdate ()

419

Page 420: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klasse CallableStatement

CallableStatement prozAnw = verbindung.prepareCall (

"{call prozedurName (?, ?)}");prozAnw.setInt (1, 25);

prozAnw.registerOutParameter (1, java.sql.Types.INTEGER);

prozAnw.registerOutParameter (2, java.sql.Types.DECIMAL, 3);

ResultSet rs = prozAnw.executeQuery ();

// Verarbeite rs

int i = prozAnw.getInt (1);

java.math.BigDecimal d = prozAnw.getBigDecimal (2, 3);

420

Page 421: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Transaktionen

• Transaktionen beziehen sich auf die Verbindung(Connection)

• setAutoCommit (boolean)

• commit ()

• rollback ()

• setTransactionIsolation (int)

421

Page 422: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Objekt-Serialisierung

• Kodierung von Objekten in Byte-Strome

• Kodierung von Byte-Stromen in Objekte

• kompletter Objektgraph

• Serializable oder Externalizable

422

Page 423: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Default-Serialisierung

•Marker-Schnittstelle Serializable

Klasse java.io.ObjectOutputStream :

public final void writeObject (Object ob)

throws IOException;

Klasse java.io.ObjectInputStream :

public final Object readObject ()

throws OptionalDataException, ClassNotFoundException,

IOException;

423

Page 424: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Default-Serialisierung

• Rekursiver Aufruf von writeObject bzw readObject

zur Serialisierung bzw Deserialisierungdes ganzen Objekt-Graphen

• Zirkel werden erkannt.

• Superklassen werden serialisiert.

• Felder sind auch serialisierbar.

• transient-Klassenelemente werden nicht serialisiert.

424

Page 425: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

public class ProgrammiererIn extends Person

implements Serializable

{// - Konstruktor, zeige, setLaune, setKollegIn

private Sprache sprache;

private transient String laune;

private ProgrammiererIn kollegIn;

}

425

Page 426: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

class Person implements Serializable

{public Person (String name) { this.name = name; }protected String name;

}

class Sprache implements Serializable

{public Sprache (String name) { this.name = name; }String name;

}

426

Page 427: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Serialisierung

public class Serialisierung

{public static void main (String[] argument) throws IOException

{FileOutputStream f = new FileOutputStream (argument[0]);

ObjectOutputStream s = new ObjectOutputStream (f);

ProgrammiererIn p1 = new ProgrammiererIn ("Gustav", "Java");

ProgrammiererIn p2 = new ProgrammiererIn ("Hanna", "C++");

p1.setLaune ("schlechte"); p2.setLaune ("gute");

p1.setKollegIn (p2); p2.setKollegIn (p1);

p1.zeige (); p2.zeige ();

s.writeObject (p1); s.writeObject (p2);

427

Page 428: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Serialisierung

ProgrammiererIn[] fp = new ProgrammiererIn[20];

for (int i = 0; i < 20; i++)

{fp[i] = new ProgrammiererIn ("Dummy" + i, "Cobol");

fp[i].setKollegIn (p1);

}s.writeObject (fp);

s.close ();

f.close ();

}}

428

Page 429: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel Deserialisierung

public class Deserialisierung

{public static void main (String[] argument)

throws IOException, ClassNotFoundException

{FileInputStream f = new FileInputStream (argument[0]);

ObjectInputStream s = new ObjectInputStream (f);

ProgrammiererIn p;

p = (ProgrammiererIn)s.readObject (); p.zeige ();

p = (ProgrammiererIn)s.readObject (); p.zeige ();

ProgrammiererIn[] fp = (ProgrammiererIn[])s.readObject ();

for (int i = 0; i < 20; i++) fp[i].zeige ();

s.close (); f.close ();

}}

429

Page 430: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Vor- und Nachbehandlung

private void writeObject (ObjectOutputStream aus)

throws IOException

{// Vorbehandlung des Objekts

aus.defaultWriteObject ();

// Nachbehandlung des Objekts

}

430

Page 431: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Nachbehandlung

private void readObject (ObjectInputStream ein)

throws IOException, ClassNotFoundException

{ein.defaultReadObject ();

// Nachbehandlung des Objekts

}

431

Page 432: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

• Name wird in * eingebettet.

• writeObjekt muß in Superklasse Person definiertwerden.

• Laune wird nach dem Lesen auf ”unbestimmte” gesetzt.

• Anwendungsprogramme andern sich nicht.

432

Page 433: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Eigene Serialisierung

• Implementiere Schnittstelle Externalizable

public void writeExternal (ObjectOutput aus)

throws IOException;

public void readExternal (ObjectInput ein)

throws IOException, ClassNotFoundException;

433

Page 434: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

public void writeExternal (ObjectOutput aus)

throws IOException

{String old = name;

name = "*" + name + "*";

super.writeExternal (aus);

aus.writeObject (sprache);

aus.writeObject (kollegIn);

name = old;

}

434

Page 435: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Beispiel

public void readExternal (ObjectInput ein)

throws IOException, ClassNotFoundException

{super.readExternal (ein);

sprache = (Sprache)ein.readObject ();

kollegIn = (ProgrammiererIn)ein.readObject ();

setLaune ("unbestimmte");

}

435

Page 436: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Klassenversion

• Entweder Definition vonstatic final long serialVersionUID

= -7440944271964977635L;

• oder automatische Vergabe.

• serialver

436

Page 437: Inhalt Intensivkurs Java Innere Klassen Operatoren Streamskfg/java/javaF.pdf · Inhalt Intensivkurs Java | Einleitung Innere Klassen Datentypen Threads Operatoren Streams Kontrollstrukturen

��

��Applet

• <APPLET>-Tag hat ein Attribut OBJECTzum Laden serialisierter Applet-Objekte.

• Initialisierungs-Code wird nicht mehr benotigt.

• Konvention: Objekt-Datei hat Erweiterung .ser

• appletviewer kann zur Erzeugung vonObjekt-Dateien verwendet werden (Stop, Save).

437