22.05.2009

Transcrição

22.05.2009

Prog. 2
6
•
•
Prog. 2
Exceptions
6
•
Ein Ereignis, das während der Programmausführung auftritt und den
normalen Programmablauf stört, heißt Ausnahme oder Exception
Auslösen von Exceptions
Das Auslösen einer Exception
besteht aus zwei Schritten
– Eine Methode, in der eine Anweisung eine Ausnahmesituation auslöst,
erzeugt eine Instanz der Klasse Throwable oder deren Subklassen
•
Üblicherweise werden beide
Schritte zusammengefasst:
throw new
ExceptionTyp(“Message“);
Beim Erzeugen eines ExceptionObjekts kann ein Fehlertext an den
Konstruktor übergeben werden
Der Fehlertext kann später vom
Empfänger der Exception über die
Methoden
Throwable
•
Exception
Error
MeineGepruefteException
•
IOException
...
~55
der throw-Anweisung: Division
1. Erzeugen eines Exception Objekts
durch Null wirft eine Exception */
mittels new-Operator
2. Werfen einer Exception mit Hilfe des ...
Schlüsselworts throw
Das Java-Laufzeitsystem kann Exceptions behandeln, die Instanzen
von Throwable oder davon abgeleiteten Klassen sind
Basisklasse für vom Laufzeitsystem
erzeugte Fehler. Sollte nicht im
Programm abgefangen werden.
/* Werfen einer Exception mit Hilfe
RuntimeException
–
–
MeineUngepruefteException
getMessage()
toString()
public Bruch geteilt(Bruch b) {
if(b.zaehler == 0) {
throw new
ArithmeticException(
“In Bruch: Division durch 0.“);
} else {
return new Bruch(
this.zaehler * b.nenner,
this.nenner * b.zaehler );
}
}
...
abgefragt werden
...
~20
22.05.2009
Prog. 2
FileNotFoundException
ArithmeticException
IndexOutOfBoundsException
FH-Wiesbaden --- Medieninformatik --- SS 2009 --- Prof. Dr. Ulrich Schwanecke
6
Behandlung von Exceptions
•
Ausnahmen können
– Innerhalb der Methode behandelt
werden, in der sie auftauchen
– Von einer Methode an die aufrufende
Stelle weitergereicht werden (Mittels
throws)
•
Ausnahmebehandlung (innerhalb
einer Methode) mittels try-catch
Anweisung
– Im try-Block stehen die
Anweisungen, die eine Ausnahme
auslösen können
– Im catch-Block werden die
Ausnahmen behandelt
– Leerer catch-Block verhindert
Programmabbruch
– Es können mehrere catch-Blöcke
vorhanden sein
– Anweisungen im optionalen
finally-Block werden immer
ausgeführt
22.05.2009
...
~30
1
Prog. 2
6
try {
/* Anweisungen, die Instanzen
der Klasse Exception oder
deren Subklassen werfen
können.*/
...
} catch (ExceptionTyp e) {
/* Bei einem Fehler wird die
normale Programmausführung
unterbrochen und die erste
Anweisung nach der catchKlausel mit passendem
ExceptionTyp ausgeführt */
...
} finally { // Optional!!!
/* Anweisungen, die immer
ausgeführt werden sollen */
...
}
22.05.2009
2
try-catch Beispiel
double number;
String[] numbers = {“0“,“10“,“zwanzig“}
for(int i=0; i<4; ++i) {
try {
Programm-Ausgabe:
ArithmeticException:
java.lang.ArithmeticException: / by zero
number = 1/Integer.parseInt(numbers[i]);
try-catch Ende. i: 0
System.out.println(“Number: “+number);
} catch (ArithmeticException e) {
System.out.println(“ArithmeticException:“);
System.out.println(e);
Number: 0.0
} catch (IndexOutOfBoundsException e) {
System.out.println(“IndexOutOfBoundsException:“);
NumberFormatException:
java.lang.NumberFormatException: For input
} catch (NumberFormatException e) {
System.out.println(“NumberFormatException:“);
string: “zwanzig“
} finally {
System.out.println(“try-catch Ende. i: “+i);
IndexOutOfBoundsException:
System.out.println();
java.lang.ArrayIndexOutOfBoundsException :
3
}
}
3
22.05.2009
4
Prog. 2
6
•
•
•
Ungeprüfte Exceptions
Ungeprüfte Exceptions sind
Exceptions, bei denen der Compiler
(zur Übersetzungszeit) keine
zusätzlichen Überprüfungen
vornimmt
Exception-Klassen, die Subklasse
der Klasse RuntimeException
sind, definieren ungeprüfte
Exceptions
Ungeprüfte Exception sollten immer
dann verwendet werden, wenn das
Ergebnis voraussichtlich
•
Exception: IllegalArgumentException
Eine Methode (meist Konstruktor)
•
signalisiert, dass die übergebenen
Parameter ungültig sind. Hiermit kann
z.B. die Erzeugung von Objekten mit
•
ungültigem Zustand verhindert
werden.*/
...
•
public Bruch(double z, double n)
{
if(n == 0) {
throw new
Geprüfte Exceptions
Geprüfte Exceptions müssen
behandelt werden
Compiler überprüft zur
Übersetzungszeit, ob alle geprüften
Exceptions behandelt werden
Exception-Klassen, die Subklasse
der Klasse Exception sind,
definieren geprüfte Exceptions
Eine Methode, die eine geprüfte
Exception wirft, muss dies durch
eine throws-Anweisung im
Methodenkopf kenntlich machen
– Für ungeprüfte Exceptions sollte
keine throws-Anweisung
angegeben werden (obwohl Java es
erlaubt)
IllegalArgumentException(
“In Bruch: Nenner = 0“);
– nicht gefangen wird
Ungeprüfte Exceptions können
mittels try-catch-Anweisung
gefangen werden, müssen aber
nicht
6
/* Beispiel für eine ungeprüfte
– ein Programmabbruch ist
•
Prog. 2
} else {
•
this.zaehler = z;
this.nenner = n;
}
}
Aufrufer einer Methode, die eine
geprüfte Exception werfen kann,
muss diese in einem try-Block
behandeln
Prog. 2
6
5
22.05.2009
Prog. 2
throws Beispiel
6
static public boolean isPrime(int n)
// throws ArithmeticException (ungeprüfte Ex)
{
if (n<=0) {
throw new ArithmeticException(
“isPrime: Parameter<=0“);
}
if (n==1) {
return false;
}
for (int i=2; i<=n/2; ++i) {
if(n%i==0) {
return false;
}
}
return true;
}
public static void main(String[] a){
try{
System.out.print(“10 is prime: “);
System.out.println(isPrime(10));
Systen.out.print(“5 is prime: “);
System.out.println(isPrime(5)); optional
System.out.print(“0 is prime: “);
System.out.println(isPrime(0));
} catch (ArithmeticException e) {
System.out.println(“ArithmeticException:“);
}
static private void openFile()
// geprüfte Exception !
throws FileNotFoundException
{
eingabeDatei = new BufferedReader(
new FileReader(“zahlen.dat“));
}
}
...
BufferedReader eingabeDatei;
new FileReader(“testDatei.txt“));
/* Fehlermeldung vom Compiler:
Unhandled exception type FileNotFoundException */
try {
} catch (FileNotFoundException e) {
System.out.println(“Datei nicht gefunden.“);
System.out.println(“Bitte erneut versuchen.“);
}
private void openFile()
throws FileNotFoundException // Sonst Fehler!
{
try{
openFile();
} catch(FileNotFoundException e){
•
Gezieltere Fehlerbehandlung durch
eigene Exception-Klassen
/* Definition einer eigenen geprüften
Exception-Klasse.
– Hinweis auf den Fehlerkontext
StackOverflowException erbt
– Gezieltes Reagieren auf Exceptions
der eigenen Klasse
alle Attribute und Methoden der
Klasse Exception und enthält
zusätzlich das Attribut
•
Eigenen Exception-Klassen
werden abgeleiten von
– Exception
overflowElement */
class StackOverflowException
extends Exception
• Eigene Exception-Klasse ist eine
geprüfte Exception
Muss!
System.out.println(“FileNotFoundException“);
System.out.println(e.getMessage());
{
int overflowElement;
– RuntimeExeption
• Eigene Exception-Klasse ist eine
ungeprüfte Exception
StackOverflowException(int x) {
overflowElement = x;
Programm-Ausgabe
}
10 is prime: false
5 is prime: true
ArithmeticException:
java.lang.ArithmeticException: isPrime: Parameter<=0
FileNotFoundException:
zahlen.dat (No such file or directory)
6
Eigene Exception Klassen
}
22.05.2009
import java.io.*;
}
...
22.05.2009
// Beispiel für geprüfte Exceptions
7
}
22.05.2009
8
Prog. 2
Prog. 2
Eigene Exceptions (einfaches Beispiel)
6
class Stack {
int[] s;
int length;
boolean overflow, underflow;
Stack(int size){
s = new int[size];
length = 0;
overflow = false;
underflow = false;
}
void push(int x)
throws StackOverflowException {
overflow = length >= s.length;
if(overflow)
throw new StackOverflowException(x);
else s[length++] = x;
}
int pop() {
underflow = length ==0;
if(!underflow) return s[--length];
else return -1;
}
public class StackTest {
public static void main(String[] args) {
Stack s = new Stack(10);
StackOverflowException:
Prog. 2
6
•
•
•
•
9
Liefert Eigenschaften mit Name
key
2. public static String
getProperty(String key,
String default)
•
22.05.2009
Wie 1., jedoch Rückgabe von
default anstatt null, falls
keine Eigenschaft key
•
public static void main(String[] args){
String[] s = {“java.version“,
“java.home“,
•
“os.name“,
“os.version“,
“file.separator“,
“path.separator“,
for(int i=0; i<s.length; ++i) {
}
}
}
•
Programm-Ausgabe
1.5.0_06
.../JavaVM.framework/Versions/1.5.0/Home
Mac OS X
10.4.6
/
:
Die Methode getProperties
liefert das Properties-Objekt
mit den System-Properties
/* Auflisten verfügbaren System-Properties*/
import java.util.*;
public class PrintProperties {
public static void main(String[] a) {
Die Methode propertyNames
erzeugt einen Enumerator mit
dem
Nebenstehendes Beispiel liefert
alle verfügbaren SystemProperties
– sowohl system-abhängige als
auch system-unabhängige
11
10
Die Methode getProperties
– durch Aufruf von getProperty
der zugehörige Wert ermittelt
werden kann
System.out.println(System.getProperty(s[i]));
try {
checkTemp(5);
} catch(TempTooLowException e) {
} catch(TempTooHighException e) {
}
}
Properties sProps = System.getProperties();
Enumeration propNs = sProps.propertyNames();
while(propNs.hasMoreElements()){
String propN = (String)propNs.nextElement();
– alle Schlüsselwerte
durchlaufen werden können
“line.separator“};
Zugriff auf einzelne Properties
•
6
public class PrintProperty {
Zugriff auf Systemeigenschaften in
Java über die Klasse Properties
(abgeleitete von Hashtable)
1. public static String
getProperty(String key)
22.05.2009
Prog. 2
// Zugriff auf System-Properties
Jede Eigenschaft besitzt einen
eindeutigen Namen, unter dem auf
sie zugegriffen werden kann
public static void checkTemp(double temp)
throws TempTooLowException,
TempTooHighException {
if(temp < MIN_TEMP) {
throw new
TempTooLowException(temp);
} else if (temp > MIN_TEMP) {
throw new
TempTooHighException(temp);
}
}
class TempTooHighException
extends TemperatureException
{
public TempTooHighException(double temp){
super(“Max. Temperatur ueberschritten:
“+
temp);
}
Programm-Ausgabe
}
}
TempTooLoowException: Min. Temperatur unterschritten: 5.0
Die Klasse Properties
Über das Konzept der Properties
kann in Java auf System-Eigenschaften zugegriffen werden
public class ThowsTest{
final static double MIN_TEMP = 10.0;
final static double MAX_TEMP = 100.0;
class TempTooLowException
extends TemperatureException
{
public TempTooLowException(double temp){
super(“Min. Temperatur unterschritten:
“+
temp);
}
}
10
11
12
13
14
Eigene Exceptions (zweites Beispiel)
class TemperatureException extends Exception
{
public TemperatureException(String s){
super(s);
}
}
/* Würde zur Compilerfehlermeldung führen:
Unhandled exception type
StackOverflowExample
for(int i=0; i<20; ++i){
s.push(i);
}
*/
for(int i=0; i<15; ++i){
try {
s.push(i);
} catch(StackOverflowException e) {
System.out.print(e+“: “);
System.out.println(e.overflowElement);
}
}
}
}
Programm-Ausgabe
}
22.05.2009
6
22.05.2009
System.out.println(propN + “=“ +
System.getProperty(propN));
}
}
}
Programm-Ausgabe
java.runtime.name=Java(TM) 2 Runtime Environment...
sun.boot.library.path=/System/Library/Frameworks/..
java.vm.version=1.5.0_06-64
awt.nativeDoubleBuffering=true
gopherProxySet=false
java.vm.vendor="Apple Computer, Inc."
java.vendor.url=http://apple.com/
path.separator=:
...
12
Prog. 2
6
Die Klasse File
•
Die Klasse File (aus java.io)
– stellt eine Abstraktion einer Datei
bzw. eines Verzeichnisses dar
– behandelt nicht den Inhalt einer
Datei, sondern abstrahiert Name
und Zugriffspfad
•
File besitzt die Konstruktoren
Prog. 2
6
• Konstruiert File-Objekte zum Dateioder Verzeichnisnamen
– public
File(String parent,
String child)
Aufrufe */
• Wie 2. jedoch Übergabe von FileObjekt anstatt Verzeichisnamen
•
boolean isDirectory()
•
boolean isFile()
•
boolean canRead()
•
boolean canWrite()
import java.io.*;
–
File f1 = new File(“TestDatei.txt“);
–
/* Unter DOS muss der Backslash
–
doppelt angegeben werden, da er
gleichzeitig Escape-Zeichen für
–
Strings ist. */
Prog. 2
6
Liefert true, wenn f File ist
Liefert true, wenn f lesbar ist
String getName()
File f3 = new
•
String[] list()
–
–
File(“.“,“Beispiel.java“);
File f4 = new
•
File(“/usr/testusr“);
•
File f5 = new
Liefert ein String-Array mit den
}
Namen der Dateien/Verzeichnisse
im, durch f bezeichneten, Verzeichnis }
Liefert true, wenn f existiert
long length()
–
13
Liefert Datei-/Verzeichnis-Namen
boolean exists()
–
22.05.2009
import java.io.*;
public class VerzeichnisInfo {
File fod = new File(".");
Out.println("Name
: "+fod.getName());
Out.println("Pfad
: "+fod.getPath());
Out.println(“Pfad voll : "+fod.getAbsolutePath());
Out.println("Schreiben : "+fod.canWrite());
Out.println("Lesen
: "+fod.canRead());
Out.println("File
: "+fod.isFile());
Liefert true, wenn in f geschrieben
werden kann
•
File(f4,“FileExample.java“);
22.05.2009
Liefert true, wenn f Verzeichnis ist
File f2 = new
File(“c:\\documents\\docu.doc“);
• Getrennte Übergabe von
Verzeichnis- und Datei-Namen
– public
File(File parent,
String child)
f ist Instanz von File:
/* Beispiele für gültige Konstruktor-
– public
File(String pathname)
Methoden der Klasse File
if(fod.isDirectory()) {
Out.println("Directory : "+fod.isDirectory());
String flist[] = fod.list();
for(int i=0; i<flist.length; ++i)
Out.println("-- "+flist[i]);
}
ProgrammAusgabe:
Liefert die Anzahl Bytes in f
Name
: .
Pfad
: .
Pfad voll : .../workspace/FileTest/.
Schreiben : true
Lesen
: true
File
: false
Directory : true
-- .classpath
-- .project
-- VerzeichnisInfo.class
-- VerzeichnisInfo.java
14
Prog. 2
Streams
6
Byte-Streams (OutputStream, InputStream)
• Byte-Stream transportieren Bytes (Rohdaten,
Binärinformationen) zwischen Sender und Empfänger
• Abstrakte Basisklassen aller Byte-Streams sind
• Alle Verbindungen nach außen (I/O-Vorgänge) erfolgen in
Java über Streams
• Streams sind abstrakte Verbindungen (Datenleitungen)
eines Programms nach außen
– OutputStream, mit den Methoden
• public void close()
– Auf der einen Seite gehen Daten ein, auf der anderen Seite werden
sie angenommen
– Ausgabestrom schließen (Freigabe aller zugehörigen System-Resourcen)
• public void flush()
• Das Paket java.io stellt zwei verschiedene Streams zur
Verfügung
– Gepufferte Daten schreiben
• public void write(int b)
– Schreibt die unteren 8 Bit von b
– Byte-Streams
• public void write(byte[] b)
• Transportieren Bytes zwischen Sender und Empfänger
– Schreibt b.length Bytes des Byte-Arrays b
• Dienen dem Transport von „Rohdaten“ (z.B. Binärinformationen)
• public void write(byte[] b,int offs, int len)
– Character-Streams (seit JDK 1.1)
– Schreibt len Bytes, bei offs beginnend, aus dem Byte-Array b
• Vereinfachen die Ein-/Ausgabe von Unicode Zeichen
• Vereinfachen Schreib- und Lesevorgänge für Textdateien
– InputStream
• Später mehr...
22.05.2009
15
22.05.2009
16
Prog. 2
Prog. 2
Klassendiagramm OutputStream/InputStream
6
6
FileOutputStream
Byte stream
Object
Objekt vom Typ
FileOutputStream
/* FileOutputStream Beispiel. Legt
eine Datei an und fügt die Bytes
0..255 an. */
OutputStream
...
InputStream
FileOutputStream
FileInputStream
FilterOutputStream
BufferedInputStream
DataOutputStream
ObjectOutputStream
PipedOutputStream
ByteArrayOutputStream
...
6
•
•
ObjectInputStream
public abstract int read()
throws IOException
•
•
–
–
–
22.05.2009
Liest ein Byte als Integer ein (die
oberen drei Byte sind leer)
Liefert -1 bei Dateiende
public int read(byte[] b)
throws IOException
•
Liest Bytes in das Byte-Array b ein
•
Gibt die Anzahl gelesener Bytes zurück
public int read(byte[] b,
int off, int len)
throws IOException
•
Liest len Bytes in Byte-Array b , ab
Position off ein
•
Gibt Anzahl gelesener Bytes zurück
public long skip(long n)
throws IOException
•
Überspringt von n Bytes
•
Löscht sie aus dem Eingabe-Strom
17
•
Setzt Dateizeiger auf den Anfang
public class FOSExample {
public static void main(String[] args)
{
try {
FileOutputStream out = new
FileOuputStream(args[0],true);
for(int i=0; i<256; ++i) {
out.write(i);
}
out.close();
Prog. 2
6
} catch(IOException e) {
System.err.println(e);
System.exit(1);
Entspricht 1., setzt aber den Dateizeiger auf
das Ende der Datei, falls append=true
22.05.2009
}
}
}
18
FileInputStream
Byte stream
– public int available()
throws IOException
Objekt vom Typ
FileInputStream
import java.io.*;
public class FISExample {
• Liefert die Anzahl Bytes, die
ohne Blockieren mindestens
gelesen werden können (Die
meisten Implementierungen
geben hier immer max. 1 zurück)
myFile.dat
try {
FileInputStream in = new
FileInputStream(args[0]);
– public void close()
thows IOException
• Schließt den Eingabe-Strom
– public void mark(
int readlimit)
• Markiert die aktuelle Position im
Eingabestrom
– public void reset()
–
• Testet ob Markieren /
Positionieren unterstützt wird
byte[] buf = new byte[4096];
int len;
while((len=in.read(buf))>0) {
out.write(buf,0,len);
Öffnen einer Datei mit Namen name
}
out.close();
FileInputStream(File file)
•
– public boolean
marksupported()
FileOuputStream(args[1]);
FileInputStream(String name)
•
–
• Springt zur, mit mark gesetzten
Markierung
FileOutputStream out = new
• FileInputStream stellt einen
Byte-Stream zum Lesen aus
einer Datei zur Verfügung
• Konstruktoren
• readlimit gibt maximale Anzahl
zu markierender Zeichen an
Legt gewünschte Ausgabe-Datei an
3. FileOutputStream(File file)
throws IOException
AudioInputStream
Die Basisklasse InputStream
–
•
•
ByteArrayInputStream
...
Abstrakte Basisklasse aller EingabeByte-Streams
Methoden
FileOutputStream stellt einen
Byte-Stream zur Ausgabe in
eine Datei zur Verfügung
Konstruktoren
2. FileOutputStream(String name,
boolean append)
PipedInputStream
import java.io.*;
1. FileOutputStream(String name)
...
...
Prog. 2
•
DataInputStream
PrintStream
22.05.2009
•
FilterInputStream
In der Vorlesung
BufferedOutputStream
myFile.dat
in.close();
Öffnen einer Datei zum File-Objekt
file
}
}
}
19
22.05.2009
Bereits vorhandene
Zieldatei wird ohne
Rückfrage überschrieben
20
Prog. 2
Prog. 2
6
Filter-Streams
•
Streams können (mehrfach) geschachtelt werden
6
• FilterOutputStream ist Basisklasse aller gefilterten AusgabeStreams
– Ein InputStream bzw. OutputStream stellt eine Stream-Verbindung
zwischen einem Programm und einer Datei her
– Abgeleitete Klassen bekommen das Ausgabegerät bei der Instanzierung
in Form eines OutputStream-Arguments übergeben
– Diese Streams können mit Filter-Streams geschachtelt werden, welche die
durchlaufenden Daten filtern oder zwischenspeichern
•
FilterOutputStream / FilterInputStream
• public FilterOutputStream(OutputStream out)
– Von FilterOutputStream abgeleitete Klassen
Filter-Streams
• fangen Schreibzugriffe ab
• verarbeiten diese
• leiten sie an den OutputStream out weiter
– können keine direkte Stream-Verbindung zu einem Ein-/Ausgabe-Gerät
herstellen
– können Daten in einen elementaren Eingabe- oder Ausgabe-Stream
(InputStream, OutputStream) eingeben oder daraus lesen
...
FilterStream
FilterStream
FileOutputStream
• FilterInputStream ist Basisklasse aller gefilterten EingabeStreams
– Abgeleitete Klassen bekommen das Eingabegerät bei der Instanzierung in
Form eines InputStream-Arguments übergeben
File
• public FilterInputStream(InputStream in)
– Von FilterInputStream abgeleitete Klassen
...
22.05.2009
FilterStream
FilterStream
FileInputStream
• fangen Lesezugriffe ab
• verarbeiten diese
• leiten sie an den InputStream in weiter
File
21
Prog. 2
22.05.2009
Prog. 2
BufferedOutputStream / BufferedInputStream
6
DataOutputStream
• BufferedOutputStream puffert die Ausgabe in einen AusgabeStream
•
• void writeBoolean(boolean v)
Mittels DataOutputStream können
throws IOException
primitive Datenypen in definierter und
• void writeByte(int v)
portabler Weise ausgegeben werden
•
Die so geschriebenen Daten können
mittel DataInputStream wieder
eingelesen werden
6
– Beschleunigt die Ausgabe, wenn viele einzelne write-Aufrufe, die jeweils
nur wenig Daten übertragen, erfolgen
– Konstruktoren
• public BufferedOutputStream(OutputStream out)
• public BufferedOutputStream(OutputStream out, int size)
• DataOutputStream implementiert
das Interface DataOutput
– Datenquelle und Puffergröße
– Methoden
– Für jeden primitven Datentyp gibt es
eine Methode
• public void flush() throws IOException
– erzwingt das Schreiben der gepufferten Daten
• BufferedInputStream puffert die Eingabedaten
– Zusätzlich gibt es eine Methode
writeUTF zur Konvertierung der
2Byte langen UNICODE-Zeichen in 1,
2 oder 3 Byte lange Einzelzeichen
– Beschleunigt das Einlesen, wenn häufig kleine Datenmengen oder
einzelne Bytes gelesen werden müssen
– Konstruktoren
• public BufferedInputStream(InputStream out)
• public BufferedInputStream(InputStream out, int size)
– Datenquelle und Puffergröße
22.05.2009
23
22.05.2009
22
throws IOException
•
void writeShort(int v)
throws IOException
•
void writeChar(int v)
throws IOException
•
void writeInt(int v)
throws IOException
•
void writeLong(long v)
throws IOException
•
void writeFloat(float v)
throws IOException
•
void writeDouble(double v)
throws IOException
•
void writeChars(String s)
throws IOException
•
void writeUTF(String str)
throws IOException
24
Prog. 2
Prog. 2
6
DataInputStream
•
Mittels DataInputStream können die • boolean readBoolean()
throws IOException
von DataOutputStream
• byte readByte()
geschriebenen Daten eingelesen
throws IOException
werden
• short readShort()
• DataInputStream implementiert
das Interface DataInput
– Für jeden primitven Datentyp gibt es
eine Methode
6
• void readFully(byte[] b,
int off,
int len)
throws IOException
22.05.2009
Prog. 2
6
•
import java.io.*;
•
•
new BufferedInputStream(
•
String readUTF()
throws IOException
FileInputStream(“test.dat“)));
new DataOutputStream(
new BufferedOutputStream(
System.out.println(in.readInt());
new
FileOutputStream(“test.dat“)));
System.out.println(in.readDouble());
System.out.println(in.readUTF());
in.close();
out.writeInt(1);
out.writeDouble(Math.PI);
out.writeUTF(“Hallo Welt“);
out.close();
float readFloat()
throws IOException
String readLine()
throws IOException
new
DataOutputStream out =
long readLong()
throws IOException
•
new DataInputStream(
try {// Datei schreiben
int readInt()
throws IOException
double readDouble()
throws IOException
DataInputStream in =
char readChar()
throws IOException
•
try {// Dateiinhalt ausgeben
public class DatenEinUndAusgabe {
throws IOException
•
– Zusätzlich gibt es Methoden zum
einlesen von Datenbytes ungeachtet
•
ihres Typs
• void readFully(byte[] b)
throws IOException
DataOutputStream/DataInputStream (Beispiel)
}
}
}
}
DataOutputStream
25
BufferedOutputStream
22.05.2009
DataInputStream
BufferedInputStream
File
FileOutputStream
FileInputStream
File
Programm-Ausgabe:
1
3.141592653589793
Hallo Welt
26
Prog. 2
Character Streams
6
Klassendiagramm Writer/Reader
Object
Byte-Streams arbeiten auf Basis von Bytes und gehen davon aus, dass
Zeichen im ASCII Standard dargestellt werden
Byte stream
Objekt vom Typ
OutputStream
Byte stream
Objekt vom Typ
InputStream
•
In Java werden Zeichen (Character) gemäß dem Unicode-Standard
mit zwei Byte dargestellt
•
Character Streams dienen der vereinfachten zeichenorientierten Ein/Ausgabe
•
Abstrakte Basisklassen aller Character Streams sind die Klassen
Writer
OutputStreamWriter
InputStreamReader
In der Vorlesung
FileWriter
BufferedWriter
CharArrrayWriter
– Writer (Schreibvorgänge)
...
Reader
FilterWriter
FileReader
BufferedReader
CharArrayReader
FilterReader
– Reader (Lesevorgänge)
character stream
Objekt vom Typ
Writer
character stream
Objekt vom Typ
Reader
22.05.2009
PipedWriter
PipedReader
PrintWriter
StringReader
StringWriter
27
22.05.2009
28
Prog. 2
6
FileWriter
•
Konkrete Klasse für Schreibvorgänge in
Dateien
Prog. 2
/*
Unten stehendes Programm schreibt den Text
„Hallo Welt“ in die Datei Testdatei.txt“.*/
•
Erweiterung der abstakten Klasse
OutputStreamWriter
import java.io.*;
•
Konstruktoren
public class FileWriterExample {
–
FileWriter(String dateiname)
throws IOException
•
–
–
•
Prog. 2
–
void write(string str)
throws IOException
–
void close()
throws IOException
•
• Schreibt s in den Ausgabestrom
– newLine()
thows IOException
• Schreibt einen Zeilenseparator
(Property: line.separator)
public class FileReaderExample {
String datei =“FileReaderExample.java";
try {
FileReader fr = new FileReader(datei);
int c;
while( (c=fr.read())!=-1 )
Out.print((char)c);
fr.close();
– public int read()
throws IOException
}
catch(FileNotFoundException e) { }
• Gibt den Integer-Wert eines Charakter
zurück (bei Dateiende -1)
– public void close()
throws IOException
}
catch(IOException e) { }
}
}
• Schließt den Character-Stream
}
29
22.05.2009
Prog. 2
import java.io.*;
public class BWriterExample {
String s[] = new String[2];
s[0] = "Hallo";
s[1] = "Welt";
BufferedReader
•
Speichert gelesene Character in
einen Puffer
Kann Lesegeschwindigkeit
erhöhen
Ermöglicht das Einlesen kompletter
Zeilen
Konstruktoren
•
FileWriter fw = new FileWriter(“Test.txt");
BufferedWriter bw = new BufferedWriter(fw);
•
– BufferedReader(Reader in)
for(int i=0; i<s.length; ++i) {
bw.write((i+1)+". Zeile: "+s[i]);
• Erzeugt einen gepufferten CharacterEingabe-Stream
bw.newLine();
– BufferedReader(Reader in,
int size)
}
bw.close();
• Zusätzliche Angabe der Puffergröße
}
catch (FileNotFoundException e) {}
catch (IOException e) {}
}
BufferedWriter
6
•
try {
}
import java.io.*;
Methoden
catch(FileNotFoundException e) { }
• Erzeugt einen gepufferten
Character-Ausgabe-Stream
– write(String s)
thows IOException
aus. */
• Öffnet Datei zum File-Objekt file
catch(IOException e) { }
• Zusätzliche Angabe der Puffergröße
„FileReaderExample.java“ auf der Konsole
– FileReader(File file)
// Muss
Methoden
Nachfolgendes Programm gibt den Inhalt von
• Öffnen der Datei dateiname
}
– BufferedWriter(Writer out,
int size)
/*
– FileReader(String dateiname)
thows FileNotFoundException
fw.close();
– BufferedWriter(Writer out)
22.05.2009
Konstruktoren
fw.write(text);
Schreibt Zeichen gepuffert in einen
Ausgabestrom
Kann Schreibgeschwindigkeit
erhöhen
Ermöglicht das Schreiben von
Textzeilen
Konstruktoren
•
•
// Optional
•
•
Erweiterung der abstakten Klasse
OutputStreamReader
FileWriter fw = new FileWriter(datei);
Methoden
BufferedWriter
•
•
try {
Öffnen der Datei zum File-Objekt file
6
•
Konkrete Klasse für Lesevorgänge
aus Dateien
String datei ="Testdatei.txt";
Ist append=true, wird an eine bestehende
Datei angehängt
22.05.2009
•
String text ="Hallo Welt";
FileWriter(File file)
throws IOException
•
FileReader
Öffnen einer Datei (existierende Datei wird
überschrieben)
FileWriter(String dateiname,
boolean append)
throws IOException
•
6
FileWriter
•
Methoden
• Liest Textzeile
• Als Zeilenende werden akzeptiert:
line feed (\n), carriage return (\r)
oder (\r\n)
Inhalt der Datei Test.txt
1. Zeile: Hallo
2. Zeile: Welt
import java.io.*;
import java.util.*;
public class BReaderExample {
Vector cont = new Vector();
String datei = “BReaderExample.java";
try {
FileReader fr = new FileReader(datei);
BufferedReader br = new BufferedReader(fr);
String zeile;
while((zeile = br.readLine())!=null)
cont.add(zeile);
br.close();
}
catch (FileNotFoundException e) {}
catch (IOException e) {}
for(int i = (cont.size()-1); i>=0; --i)
Out.println((String) cont.elementAt(i));
– String readLine()
throws IOException
File
30
}
}
BufferedReader
FileReader
File
Ausgabe: Der Quellcode in umgekehrter
Reihenfolge
31
22.05.2009
32
Prog. 2
6
•
Prog. 2
Standard-Datenströme
6
In Java sind die Standard-Datenströme für Eingabe, Ausgabe und
Fehlermeldungen als statische Variablen der Klasse System realisiert
– System.in
•
•
• Statische Variable vom Typ InputStream (Byte-Stream)
• Erwartet standardmäßig eine Eingabe von Tastatur
•
– System.out
• Statische Variable vom Typ PrintStream (Byte-Stream)
• Standard Ausgabe-Strom
Tastatureingabe
Mittels Standard-Eingabestrom
System.in kann die Eingabe von
der Tastatur erreicht werden
Schachtelung mit dem CharacterStream BufferedReader macht
den Einlesevorgang komfortabler
Durch Schachtelung mit
InputStreamReader erhält man
den benötigten Stream vom Typ
Reader
// Einlesen einer Zeile von der Tastatur
import java.io.*;
public class TastaturEingabe {
BufferedReader eingabe =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Eingabe: ");
• Ausgabe wird standardmäßig in die Konsole geschrieben
– System.err
• Statische Variable vom Typ PrintStream (Byte-Stream)
• Strom für Fehlermeldungen
• Ausgabe wird standardmäßig in die Konsole geschrieben
•
22.05.2009
String zeile = "";
BufferedReader eingabe =
new BufferedReader (
new InputStreamReader (
Sytem.in));
33
Mittels readLine() können dann
Zeilen von der Tastatur eingelesen
werden
22.05.2009
try {
zeile = eingabe.readLine();
} catch (IOException e) {}
System.out.println(zeile);
}
}
34

22.05.2009

Transcrição

Documentos relacionados

// IO.java // Java Codebeispiel zur Ein

Woran liegt es wenn nicht alle versendeten E

12.2 Persistente Objekte

Praktikum: Spezifikation

Grundlagen der Programmierung (CS101)

Erstellt mit Poseidon for UML Community Edition

Kurs: Programmieren in Java

Eingebaute Datentypen (primitive types)

Übung 1

und Installation Java