Wie nach der Vorlesung weiter?

01a:1-105

 Alle angegebenen Folien

gewissenhaft durcharbeiten

 Insbesondere die Notizen

zu den einzelnen Folien

 Möglichst auch alle Folien

davor

 Wenn etwas nicht verstanden:

unbedingt im Forum oder in der
Sprechstunde nachfragen
Laufzeitfehler
05:2-9

Was ist das allgemein?

 Kann nicht vom Compiler entdeckt werden
 Laufzeitsystem bricht Ablauf ab
 Call-Stack mit Zeilennummern wird in der
Fehlermeldung angezeigt
 Man sieht sofort, wo der Fehler aufgetreten ist
Laufzeitfehler
05:2-9

Beispiele für Laufzeitfehler:

 Durch 0 teilen bei int
 Auf Attribut / Methode von null zugreifen
 Auf nichtexistierenden Array-Index zugreifen
 Downcast auf Referenztyp, so dass der dynamische
Typ weder gleich dem statischen Typ noch Subtyp
davon ist
Laufzeitfehler
05:2-9

Manche Laufzeitfehler durch Sprache ausgeschlossen:

 Nur Methoden aufrufbar, die im statischem Typ definiert

sind

 Keine Objekte von abstrakten Klassen oder Interfaces

 Durch 0 teilen bei float und double: *_INFINITY und NaN

 Arithmetischer Überlauf bei ganzzahligen Typen: Wird

einfach „schmerzlos“ ausgeführt
Exception-Klassen
05:10-11

Klasse java.lang.Exception

Alle von java.lang.Exception direkt oder

indirekt abgeleiteten Klassen
Exception werfen
05:12-41

public char toUpperCase ( char c ) throws Exception {

if ( c < ´a´ | | c > ´z´ )
throw new Exception ( “No lower-case letter!“ );
return (char)( c – ´a´ + ´A´ );
}
Exception fangen
05:12-41

char x = ´3´;
char y;
try {
y = abc.toUpperCase ( x );
System.out.print ( “Reached this line?“ );
}
catch ( Exception exc ) {
System.out.print ( exc.getMessage() );
}
Exception fangen
05:12-41

char x = ´3´;
char y;
try {
y = abc.toUpperCase ( x );
System.out.print ( “Reached this line?“ );
}
catch ( Exception exc ) {
exc.printStackTrace();
}
Exception werfen
05:12-41

public char toUppercase ( char c )

throws IndexOutOfBoundsException {
if ( c < ´a´ | | c > ´z´ )
throw new IndexOutOfBoundsException
( “No lower-case letter!“ );
return (char)( c – ´a´ + ´A´ );
}
Exception fangen
05:12-41

char x = ´3´;
char y;
try {
y = abc.toUppercase ( x );
System.out.print ( “Reached this line?“ );
}
catch ( IndexOutOfBoundsException exc ) {
System.out.print ( exc.getMessage() );
}
Exception werfen
05:12-41

/**
• @param c the character to be converted to upper case
• @throws class IndexOutOfBoundsException if c ist not a
lower-case letter
• @return upper case of c
*/

public char toUpperCase ( char c ) throws IndexOutOfBoundsException {

if ( c < ´a´ | | c > ´z´ )
throw new IndexOutOfBoundsException ( “No lower-case letter!“ );
return (char)( c – ´a´ + ´A´ );
}
Methoden überschreiben
05:42-46

public class X {
public void m () throws Exception { .......... }
}

public class Y extends X {

public void m () throws IndexOutOfBoundsException {
..........
}
}
Methoden überschreiben
05:42-46

X a = new Y();
try {
a.m();
}
catch ( Exception exc ) {
..........
}
Signatur einer Methode
03c:83-115

Name

Parameterliste: geordnete Sequenz

der Typen der Parameter
Überschreiben einer Methode
03c:83-115

public class X {
public void m () { .......... }
}

public class Y extends X {

public void m () { .......... }
}
Überschreiben einer Methode
03c:83-115

Jeweils nur in eine Richtung variabel:

private  ε  protected  public

Falls Rückgabe von einem Referenztyp:

