Teil 3 - Michael Hahsler

Java Einführung
Teil 3: Wiederverwendung
Michael Hahsler
Java Einführung
Packages
Inhalt dieser Einheit
•
•
•
•
•
Packages (= Klassenbibliotheken)
Packages erstellen
Packages importieren
Packages verwenden
Standard Packages
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Code-Reuse
•
Einbinden von bereits (selbst-/fremd)
programmiertem Code
• Wiederverwendung von Klassen, mit oder ohne
deren Implementierung zu kennen
Techniken:
1. Vorhandenen Klassen (aus Packages) verwenden
2. Vererbung (vorhandene Klassen erweitern und
spezialisieren)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Packages
• Verschiedene, funktional zusammengehörende Klassen
werden in Packages mit einem klaren Interface
(public Klassen und Methoden) integriert.
• API (Application Program Interface): Gesamtheit der
von zusammengehörenden Paketen definierte
Schnittstellen
• Packages werden mit der
• Java-Plattform ausgeliefert (Standard-Packages),
• können selbst oder
• von Dritten programmiert werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Vorteile von Packages
Die Verwendung von Packages bringt folgende Vorteile:
• Systematische Ordnung bei vielen Klassen ("Name
spaces")
• Leichter überschaubaren Programmcode
• Definition eines klaren public-Interfaces der
Packages (API) meist mit Automatisch generierter
Dokumentation (JavaDoc)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Name spaces
• Ermöglichen die Verwendung der gleichen Namen in
verschiedenen Packages.
• Bsp: Uni.Person und Verein.Person sind
verschiedene Klassen
Person
Person
Spieler
Student
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Packages erstellen
Alle Klassen die zu einem Package gehören, müssen:
1.
In ein Verzeichnis (Ordner) mit dem Namen des Pakets
gespeichert werden.
2.
Mit package packageName beginnen.
Bsp: Datei mypackage/MyClass.java
package mypackage;
public class MyClass {
...
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Packages verwenden
• Packages müssen entweder ausdrücklich (explizit)
oder implizit importiert werden.
Beispiele:
• Import mit expliziter Importanweisung
import mypackage.*;
MyClass m = new MyClass();
• Impliziter Import
mypackage.MyClass m =
new mypackage.MyClass();
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Packages verwenden II
• Einbinden des gesamten Pakets
import java.util.*;
• Einbinden einzelner Klassen eines Pakets
import java.util.Date;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Interface des eigenen
Pakets
• Die Klassen und Methoden, die von außerhalb des
Pakets verwendet werden sollen, müssen als public
deklariert werden, da sie sonst nur innerhalb des
Paketes sichtbar sind.
• Um Packages weltweit eindeutig zu benennen soll der
Pfad als verkehrter Domain-Name des
Klassenerzeugers gewählt werden
z.B. at.ac.wuwien.meinPaket
das dazugehörige Verzeichnis ist
at/ac/wuwien/meinPaket/
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Java-Standard-Packages
• java.lang /*wird implizit immer importiert (keine importAnweisung nötig), enthält z.B. Klasse String, Math,... */
• java.io //Ein/Ausgabe
• java.util //nützliche Klassen (Datum, Random etc)
• java.net //für die Kommunikation über Netzwerke
• java.awt /*Klassen für die Benutzerschnittstelle und
Graphikprogrammierung */
• Information bietet die Spezifikation der Java-API.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Java-Standard-Packages II
• Das Package java.lang wird immer implizit importiert.
• Verwendungsbeispiel:
System.out.println(String)
• System ist eine Klasse im Package java.lang
• out ist eine statische Variable in der Klasse System vom Typ
PrintStream.
• In der Klasse PrintStream ist die Methode println(String)
definiert.
• Unbedingt nachvollziehen auf: http://java.sun.com/j2se/1.4/docs/api/
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Lernkontrolle
• Sie kennen die Möglichkeiten der Verwendung von
Packages,
• die Problematik von Namenskonflikten.
• Zerlegen Sie Ihr Programm zur Umwandlung
römischer Zahlen in Package und Programmcode
und bringen Sie das Programm zum Laufen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Java Einführung
Vererbung und Polymorphie
Kapitel 13
Inhalt
• Klassifikation (UML)
• Implementierung von Vererbungshierarchien
• Überschreiben von Methoden
• Polymorphismus: Up-Casting und Dynamisches
Binden
• Schlüsselwort final
Grundzüge der Programmierung - Hahsler
2
Vererbung
• Vererbung ist ein Grundkonzept der
Objektorientierung.
• Sub-Klassen erben dabei die Eigenschaften
(Variablen, Methoden) von Super-Klassen
• In Java wird nur Einfachvererbung unterstützt,
d.h. jede Sub-Klasse kann nur direkt von einer
Klasse erben.
Grundzüge der Programmierung - Hahsler
3
Klassifikation
Buchhandlung
Article
Anzeige für
Warenkorb
code: int
label: String
price: double
Article beinhaltet
alle gemeinsamen
Eigenschaften
showInfo()
getArticleLine()
"Erben" alle
Eigenschaften
von Article
Book
Newspaper
CD
author: String
title: String
publisher: String
year: int
artist: String
song: String[]
showInfo()
...
name: String
city: String
showInfo()
showInfo()
Grundzüge der Programmierung - Hahsler
4
Implementierung der Elternklasse
Article
class Article {
code: int
label: String
price: double
int code;
String label;
double price;
showInfo()
getArticleLine()
void showInfo() {...}
String getArticleLine() {...}
Article (int code, String label, double
price) {...}
}
Grundzüge der Programmierung - Hahsler
5
Implementierung der Abgeleiteten
Klasse Book
class Book extends Article {
String author, title, publisher;
int year;
Book
author: String
title: String
publisher: String
year: int
showInfo()
void showInfo() {...}
Book (int code, String author, String title,
double price) {...}
}
Bekommt alle Eigenschaften von Article, erweitert die Attribute
und überschreibt die Methode showInfo()
Grundzüge der Programmierung - Hahsler
6
Implementierung der Abgeleiteten
Klasse CD
class CD extends Article {
String artist;
String [] song;
CD
artist: String
song: String[]
showInfo()
void showInfo() {...}
CD(int code, String artist, double
price){...}
}
Bekommt alle Eigenschaften von Article, erweitert die Attribute
und überschreibt die Methode showInfo()
Grundzüge der Programmierung - Hahsler
7
Überschreiben von Methoden
Die neu definierte Methode in der abgeleiteten Klasse ersetzt
die gleichnamige Methode in der Elternklasse (Superklasse)
•Die neue Methode kann die Methode der Superklasse aufrufen:
class Book extends Article {
...
void showInfo() {
super.showInfo(); // Methode in Article
// show more stuff
} ...
}
Grundzüge der Programmierung - Hahsler
8
Instanzierung einer abgeleiteten
Klasse
Book myBook = new Book(10, "Jules Verne",
"20.000 Meilen unter dem Meer", 21.90)
Top-Down-Ablauf bei der Instanzierung:
Article
1. Konstruktor von Article
2. Konstruktor von Book
Grundzüge der Programmierung - Hahsler
Book
9
Instanzierung einer abgeleiteten
Klasse II
Article
Bsp: Konstruktor der Super-Klasse mit Argumenten
aufrufen:
class Book extends Article {
...
Book (int code, String author, String
title, double price){
super(code,autor+": "+title, price);
Book
// muss die 1.Zeile sein
...
}
...
}
class Article {
Article (int code, Sting label,
double preis) {...}
...
}
Grundzüge der Programmierung - Hahsler
10
Polymorphie: Kompartibilität
zwischen Ober- und Unterklasse
• Jedes Programm, das in der Lage ist, mit Instanzen der
Oberklasse zu arbeiten, kann auch mit Instanzen der
Unterklasse arbeiten. (Polymorphismus)
• D.h. jedes Programm, das Artikel (Article) verwalten kann, kann auch
mit unseren Büchern (Book) und CDs (CD) oder allen anderen
abgeleiteten Klassen arbeiten, da es das Interface von Article kennt.
CD
...
Book
Article
Grundzüge der Programmierung - Hahsler
11
Zuweisung von Objekten
• Aufgrund der Kompartibilität kann ein Objekt der
Unterklasse einer Oberklassenvariable zugewiesen
werden (up-casting)
Article a = new Book();
// a ist ein book sieht aber wie ein Article aus
• Prüfen auf den Klassentyp
if (a instanceof Book) {...}
• Umwandeln auf original Klassentyp
Book b = (Book) a; // Cast
Grundzüge der Programmierung - Hahsler
12
Dynamische Bindung
• Problemstellung:
• Methode wird überschrieben
• Objekt der Unterklasse wird in einer Oberklassen-Variable
gespeichert (up-casting)
• Welche Methode wird verwendet?
• Lösung: Dynamische Bindung - Die Methode
des "echten" Typs wird zur Laufzeit ermittelt und
ausgeführt.
Grundzüge der Programmierung - Hahsler
13
Dynamische Bindung II
Article a = new Book();
a.showInfo();
Kommen später neue
Artikel hinzu, braucht im
Programm nichts mehr
verändert werden!
Article
code: int
label: String
price: int
showInfo()
getArticleLine()
Book
CD
author: String
title: String
publisher: String
year: int
showInfo()
artist: String
song: String[]
showInfo()
Grundzüge der Programmierung - Hahsler
14
Dynamische Bindung III
Anwendung mit Arrays von Objekten verschiedener
Unterklassen
Article [] someArticles = new [10] Articles;
someArticles[0] = new Book(12, "S.King",...);
someArticles[1] = new CD(31, "Sting",...);
... // Up-casts
for (int i=0; i<someArticles.lenght; i++) {
someArticles[i].showInfo(); // dyn. Binden
}
Grundzüge der Programmierung - Hahsler
15
final + primitive Datentyp
Der Wert der „Variablen“ ist konstant.
final int I = 0;
I++;
/* Anweisung nicht möglich, der Wert von i kann nicht
verändert werden.*/
Fehlermeldung des Compilers:
Test.java:4: Can't assign a value to a final variable: I
I++;
^
1 error
Grundzüge der Programmierung - Hahsler
16
final + Objekt-Datentyp
Die Referenz ist konstant.
Number.java:
class Number {
int i;
}
final Number N1 = new Number(19);
Number n2 = new Number(47);
N1 = n2; /*Anweisung nicht möglich. Der Variablen N1 kann
keine neue Referenz zugewiesen werden.*/
N1.i = n2.i; /* Anweisung möglich! */
Grundzüge der Programmierung - Hahsler
17
final + Parameter
Parameter ist in der Methode nicht veränderbar.
public void deposit(final double VALUE){
VALUE = VALUE * 2; /* Anweisung nicht möglich. Der Variablen
VALUE kann kein neuer Wert zugewiesen werden. */
balance+= VALUE; // Anweisung möglich
...
}
Grundzüge der Programmierung - Hahsler
18
final + Methode
Das Überschreiben der Methode durch eine Subklasse wird
verhindert.
class Lebewesen {
public final String getName() {...}
}
• Gründe: Effizienzsteigerung (kein dynamische Binden; siehe
Polymophismus) oder Sicherheit.
• private + Methode entspricht impliziten final weil die Subklasse
keinen Zugriff hat.
Grundzüge der Programmierung - Hahsler
19
final + Klasse
Eine Vererbung dieser Klasse ist nicht möglich.
final class FinalClass{}
class SubClasse extends FinalClass{}
//Anweisung nicht möglich
Fehlermeldung des Compilers:
Test.java:12: Can't subclass final classes: class Number
public class Test extends Number{
• Damit soll die Sicherheit oder Effizienz gesteigert werden. Die Methoden
einer final definierten Klasse sind implizit final definiert.
Grundzüge der Programmierung - Hahsler
20
Was sie nach dieser Einheit wissen
sollten...
•
•
•
•
•
Kompatibilität bei abgeleiteten Klassen.
Was ist Polymorphismus.
Was Up-Casting ist.
Dynamisches Binden.
Die unterschiedlichen Bedeutungen des
Schlüsselworts final
Grundzüge der Programmierung - Hahsler
21
Java Einführung
Abstrakte Klassen und
Interfaces
Interface
• Interface bieten in Java ist die Möglichkeit, einheitliche Schnittstelle
für Klassen zu definieren, die
• später oder/und
• durch andere Programmierer
• implementiert werden.
• Interfaces können definiert und implementiert werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Definition und Implementierung
eines Interfaces
Java-Syntax:
interface AnInterface {
...
}
<<interface>>
AnInterface
<<implements>>
AClass
class AClass implements AnInterface {
...
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Bsp: Interface definieren
interface HasName {
String pre = “My Name is “;
//Variablen sind autom. static & final!
String getName();
//Methoden sind autom. public!
//keine Implementierung!
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Bsp: Interface implementieren
•
Der Compiler prüft ob alle Methoden des Interfaces implementiert wurden.
class Person implements hasName {
privateString myName; // Instanzvariablen
public String getName() {
return(pre + myName); // pre kommt vom Interface!
}
public void talk(String sentence) {
System.out.println(myName+ “ says: “+sentence);
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Bsp: Interface implementieren II
•
Interfaces werden in der Java API gefunden. Z.B.: java.lang.Comparable
Method Summary intcompareTo(Object o)
Compares this object with the specified object for order. Returns
a negative integer, zero, or a positive integer as this object is less
than, equal to, or greater than the specified object.
class fraction implements Comparable {
private double n,d;
public int compareTo(Object o) {
Fraction oFrac = (Fraction) o; // upcast!
double me = (double) n/ (double) d;
double other = (double) oFrac.n / (double) oFrac.d;
if (me < other) { return -1; }
if (me > other) { return 1; }
return 0; }
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Abstrakte Klassen
• Soll genauso wie Interface/implements ein einheitliches
Interface für alle abgeleiteten Klassen definiern. Hier ist es aber
möglich einzelne Methoden bereits in der abstrakten Klasse zu
implementieren und Instanzvariablen zu deklarieren.
• Wird in einer Klasse für mindestens eine Methode nur die Schnittstelle
definiert (abstrakte Methode), muss die gesammte Klasse als abstrakt
definiert werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Abstrakte Klassen II
• Die Kennzeichnung einer Klasse als abstrakt verhindert, dass
Instanzen dieser Klasse erzeugt werden können.
• Alle abstrakten Methoden müssen in den nicht abstrakten Subklassen
implementiert werden.
• Java-Syntax der Klassendeklaration:
abstract class KlassenName {
void aNormalMethod(int a) {...}
abstract void aAbstractMethod(int b);
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
Block der
Methode
fehlt
8
Abstrakte Klasse Beispiel
• Es sollen Verschiedene Formen implementiert werden, die das
gleiche Interface verwenden. Das Interface und gemeinsame
Teile werden in Shape definiert/implementiert
<<abstract>>
Shape
Point
Rectangel
Circle
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
...
9
Abstrakte Klasse Beispiel II
public abstract class Shape {
protected Point anchor;
Shape() { this.anchor =new Point(); }
public Point position() { return anchor; }
//abstract interface
abstract public double area();
abstract public double perimeter();
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Abstrakte Klasse Beispiel II
public class Rectangle extends Shape {
protected Point rightLowerCorner; // 2. Ecke
public Rectangle() {
super();
this.rightLowerCorner = new Point();
}
// Implementierung der abstrakten Methoden
public double area() { return (width()*heigth()); }
public double perimeter() {
return (2*(width()+heigth()));}
// Zusätzliche Methoden
private double width() {
return (Math.abs(rightLowerCorner.x-anchor.x));
} ...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Was sie nach dieser Einheit
wissen sollten...
• Verwendung von Interfaces und abstrakten
Klassen
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Java Einführung
Collections
Inhalt dieser Einheit
Behälterklassen, die in der Java API
bereitgestellt werden
• Wiederholung Array
• Collections (Vector, List, Set)
• Map
Grundzüge der Programmierung - Hahsler
2
Wiederholung Array
a[0] a[1] a[2] a[3]
a
...
a[10]
...
• Ein Array hat einen Namen (hier: a)
• Die einzelnen Elemente können durch den Index
([0],[1],...) angesprochen werden
• Die einzelnen Elemente verhalten sich wie
namenlose Variablen
• Die Größe wird einmal festgelegt und ist dann fix.
Grundzüge der Programmierung - Hahsler
3
java.util.Arrays
Die Klasse java.util.Arrays stellt Funktionalitäten für das Arbeiten
mit Arrays zur Verfügung. Ein Auszug:
• boolean Arrays.equals(Object[] a, Object[] a2)
Liefert true, wenn die Arrays a und a2 identisch sind. Die Objekte im Array müssen
mittels equals() vergleichbar sein!
• void Arrays.fill(Object[] a, Object val)
Weist allen Elementen des Array a das Objekt val zu.
• void Arrays.sort(Object[] a)
Sortiert das Array a in aufsteigender Reihenfolge. Alle Elementen müssen das
Comparable Interface implementiert haben!
• int Arrays.binarySearch(Object[] a, Object key)
Sucht im sortierten (durch sort(...)) Array a nach dem Element key unter
Verwendung der binären Suchmethode und liefert den Index des gefundenen Objektes
bzw. einen negativen Wert bei Misserfolg.
Grundzüge der Programmierung - Hahsler
4
Beispiel: Arrays
import java.util.Arrays;
class ArrayDemo {
public static void main (String [] args) {
int [] myArray = {9, 23, 1, -28, 8};
Arrays.sort(myArray);
for (int i = 0; i < myArray.length;i++){
System.out.println(myArray[i]);
}
}
Grundzüge der Programmierung - Hahsler
5
Collections
• Collections bieten ein Konzept, welches Objekte zu Gruppen zusammen
fasst (z.B. eine Klasse (Gruppe von Studenten), ein Postfach (Gruppe
von Emails) oder ein Telefonverzeichnis (Gruppe von NameTelefonnummer- Paaren).
• Mit einem Collection-Objekt können Instanzen beliebiger Klassen
verwaltet werden.
• Seit J2SE 5.0 gibt es Generics, davor galt:
•Spezielle Typinformation der einzelnen Objekte geht dabei verloren, da sie
als Object gespeichert werden.
•Um die Instanzen verwenden zu können, müssen auf den entsprechenden
Datentyp umgewandelt werden (Casting).
Grundzüge der Programmierung - Hahsler
6
Struktur von Collections
<<interface>>
Iterator
verwendet
zeigt auf
<<interface>>
Collection
1
Grundzüge der Programmierung - Hahsler
*
Objekt
7
Interface von Collections
• boolean add(E o)
Fügt das Objekt o hinzu und liefert true bzw. false, je nachdem, ob das Objekt
erfolgreich hinzugefügt werden konnte.
• void clear()
Löscht alle Elemente im Container.
• boolean contains(E o)
Liefert true, wenn das Objekt o im Container enthalten ist.
• boolean remove(E o)
Liefert true, wenn das Objekt o im Container gelöscht werden konnte.
• int size()
Liefert die Anzahl der Elemente.
• Iterator iterator()
Liefert ein Iterator Objekt zum Zugriff auf die Elemente des Containers.
E … Generic: Klasse für die die Collection erzeugt wurde.
Grundzüge der Programmierung - Hahsler
8
Interface von Iterator
• boolean hasNext()
Liefert true, wenn es weitere Elemente im Container gibt - bei false liefert der Aufruf
von next eine Exception.
• Object next()
Liefert das nächste Element.
• void remove()
Löscht das aktuelle Element der Collection.
Grundzüge der Programmierung - Hahsler
9
Arten von Collections
• Set (HashSet, TreeSet,...)
• kann Elemente nicht doppelt enthalten
• schnelle Suche
• List (ArrayList, LinkedList, Vector, Stack,...)
• kann Elemente doppelt enthalten
• Elemente haben eine Reihenfolge
• variable Länge, schnelles Einfügen und Löschen
Grundzüge der Programmierung - Hahsler
10
Verwendung von List
import java.util.*;
class PointList {
public static void main (String [] args) {
List<Point> myPoints = new LinkedList<Point>();
myPoints.add(new Point(1.0,1.0));
System.out.println("Die Liste enthält "
+ myPoints.size()+" Punkt(e)!\n");
Iterator<Point> it = myPoints.iterator();
while(it.hasNext()) {
Point b = it.next();
System.out.println("Point("+b.x+","+b.y+") ");
}
}}
class Point { double x,y;
Point(double xi, double yi) { x=xi; y=yi; }}
Grundzüge der Programmierung - Hahsler
11
Verwendung von Vector
import java.util.*;
class PointVector {
public static void main (String [] args) {
Vector myPoints = new Vector<Point>();
myPoints.add(new Point(1.0,1.0));
System.out.println("Die Liste enthält "
+ myPoints.size()+" Punkt(e)!\n");
for( int i=0; i<myPoints.size(); i++) {
Point b = myPoints.elementAt(i);
System.out.println("Point("+b.x+","+b.y+") ");
}
}}
class Point { double x,y;
Point(double xi, double yi) { x=xi; y=yi; }}
Grundzüge der Programmierung - Hahsler
12
Sonderfall: Map
• Map (Hashtable, TreeMap,...)
• schnelles Auffinden von Elemententen über einen key
• jedes Element muss einen eindeutigen key haben
• Map hat ein anderes Interface als Collections:
Object put(K key, Object V value);
Object get(K key);
Object remove(K key);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();
K, V … Generics
public Set keySet(); /* dadurch kann durch die Elemente wie
durch ein Set iteriert werden! */
Grundzüge der Programmierung - Hahsler
13
Verwendung von Maps
import java.util.*;
class PointMap {
public static void main (String [] args) {
Map<String, Point> myPoints =
new Hashtable<String, Point>();
myPoints.put("BUBU", new Point(1.0,1.0));
// 1. einen Iterator auf das keySet erzeugen
Iterator<String> it = myPoints.keySet().iterator();
// 2. Keys durchgehen und Elemente aus der Map holen
while(it.hasNext()) {
String aKey = it.next();
Point b = myPoints.get(aKey);
System.out.println("Key: "+aKey +" Value: "+b);
}
} }
Grundzüge der Programmierung - Hahsler
14
Verwendung von Maps II
import java.util.*;
class PointMap {
public static void main (String [] args) {
Map<String, Point> myPoints =
new Hashtable<String, Point>();
myPoints.put("BUBU", new Point(1.0,1.0));
for(String aKey : myPoints.keySet())) {
Point b = myPoints.get(aKey);
// for-each loop
System.out.println("Key: "+aKey +" Value: "+b);
}
} }
Grundzüge der Programmierung - Hahsler
15
Was Sie nach dieser Einheit
wissen sollten...
• Die Verwendung der Hilfsmethoden von
java.util.Arrays.
• Die Interfaces von Collection und Interator.
• Die Unterschiede von Lists, Sets und Maps
und wie diese eingesetzt werden.
Grundzüge der Programmierung - Hahsler
16
Java Einführung
IO (Eingabe/Ausgabe)
Inhalt dieser Einheit
Ein-/Ausgabe:
• Arbeiten mit Verzeichnissen und Dateien
• Schreiben und Lesen von Dateien bzw.
Datenströmen
• Fehlerbehandlung beim Schreiben und Lesen
von Dateien bzw. Datenströmen
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Lesen und Schreiben von
Daten
„Ein Programm muss oft Informationen aus einer externen Quelle
importieren (Datenquelle) oder Information in eine externe Quelle
exportieren (Datensenke).“
„Die Information kann sich in einer Datei auf einer Diskette, irgendwo im
Netzwerk, im Speicher, in einem anderen Programm befinden oder über
die Tastatur eingegeben werden.“
„Die Information kann verschiedenen Typs sein, zum Beispiel Objekte,
Zeichen, Bilder oder Sounds.“
(Quelle: http://java.sun.com)
In dieser Einheit werden Klassen vorgestellt, die ein Java Programm
benötigt, um Informationen zu lesen und zu schreiben.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Files & Unterverzeichnisse
Für die Verwendung der Ein-Ausgabe-Klassen muss das
Package java.io importiert werden.
Dateien und Unterverzeichnisse sind vom Datentyps File
aus dem Package java.io:
• Datei:
File f = new File („filename“);
• Unterverzeichnis:
File dir = new File („dirname“);
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Methoden von File
Methoden für Dateien oder Unterverzeichnisse
•String getName() - liefert Datei- bzw. Verzeichnis-Namen
•getAbsolutePath() - liefert Datei-/Verzeichnis-Namen mit Pfad
•String getParent()- liefert das Oberverzeichnis
•boolean exists() - Existiert die Datei?
•boolean canWrite()- Darf in die Datei geschrieben werden?
•boolean canRead() - Darf die Datei ausgelesen werden?
•boolean isFile() - Ist es eine Datei, ...
•boolean isDirectory()
... oder ein Verzeichnis?
•boolean mkdir() legt ein Verzeichnis an
•String[] list() für eine Liste von allen in einem Verzeichnis
enthaltenen Datei- und Verzeichnis-Namen.
•boolean delete() - für das Löschen des Files
(Für weitere Methoden von File, lesen Sie bitte in der Java API nach)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Bsp.: Klasse InfoTxt
(Handling von Dateien)
import java.io.*;
public class InfoTxt {
public static void main (String[] args){
File info = new File("info.txt");
//Erzeugt File-Objekt mit Namen "info.txt"
System.out.println(info.getName());
System.out.println(info.length());
}
}
(vereinfachtes Beispiel – ohne Exception-Handling)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Bsp.: Klasse File
(Handling von Dateien)
import java.io.*;
public class FileTest{
public static void main (String[] args){
File file = new File("file.txt");
//Erzeugt File-Objekt mit Dateiname „file.txt“
if (file.exists() && !file.isDirectory()){
System.out.println("Datei"+file.getName()+
"gefunden");
System.out.println("Voller Name: " +
file.getAbsolutePath());
}
else if (!file.exists()) {
System.out.println("Datei "+file.getName()+"
existiert nicht!");
}
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Bsp.: Klasse File –
(Handling von Verzeichnissen)
import java.io.*;
public class DirTest{
public static void main (String args[]){
File dir=new File(".");//aktuelles Verzeichnis
String[] list=dir.list();
for (int i=0; i<list.length; i++)
if (list[i].endsWith(".txt")){
long length=new File(dir,list[i]).length();
// Länge der Files
System.out.println(list[i]+" ["+length+"]");
}
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Datenströme (Streams)
IO-Operationen werden in Java durch Datenströme realisiert:
Ein Datenstrom (engl.: Stream) ist eine Datenstruktur, welche Daten
in serieller Form speichern kann.
Mit einem Stream kann entweder
• gelesen oder
• geschrieben werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Reading und Writing
• Wenn ein Programm Daten lesen soll, dann wird ein Stream auf
die Datenquelle geöffnet und die Information seriell gelesen.
• Ebenso kann ein Programm, das Daten schreiben soll, einen
Stream zu der Datensenke öffnen und die Information dorthin
seriell hinausschreiben.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Ablauf
•
Lesen
1.
2.
3.
4.
•
Öffnen eines Streams;
Solange noch Info
Lese Info;
Schließe den Stream;
Schreiben
1.
2.
3.
Öffnen des Streams;
Solange noch Info
Schreibe Info;
4.
Schließe den Stream;
Selber Ablauf egal woher die Daten kommen und wohin sie gehen!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Arten von Datenströmen
Es gibt in Java zwei verschiedene Gruppen von
Datenströmen:
• Byte-Streams (InputStream, OutputStream) werden für
das Arbeiten mit byte-orientierten Datenströmen eingesetzt.
Die Transporteinheiten bei Byte-Streams sind 8 Bit lang.
• Character-Streams (Reader und Writer) werden für das
Arbeiten mit zeichen- und zeilenorientierten Datenströmen
eingesetzt. Diese Klassen verwenden 16 Bit lange UnicodeZeichen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Reader vs. InputStream
Writer vs. OutputStream
Reader vs. InputStream
• Reader
• Lesen von Character-Streams
(16 bit): Zeichen und Arrays
von Zeichen
• Textdateien
• InputStream
• Lesen von Byte-Streams (8
Bit)
• Binäre Daten wie Soundfiles,
Bilder
Writer vs. OutputStream
• Writer
– Schreibt Character-Streams
• OutputStream
– Schreibt Byte-Streams
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Klasse InputStream
InputStream ist die abstrakte Oberklasse für das Lesen
von Datenströmen, also für die Byte-orientierte Eingabe
(z.B. Bild- und Sounddateien).
FileInputStream ist eine Subklasse von InputStream
für das Lesen von Dateien. Das Öffnen des Lese-Stroms
bzw. des Files erfolgt mit einem Konstruktor der Form
FileInputStream infile =
new FileInputStream (fileObject);
(Weitere Subklassen sind z.B.
ObjectInputStream oder ByteArrayInputStream)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Klasse InputStream II
• Wichtige Methoden der Klasse
InputStream:
• int read()
liefert ein Byte, oder den Wert -1, wenn das
Ende des Datenstroms (End-of-File) erreicht
wurde.
• void close() Beendet eine StreamVerbindung und gibt alle Systemressourcen
frei.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
InputStream
Klassenhierarchie
Die Klasse InputStream und ihre Subklassen:
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
Klasse OutputStream
OutputStream ist die abstrakte Oberklasse für das
Schreiben von Datenströmen, also für die Byte-orientierte
Ausgabe.
FileOutputStream ist eine Subklasse von
OutputStream für das Schreiben von Dateien. Das
Öffnen des Schreib-Stroms bzw. des Files erfolgt mit einem
Konstruktor der Form
FileOutputStream outfile =
new FileOutputStream(fileObject);
(Weitere Subklassen sind z.B.
ByteArrayOutputStream, oder ObjectOutputStream)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
Klasse OutputStream II
Wichtige Methoden der Klasse OutputStream:
• int write()
liefert ein Byte, oder den Wert -1, wenn das
Ende des Datenstroms (End-of-File) erreicht
wurde.
• abstract void close()
Beendet die Stream-Verbindung und gibt alle
Systemressourcen frei.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
OutputStream
Klassenhierarchie
Die Klasse OutputStream und ihre
Subklassen:
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
19
Kopieren von Dateien
Beispiel
import java.io.*;
public class FileStream {
public static void main(String[] args){
File inputFile = new File(“music.mp3");
File outputFile = new File(„song.mp3");
FileInputStream in = new FileInputStream(inputFile);
FileOutputStream out = new FileOutputStream(outputFile);
int c;
while ((c = in.read()) != -1){
out.write(c);
}
in.close();
out.close();
}
}
(vereinfachtes Beispiel – ohne Exception-Handling. Vollst. Code: siehe
Copy.java
20
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
Klasse Reader
Reader ist die abstrakte Oberklasse für das Lesen von
Textströmen, also für die Zeichen-orientierte Eingabe.
InputStreamReader ist eine Subklasse von Reader für
das Lesen von Dateien. Das Öffnen des Lese-Stroms bzw.
des Files erfolgt mit einem Konstruktor der Form
InputStreamReader infile =
new FileReader(fileObject);
(Weitere Subklassen sind z.B.
StringReader oder CharArrayReader)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
21
Klasse Reader II
• Wichtige Methoden der Klasse Reader:
• int read()
liefert ein Zeichen, oder den Wert -1, wenn
das Ende des Datenstroms (End-of-File)
erreicht wurde.
• abstract void close() Beendet eine
Stream-Verbindung und gibt alle
Systemressourcen frei.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
22
Reader
Klassenhierarchie
Die Klasse Reader und ihre Subklassen:
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
23
Klasse Writer
Writer ist die abstrakte Oberklasse für das Schreiben von
Textströmen, also für die Zeichen-orientierte Ausgabe.
OutputStreamWriter ist eine Subklasse von Writer für
das Schreiben von Dateien. Das Öffnen des Schreib-Stroms
bzw. des Files erfolgt mit einem Konstruktor der Form
OutputStreamWriter outfile =
new OutputStreamWriter(fileObject);
(Weitere Subklassen sind z.B. PrintWriter
oder StringWriter)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
24
Klasse Writer II
Wichtige Methoden der Klasse Writer:
• int write()
liefert ein Zeichen, oder den Wert -1, wenn
das Ende des Datenstroms (End-of-File)
erreicht wurde.
• abstract void close() Beendet eine
Stream-Verbindung und gibt alle
Systemressourcen frei.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
25
Writer
Klassenhierarchie
Die Klasse Writer und ihre Subklassen:
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
26
Kopieren von Dateien
Beispiel
import java.io.*;
public class Copy {
public static void main(String[] args){
File inputFile = new File(“input.txt");
File outputFile = new File("outagain.txt");
FileReader in = new FileReader(inputFile);
FileWriter out = new FileWriter(outputFile);
int c;
while ((c = in.read()) != -1){
out.write(c);
}
in.close();
out.close();
}
}
(vereinfachtes Beispiel – ohne Exception-Handling. Vollst. Code: siehe
Copy.java
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
27
Buffer
• zum Verbessern der Effizienz arbeitet man
mit einem Buffer
• zum Lesen:
ƒ
ƒ
BufferedReader: Character bzw.
BufferedInputStream: Byte
• zum Schreiben:
ƒ
ƒ
BufferedWriter: Character bzw.
BufferedOutputStream: Byte
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
28
Buffer 2
• Ohne Buffer bewirkt jeder Aufruf von read(), dass
ein einzelnes Byte aus dem File gelesen und in den
Datentyp Character übersetzt und dann so
zurückgeliefert wird.
• Um die Eingabe effizienter und schneller zu machen,
soll nicht jedes Byte einzeln gelesen werden,
sondern aus einem Pufferbereich.
• Die Buffered-Klassen bieten zusätzliche
Methoden.(z.B. die Klasse BufferedReader readLine())
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
29
BufferedReader und
BufferedWriter
•
Konstruktoren
• new BufferedReader (Reader)
• new BufferedWriter (Writer)
•
Beispiele
File fileI = new FileReader(„FileIn.txt“);
BufferedReader in =
new BufferedReader(fileI);
File fileO = new FileWriter(„FileOut.txt“);
BufferedWriter out =
new BufferedWriter(fileO);
•
Kurzform
BufferedReader in = new BufferedReader (
new FileReader ("ReadFile.java"));
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
30
Lesen von Dateien
Beispiel
import java.io.*;
public class ReadFile {
public static void main (String[] args) {
String thisLine;
File fileI = new FileReader(„FileIn.txt“);
BufferedReader in = new BufferedReader(fileI);
while( (thisLine = in.readLine()) != null) {
System.out.println(thisLine);
}
in.close();
}
}
(vereinfachtes Beispiel – ohne Exception-Handling.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
31
Exceptions
• Alle Ein-/ und AusgabeOperationen können
Fehlersituationen
auslösen:
• Alle I/O-Operationen
müssen durch
Ausnahmeregelungen
(Exceptions) bei evtl.
Fehlersituationen
abgefangen werden.
Throwable
Error
IOException
Exception
RuntimeException
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
32
Exceptions
• Eine Exception ist ein Ereignis, das während der
Programmausführung auftritt und den normalen Ablauf des
Programms stört bzw. abbricht.
• Java bietet Fehlerbehandlungsroutinen (Exception
Handling), um während des Programmablaufes auftretende
Exceptions abzufangen.
• Diese auftretenden Probleme werden durch Objekte
spezieller Exception-Classes repräsentiert, welche eine
genaue Fehlerbeschreibung und den derzeitigen Zustand
des Programmes speichern und ausgeben können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
33
Vorgänge beim Lesen eines
Files
Pseudocode:
readFile {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
34
Mögliche Exceptions
Was passiert wenn...
• die Datei nicht geöffnet werden kann?
• die Länge der Datei nicht bestimmt werden kann?
• nicht genügend Speicher zugeteilt werden kann?
• wenn das Lesen fehlschlägt?
• wenn das File nicht geschlossen werden kann?
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
35
Exception –
Try/Catch Block Syntax
Der Try-Block umschließt die IO-Operationen. Für jeden auftretenden
Fehler kann eine Fehlerbehandlungsroutine aus einer oder mehreren
Anweisungen definiert werden (Catch-Block). Die „geworfenen“ (thrown)
Exceptions werden über eine typisierte Catch - Anweisung abgefangen,
sofern die Ausnahme mit ihrem Typ übereinstimmt.
import java.io.*
class ReadFile{
try { open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
} catch (FileNotFoundException e){doSomething;}
catch (NotOwnerException e) { doSomething; }
catch (IllegalAccessException e) {doSomething;}
...}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
36
Exception - Syntax
Alle Methoden in Java, die im Laufe ihrer Ausführung eine Exception
auslösen könnten, können diese generell ankündigen. Dies geschieht
bei der unmittelbaren Definition der Methode, und zwar durch das
throws - Schlüsselwort im Kopf der Definition. Alternativ kann in der
Methode try/catch verwendet werden. Die beiden Konzepte
können auch kombiniert werden.
Die Methode gibt nur standardmäßige Fehlermeldungen aus:
type methodeName() throws Exception {
// Anweisungen
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
37
Lesen von Dateien
Klasse ReadFile hier mit Exception-Handling
import java.io.*;
public class ReadFile {
public static void main (String[] args) {
String thisLine;
try {
BufferedReader in = new BufferedReader (
new FileReader ("ReadFile.java"));
while( (thisLine = in.readLine()) != null) {
System.out.println(thisLine);
}
in.close();
} catch (Exception e) {
System.out.println("error " + e);
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
}}
38
Schreiben von Dateien
Beispiel
import java.io.*;
public class WriteFile {
public static void main (String[] args) {
try {
BufferedWriter out =
new BufferedWriter(
new FileWriter ("file.txt"));
// FileWriter fw = new FileWriter("file.txt");
// BufferedWriter out = new BufferedWriter(fw);
out.write("Der Text für die Datei");
out.newLine();
out.close();
}
catch (Exception e) {System.out.println(e);}
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
39
Kopieren von Dateien
Klasse Copy hier mit Exception-Handling
import java.io.*;
public class Copy {
public static void main(String[] args) throws Exception {
File inputFile = new File(“input.txt");
File outputFile = new File("outagain.txt");
FileReader in = new FileReader(inputFile);
FileWriter out = new FileWriter(outputFile);
int c;
while ((c = in.read()) != -1) {
out.write(c);
in.close();
out.close();
}
}
}
siehe Copy.java
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
40
Exception Beispiel
Wenn die Datei input.txt nicht im aktuellen Verzeichnis enthalten
ist, wird beim Aufruf von der Klasse „Copy“ die
FileNotFoundException ausgegeben. Diese Exception wird in
der Klasse FileNotFoundException definiert und ist eine
Subklasse von IOException.
Exception in thread "main" java.io.FileNotFoundException: input.txt (Das
System kann die angegebene Datei nicht finden)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.<init>(Unknown Source)
at java.io.FileInputStream.<init>(Unknown Source)
at java.io.FileReader.<init>(Unknown Source)
at Copy.main(Copy.java:7)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
41
Beispiel: Abfangen spezieller
Exceptions (FileNotFoundException)
import java.io.*;
public class Copy {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
FileReader in = new FileReader(inputFile);
int c;
while ((c = in.read()) != -1)
System.out.print(c);
in.close();
} catch (FileNotFoundException fnf) {
System.err.println("Sondermeldung: Input.txt not found! "+fnf);
} catch (Exception e) {System.err.println(e);
} }
}
Erzeugt
folgende Fehlermeldung, wenn es die Datei input.txt nicht gibt:
Sondermeldung: Input.txt not found! java.io.FileNotFoundException:
input.txt (Das System kann die angegebene Datei nicht finden)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
42
Tastatureingabe
Klasse Echo mit Exception-Handling
import java.io.*;
public class Echo {
public static void main(String[] args)
throws IOException {
BufferedReader into = new BufferedReader(
new InputStreamReader(System.in));
String s;
while((s = into.readLine()).length() != 0)
//solange nicht Leerzeile
System.out.println(s);
//eine Leerzeile beendet das Programm
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
43
Lernkontrolle
• Sie kennen die Syntax, für die Eingabe und
Ausgabe von Daten eines Java-Programms.
• Sie kennen die Unterschiede und die
Anwendung der Klassen Reader, Writer,
InputStream, OutputStream
• Bei der Ein- und Ausgabe von Daten können
Fehler auftreten. Sie wissen, wie Sie diese
Fehler abfangen können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
44
Java Einführung
Exception Handling
Kapitel 17
Inhalt
•
•
•
•
•
Was sind Exceptoins?
Wie werden sie ausgelöst?
Wie kann man Exceptions behandeln?
Erweiterung von Exceptions
Spezialfall IO
Grundzüge der Programmierung - Hahsler
2
Ausnahmezustände
Im Ablauf eines Programms können unvorhergesehen
Probleme auftreten. Die JavaVM führt dann eine
Ausnahmebehandlung (Exception) durch.
Ausnahmen sind in Java als Instanzen definiert (siehe:
java.lang.RuntimeException,
java.io.IOException, ...)
Wichtige Ausnahmezustände:
• Arithmetic Exceptions (bei Division durch 0 bei int)
• NullPointerException (Instanzname enthält keine Instanz)
• ArrayOutOfBoundsException (unmöglicher Index bei Arrays)
• IOException (Ein/Ausgabeproblem)
Grundzüge der Programmierung - Hahsler
3
Beispiel für eine
RuntimeException
class SimpleClass { int s; }
class Killer {
public static void main (String [] args) {
SimpleClass mySC = new SimpleClass();
mySC= null;
mySC.s=10;
}
}
Fehler beim Ausführen und Programm bricht ab:
Exception in thread "main"
java.lang.NullPointerException:
at Killer.main(Killer.java:7)
Grundzüge der Programmierung - Hahsler
4
Beispiel für eine
RuntimeException II
class Killer2 {
public static void main (String [] args) {
int n=0;
int e = 10/n;
System.out.println(e);
}
}
Fehler beim Ausführen und Programm bricht ab:
Exception in thread "main"
java.lang.ArithmeticException: / by zero
at Killer2.main(Killer2.java:4)
Grundzüge der Programmierung - Hahsler
5
Ausnahmebehandler
try & catch
try {
• try-Block mit Anweisungen
die die Exception auslösen
Anweisungen;
} catch (AException e) { kann
Behandlung;
• catch-Blöcke mit den
} catch (BException e) { Fehlerbehandlungsanweisungen (wird nach Typ
Behandlung;
des Parameters bestimmt!)
} catch(..
• finally-Block wird bei jeder
...
Exception am Schluss
} finally {
ausgeführt
Behandlung;
• Nach der Behandlung der
}
Exception wird das
Programm fortgesetzt!
Grundzüge der Programmierung - Hahsler
6
Beispiel zu try & catch
class Killer3 {
public static void main (String [] args) {
double myArray[] = new double[5]; // Index 0..4
double v; int i=5;
try {
v= myArray[i]; // Indexfehler 5>4!
}catch(ArrayIndexOutOfBoundsException e){
System.err.println("Folgende Exception "
+ " ist aufgetreten: " + e);
}
System.out.println("Weiter geht's ...");
}
}
Grundzüge der Programmierung - Hahsler
7
Exceptions in Methoden
class Killer5 {
static int divide(int a, int b) throws ArithmeticException {
return (a/b);
}
die Methode kann eine Exception auslösen
public static void main (String [] args) {
try {
System.out.println ("1/0 = "+divide(1,0));
} catch(Exception e) {
System.out.println("I caught the Exception:"
+e.getMessage());
}
System.out.println("Life goes on!");
}
}
die aufrufende Methode kümmert sich um
die Behandlung
Grundzüge der Programmierung - Hahsler
8
Klassenhierarchie von
Exceptions
Object
Throwable
Exception
RuntimeException
•IndexOutOfBoundExc.
•ArithmeticException
•NullPointerException
•...
IOException
•FileNotFoundException
... Exceptions weiterer
Packages
•EOFException
•CharacterCodingExc.
•...
Grundzüge der Programmierung - Hahsler
9
Erzeugen einer neuen Exception
class FunnyException extends Exception {
String joke;
FunnyException(String in) { joke=in; }
java.lang.Exception
public String getMessage() {
return ("I was caused by the joke: "+joke);
}
}
class Killer4 {
public static void main (String [] args) {
try {
throw new FunnyException("Yesterday I was...");
} catch(Exception e) {
e.printStackTrace();
}
}
Jede Exceptionklasse kann durch extends spezialisiert werden.
}
Grundzüge der Programmierung - Hahsler
10
IOException
IO geht in Java prinzipiell über die abstrakten Klassen:
• InputStream
• OutputStream
Steams können von Tastatur, zu Bildschirm und von/zu
Datenträger, Netzwerk usw. gehen
Streams sind byte-orientiert und verfügen über:
• einen Konstruktor (=open)
• int read(byte[] b) bzw. void write(byte[] b)
• close()
Als Vereinfachung bei der Eingabe gibt es
BufferedReader mit der Methode: String
readLine()
Grundzüge der Programmierung - Hahsler
11
IOException II
Bsp: Einlesen von der Tastatur
try {
/* kann IOExceptions auslösen (siehe BufferedReader und
* und InputStreamReader in API) */
BufferedReader inKeyBoard = new BufferedReader(new
InputStreamReader(System.in));
fileName= inKeyBoard.readLine();
} catch (Exception e) {
System.err.println("Fehler bei der Eingabe: "
+ e.getMessage());
System.exit(1); // JVM mit Fehlercode beenden
}
Grundzüge der Programmierung - Hahsler
12
IOException III
Bsp: Einlesen von der Datei (Ausgabe funktioniert analog mit
FileWriter/BufferedWriter)
try {
/* kann IOExceptions auslösen (siehe BufferedReader und
* und FileReader in API) */
FileReader inFile =new FileReader ("Datei.txt");
BufferedReader in = new BufferedReader (inFile);
while((buffer = in.readLine()) != null) {
System.out.println(buffer);
}
in.close();
} catch (Exception e) {
System.err.println("Fehler beim öffnen/lesen: "
+ e.getMessage());
System.exit(1); // JVM mit Fehlercode beenden
}
Grundzüge der Programmierung - Hahsler
13
Was sie nach dieser Einheit wissen
sollten...
• die Funktionsweise von Exceptions verstehen.
• wissen wie man in der API Spezifikation
Exceptions einzelner Pakete/Klassen findet.
• Exceptions richtig behandeln können.
• das Prinzip von Ein-/Ausgabe in Java verstehen.
Grundzüge der Programmierung - Hahsler
14