durch Subtyp ersetzbar
Klassen, Interfaces, Arrays
Exceptionklassen durch abgeleitete
Exceptionklassen ersetzbar
Überschreiben einer Methode
03c:83-115
public class A { public class X {
private A m () {
.......... ..........
} }
}
public class B extends A { public class Y extends X {
......... public B m () {
.........
} }
}
Überschreiben einer Methode
03c:83-115
public class X { Im selben Package:
A m () {
.......... X c = new Y();
}
} A d = c.m();
public class Y extends X {
public B m () {
.........
}
}
Überschreiben einer Methode
03c:83-115
public class X {
protected A m () {
.......... public class Z extends Y {
} private A c;
} public void n ( X d ) {
public class Y extends X { c = d.m();
public B m () { }
.........
}
}
Vererbung Klassenmethoden
03c:83-115

Klassenmethoden
 werden an Subtypen vererbt,
 im Subtyp kann auch eine Klassenmethode mit
derselben Signatur definiert werden,
 aber die Auswahl der Methodenimplementation
richtet sich nach dem statischen Typ,
 nicht nach dem dynamischen Typ wie bei
Objektmethoden.
Überladen von Methoden
03c:83-115

System.out.print ( -123 );
System.out.print ( 3.14 );
System.out.print ( ´!´ );
System.out.print ( “Hello World“ );
System.out.println ( -123 );
System.out.println ( 3.14 );
System.out.println ( ´!´ );
System.out.println ( “Hello World“ );
Überladen von Methoden
03c:83-115

Alle Methoden einer Klasse müssen

unterschiedliche Signatur haben

Bei Überladung müssen die

Sequenzen der Parametertypen
unterschiedlich sein
Überladen von Methoden
03c:83-115

public class X {
public void m () { .......... }
public void m ( int i ) { .......... }
public void m ( double d ) { .......... }
public void m ( int i, double d ) { .......... }
}
Überladen von Methoden
03c:83-115

public class X {
public void m ( int i ) { .......... }
public int m ( int i ) { .......... }
public static void m ( int i ) { .......... }
private void m ( int i ) { .......... }
}
Überladen von Methoden
03c:83-115
public class X {
public void m ( int i, double d ) {
..........
}
public void m ( double d, int i ) {
..........
X a = new X();
}
a.m ( 123, 2.71 );
}
a.m ( 3.14, 321 );
a.m ( 123, 321 );
Exceptions aus Lambda
05:47-50

public interface MyBinaryIntFunction {

int apply ( int m, int n ) throws Exception;
}

MyBinaryIntFunction div =
( m, n ) ->
{ if ( n == 0 ) throw new Exception(); return m / n; };
Eigene Exception-Klasse
05:51-68

public class WitchingHourException extends Exception {

public WitchingHourException () {
super ( “It\'s witching hour!“ );
}

}
Exception werfen
05:51-68

public int hourOfNow ()

throws WitchingHourException {
Calendar cal = Calendar.getInstance();
int hour = cal.get ( Calendar.HOUR_OF_DAY );
if ( hour == 3 )
throw new WitchingHourException();
return hour;
}
Exception fangen
05:51-68

int hourOfNow;
try {
hourOfNow = abc.hourOfNow ();
}
catch ( WitchingHourException exc ) {
System.out.print ( exc.getMessage() );
}
Mehrere Exception-Klassen werfen
05:69-89

public void printHour ( int hour ) throws

IndexOutOfBoundsException, WitchingHourException {
String excStr = “Invalid hour : “ + hour;
if ( hour < 0 || hour >= 24 )
throw new IndexOutOfBoundsException ( excStr );
if ( hour == 3 )
throw new WitchingHourException ();
System.out.print ( hour );
}
Mehrere Exception-Klassen fangen
05:69-89

Calendar cal = Calendar.getInstance();

int hour = cal.get ( Calendar.HOUR_OF_DAY );

try {
x.printHour ( hour );
}
catch ( IndexOutOfBoundsException exc ) { .......... }
catch ( WitchingHourException exc ) { .......... }
Mehrere Exception-Klassen fangen
05:69-89

public void printHour ( int hour ) throws Exception {

String excStr = “Invalid hour : “ + hour;
if ( hour < 0 || hour >= 24 )
throw new IndexOutOfBoundsException ( excStr );
if ( hour == 3 )
throw new WitchingHourException ();
System.out.print ( hour );
}
Mehrere Exception-Klassen fangen
05:69-89

try {
abc.printHour ( hour );
}
catch ( WitchingHourException exc ) { .......... }
catch ( RuntimeException exc ) { .......... }
catch ( Exception exc ) { .......... }
Mehrere Exception-Klassen fangen
05:69-89

try {
abc.printHour ( hour );
}
catch ( WitchingHourException exc ) { .......... }
catch ( IndexOutOfBoundsException exc ) { .......... }
catch ( RuntimeException exc ) { .......... }
catch ( Exception exc ) { .......... }
Mehrere Exception-Klassen fangen
05:69-89

try {
abc.printHour ();
}
catch ( AException | BException exc ) { .......... }
catch ( Exception exc ) { .......... }
Exception weiterreichen
05:90-95

public void printHourOfNow ()

throws WitchingHourException {
Calendar cal = Calendar.getInstance();
int hour = cal.get ( Calendar.HOUR_OF_DAY );
x.printHour ( hour );
}
Exception weiterreichen
05:90-95
try-with-resources
05:96-98

try ( Printer printer = .......... ) {

..........
}
catch ( .......... ) { .......... }
catch ( .......... ) { .......... }
Runtime Exceptions
05:99-117

Hat eine Methode eine throw-Klausel, muss jeder

Aufruf in einen try-Block
 Alle Exceptions werden gefangen

Ausnahme:
Exceptions von java.lang.RuntimeException
bzw. unmittelbar oder mittelbar davon
abgeleitete Klassen
Runtime Exceptions
05:99-117

Beispiele:

ArithmeticException
ClassCastException
IndexOutOfBoundsException
NegativeArraySizeException
NullPointerException
Runtime Exceptions
05:99-117

public class X { .......... } X a = new X ();

public class Y1 extends X { .......... X b = new Y1 ();
} X c = new Y2 ();
public class Y2 extends X { .......... X d = new Z ();
}
public class Z extends Y1 { .......... (Y1)b (Y1)a
} (Y1)d (Y1)c
Throwable und Error
05:118-131

public class Throwable { .......... }

public class Exception extends Throwable { .......... }

public class Error extends Throwable { .......... }

AssertionError

public class Error extends Throwable { .......... }

public class AssertionError extends Error {

..........
}
AssertionError

if ( n < 0 || n % 2 == 1 )
throw new AssertionError ( “Bad n!“ );

assert n >= 0 && n % 2 == 0 : “Bad n!“;

AssertionError

public static int factorial ( int n ) {

assert n >= 0;
int result = 1;
for ( int i = 1; i <= n; i++ )
result *= i;
return result;
}