Ashraf Abu Baker [email protected]

Java-Intensivkurs WS07/08Folie 1

Ashraf Abu [email protected]

Johann Wolfgang Goethe-UniversitätProfessur für Graphische DatenverarbeitungFachbereich Informatik und MathematikProf. Dr. Detlef Krömker


Interfaces

Ein Interface (Schnittstelle) besteht aus einer Sammlung von statischen Konstanten und abstrakten Methoden, die als public deklariert sind

Ein Interface kann als abstrakte Klasse aufgefasst werden, die nur abstrakte Methodendeklarationen und statische Kostanten umfasst

Interfaces werden mit dem Schlüsselwort interface deklariert, dürfen keine Konstruktoren definieren und können daher nicht instanziiert werden


Interfaces

Alle in einem Interface definierten Attribute sind automatisch statische Konstanten, die initialisiert werden müssen

public interface GeometricObjectInterface {//Interface declaration

public static final int CIRCLE=0;public static final int RECTANGLE=1;public static final int SQUARE=2;

public int getType();

public abstract float getCircumference();//Berechnet den Umfang eines geometrischen Objektes}


Interfaces

Interfaces werden erstellt, um von Klassen implementiert zu werden

Eine Klasse, die ein Interface implementiert, muss alle Methoden des Interfaces überschreiben:public class Circle implements GeometricObjectInterface{

public float radius;

public Circle(float radius){this.radius=radius;}

public int getType(){return GeometricObjectInterface.CIRCLE;}

public float getCircumference(){return (float)(2*Math.PI*radius);}}


Interfaces

public class Square implements GeometricObjectInterface{

public float side;

public Square(float side){this.side=side;}

public float getCircumference(){ return 4*side;}

public int getType(){return GeometricObjectInterface.SQUARE;

}}


Interfaces

Eine Klasse, die nicht alle Methoden eines Interfaces implementiert, muss als abstract deklariert werden

Interfaces können wie Klassen voneinander abgeleitet werden

Interfaces können als ein restriktiver Mechanismus für Mehrfachvererbung verwendet werden

So kann eine Klasse mehrere Interfaces implementieren. Sie muss dann zu jedem Interface alle darin definierten Methoden implementieren:


Das Interface Comparable

Eine Klasse, die dieses Interface implementiert, definiert eine Ordnung auf ihre Objekte und macht sie paarweise vergleichbar

Ihre Objekte können z.B. von Sortiermethoden sortiert werden

public interface Comparable<T>{public int compareTo(T o);}


Comparable

public class ComparablePoint extends Point implements Comparable{

public float x1;public float y1;

@Overridepublic int compareTo(ComprablePoint p) {

if(x1<p.x1 || this.y1<p.y1) return -1;if(x1==p.x1 || this.y1==p.y1) return 0;return 1;

}}


Comparable

Alle Wrapper-Klassen und viele andere Klassen wie String, Date, File… implementieren das Comparable Interface


Namenskonventionen

Ein Namenskonvention ist eine Empfehlung wie Pakete, Klassen, Variablen, Methoden, Interfaces… etc. sinnvoll bezeichnet werden sollen

Paketnamenskonvention:

Paketnamen sollten aus Kleinbuchstaben bestehenSollten kurze Nomen (Substantive) seinSie dürfen auch Ziffern enthaltenBeispiel:

de.frankfurt.cs.gdv.visian3d


Namenskonventionen

Klassennamen:Beginnen mit einem Großbuchstaben und sollten Nomen (Substantive) sein

Besteht ein Klassenname aus mehreren Silben wie z.B. BinaryNode, RedBlackTree so beginnt jeder Silbe beginntebenfalls mit einem Buchstaben

Beispiele:

Point, ComplexNumber, VisualBinarySearchTree…


Namenskonventionen

Methodennamen:Beginnen mit KleinbuchstabenSollten Verbe get(), run(), save()… sein

Besteht ein Methodenname aus mehreren Silben wie z.B. getUserName() so beginnt jeder Silbe beginntmit einem Buchstaben

Boolesche Funktionen sollten mit „is“, „has“, „can“, etc. anfangen

run(), getLeftChild(),setName(), isReady(), shouldWait()..


Namenskonventionen

Variablennamen:

Beginnen mit Kleinbuchstaben

Darauffolgende Silben fangen mit einem Großbuchstaben an

Sie sollten kurz und ausdrucksstark sein

Boolesche Variablen sollten mit „is“, „has“, „can“ etc. anfangen

age, userName, isVisible, hasTicket, canStart, shouldRestarted….


Namenskonventionen

Konstantennamen:

Bestehen aus GroßbuchstabenSilben werden durch einen Unterstrich getrennt

SIZE, MAX_VALUE, EDGE_COLOR


Namenskonventionen

Interfaces :Beginnen mit einem Großbuchstaben und sollten Nomen (Substantive) sein

Silben beginnen ebenfalls mit einem Buchstaben

GeometricObjectInterface


Object, Math und String

Object ist die Oberklasse aller Java-Klassen Jede Klasse, die nicht explizit von einer anderen Klasse abgeleitet wird, wird implizit von Object abgeleitet

Klasse Object verfügt über zahlreiche Methoden:

class A { }//ist äquivalent zu class A extends Object { }


Object

public String toString():Liefert eine String-Darstellung eines Objektes zurück Wird z.B. von der Methode System.out.println() aufgerufen

Standardimplementierung der Methode liefert den Klassennamen und den HashCode des Objektes im Hexdezimal-Format als String zurück:

//Standardimplementierung von toString() in der Klasse Objectpublic String toString(){

return getClass().getName()+"@"+Integer.toHexString(hashCode());}


Object

Will man eine sinnvolle String-Darstellung des Objektes haben, dann muss die Methode überschrieben werden:

Bankkonto alexKonto=new Bankkonto(35870,"Alex M.",2103);System.out.println(alexKonto);

Ausgabe: Bankkonto@3e25a5


Object

Überschreibung der toString-Methode in Bankkonto

//Überschreibung von toString() in Bankkontopublic String toString(){

return "Kontoinformation:\r\n"+ "Kontonummer: "+kontoNummer+"\r\n"+ "Kontoinhaber(in): "+inhaber+"\r\n"+ "Kontostand: "+kontoStand+" €\r\n";

}Bankkonto alexKonto=new Bankkonto(35870,"Alex M.",2103);System.out.println(alexKonto);Ausgabe:Kontoinformation:Kontonummer: 2150Kontoinhaber(in): Alex M.Kontostand: 12350.0


Objektvergleiche

Zwei Möglichkeiten, Objekte zu vergleichen Mit "==" boolean equals(Object o)

Für primitive Variablen überprüft „==„ , ob die beiden Variablen den gleichen Wert haben Für Referenzen überprüft „==„ , ob zwei Referenzen auf dasselbe Objekt verweisen

- Es werden die Referenzwerte (Speicheradressen) verglichen


Objektvergleiche

boolean equals(Object o)Überprüft zwei verschiedene Objekte auf inhaltliche Gleichheit(Vergleicht die Objekte nicht die Referenzen)

Die standardmäßige Implementierung von boolean equals(Object o) führ lediglich einen Referenzvergleich durchund ist somit äquivalent zu „==„ boolean equals(Object o) sollte in der eigenen Klasse überschrieben werden

//Standardimplementierung von equals(Object o) in der Klasse Objectpublic boolean equals(Object o){

return this==o;}


HashCode

Ein HashCode ist:

Ein Integerwert

Repräsentiert die Eindeutigkeit eines Objektes Zwei Objekte, die gemäß der equals()-Methoden gleich sind, müssen den gleichen HashCode haben

Wird verwendet in den Collections (Datenstruktren), die hashbasiert sind


Math

Enthält eine Sammlung von mathematischen Methoden und Kostanten Ist als final deklariert darf nicht abgeleitet werden

Enthält nur einen privaten Konstruktor kann nicht instanziiert werden

//Kompilierfehler: The constructor Math() is not visibleMath math=new Math();


Math

Methode Rückgabeabs(int i) Absolutbetrag von i

ceil(double d) Nächste Ganzzahl größer gleich i

exp(double a) ea

floor(double d) Nächste Ganzzahl kleiner gleich i

log(double a) ln(a)

max(int i1, i2) Maximum der Zahlen i1 und i2

min(int i1, i2) Minimum der Zahlen i1 und i2

pow(double a, double b) ab

random() Eine Zahl aus dem Intervall[0.0,1.0]

sin(double d) Sinus-Funktion

cos(double d) Kosinus-Funktion

tan(double d) Tangens-Funktion

round(double d) Rundet d zur nächsten Ganzzahl


String

Eine Zeichenkette (String) in Java ist eine indizierte geordnete Folge von Unicode-Zeichen Indexierung beginnt bei 0

Strings sind unveränderbar (immutable)

Strings ist final

Ein String-Objekt kann entweder mit einem Konstruktor der Klasse String oder als String-Literal erstellt werden


String

public static void stringCompare(){String s1=new String("use the equals()-method to compare strings");String s2=new String("use the equals()-method to compare strings");

String s3="use the equals()-method to compare strings";//String-LiteralString s4="use the equals()-method to compare strings";//String-Literal

boolean s1_s2= false , s3_s4=false s2_s3=false;if(s1==s2) s1_s2=true; if(s3==s4) s3_s4=true; if(s2==s3) s2_s3=true; System.out.println(s1_s2+" "+s3_s4+" "+s2_s3);s2=s3;if(s2==s3) s2_s3=true;System.out.println(s2_s3);

Ausgabe: false true false true


String

int length(): Liefert die Länge der Zeichenkette zurück

charAt(int index): Liefert das Zeichen an Position index zurück

- index muss zwischen 0 und length()-1 liegen,sonst wird eine java.lang.StringIndexOutOfBoundsException geworfen

substring(int begin, int end): Liefert den Teilstring zurück, der am Index begin beginnt und am Index end-1 einschließlich endet

substring(int begin): Liefert den Teilstring von der angegebenen Position bis zum Ende des Strings zurück


String

trim(): Liefert den String zurück, der entsteht, wenn alle Leerzeichen am Anfang und am Ende des Strings entfernt werden

equalsIgnoreCase(): Vergleicht String miteinander ohne Groß-/Kleinschreibung zu beachten

toLowerCase() Wandelt den String in Kleinbuchstaben um, liefert ihn zurück

toUpperCase(): Wandelt den String in Großbuchstaben um, liefert ihn zurück


String

replace(char oldChar, char newChar): Ersetzt alle vorkommen des Zeichens oldChar durch das Zeichen newChar:


Exceptions

Ausnahmen (Exceptions) sind Java-Klassen zur Erkennung und Behandlung von Laufzeitfehlern

Ein Laufzeitfehler ist ein Fehler, der während der Ausführung eines Programms auftritt und während des Kompiliervorganges nicht erkannt werden kann

Ein Exception-Objekt repräsentiert einen Laufzeitfehler, der den normalen Ablauf des Programms stört oder gar beendet


Exceptions

Drei Arten von Fehlern

Vermeidbare Fehler (Bugs):

Das sind Fehler, die durch den Programmierer verursacht werden und praktisch vermieden werden können

- Division durch 0 - Zugriff auf einen ungültigen Arrayindex - Zugriff auf eine null-Referenz


Fehlerarten in Java

Unvermeidbare Fehler:

Ein Programm versucht auf einen Server zuzugreifen, der gerade ausgeschaltet ist

Ein Programm versucht eine Datei zu öffnen, die beschädigt ist bzw. gelöscht wurde

Ein Programm fordert den Benutzer auf eine Zahl einzugeben. Stattdessen gibt der Benutzer ein String ein


Fehlerarten in Java

Systemfehler (System Errors):

Das sind schwerwiegende nicht behebbare Fehler, nach deren Auftreten die Fortsetzung des Programms nicht sinnvoll bzw. gar nicht möglich ist

Führen zu einem Programmabbruch und zur Beendigung des Interpreters

- Beispiele: Speicherüberlauffehler (Memory Overflow), Fehler in der JVM


Fehlerbehandlung

Zur Behandlung von Laufzeitfehlern stellt Java das Exception-Konzept zur Verfügung

Wenn ein Programmteil (eine Methode oder Anweisung) einen Fehler verursacht, löst die JVM eine Ausnahme (throwing exception), die vom Programm abgefangen (catching exception) und behandelt (handling exception) werden kann

Zur Behandlung einer Ausnahme übergibt die JVM an das Programm ein Exception-Objekt, das Informationen über den Fehler enthält wie z.B. Fehlerart, Fehlerbezeichnung Programmzustand zum Zeitpunkt des Auftreten des Fehlers …etc


Fehlerbehandlung

//try to convert a string to a numberconvertStringToNubmer(String numberString){ try{

float number = Float.parseFloat(numberString);System.out.println("Converting "+numberString+

" to a number succeeded: "+number);}//Catching the exceptioncatch (NumberFormatException exceptionObject){

//handling the exceptionSystem.out.println("Exception: Unable to convert "

+numberString+" to a number!");System.out.println(exceptionObject.getMessage());

System.out.println("Printing the stack trace...");exceptionObject.printStackTrace();}}

Die Behandlung von Ausnahmen erfolgt mittels der try-catch-Anweisung:


Fehlerbehandlung

convertStringToNubmer("549.34");

Ausgabe: Converting 549.34 to a number succeeded: 549.34

convertStringToNubmer("549,34");Ausgabe: Exception: Unable to convert 549,34 to a number! For input string: "549,34" Printing the stack trace... java.lang.NumberFormatException: For input string: "549,34"

at sun.misc.FloatingDecimal.readJavaFormatString(Unknown Source)

at java.lang.Float.parseFloat(Unknown Source)at

exceptions.SimpleException.convertStringToNubmer(SimpleException.java:25)

at exceptions.SimpleException.main(SimpleException.java:39)


Throwable

Die Vaterklasse aller Exceptions ist die Klasse java.lang.ThrowableZwei wichtige Methoden:

getMessage() Wenn ein Laufzeitfehler auftritt, generiert die JVM ein

Ausnahme-Objekt und speichert in ihm eine Textnachricht getMessage() gibt diese Nachricht zurück

printStackTrace() liefert eine Art Momentaufnahme des Programmstacks (stack trace) zum Zeitpunkt des Auftretens des Fehlers in Form einer Textnachricht zurück


Ausnahmetypen

Zwei Arten von AusnahmenGeprüfte Ausnahmen (checked exceptions) Laufzeitausnahmen (runtime exceptions)

Laufzeitausnahmen repräsentieren vermeidbare Fehler

Beispiele: ArrayIndexOutOfBoundsException, NegativeArraySizeException, NullPointerException und StringIndexOutOfBoundsException

int x=1/3;int y=2/x;//Division durch null --> // Laufzeitausnahme: ArithmeticException:/by zero


Ausnahmetypen

Die geprüften Ausnahmen dagegen repräsentieren unvermeidbare Fehler und Systemfehler

Beispiele FileNotFoundException und IOException public void printFile(String fileName){//try to read and print the given fileBufferedReader input = null;

try { input = new BufferedReader( new

FileReader(fileName) ); String line = null; while (( line = input.readLine()) != null){ System.out.println(line); } } catch (IOException ex){ ex.printStackTrace();}


Ausnahmetypen

Alle aus der Klasse java.lang.RunTimeException abgeleiteten Exceptions sind Laufzeitausnahmen

Laufzeitausnahmen können, jedoch müssen nicht abgefangen und behandelt werden

try{ int x=1/3; int y=2/x }catch(ArithmeticException exceptionObject){//Catching the exception

//handling the exceptionSystem.out.println("x ist 0. Division wurde nicht ausgeführt!");}


Ausnahmetypen

Alle aus der Klasse java.lang.Exception abgeleiteten Exceptions sind geprüfte Exceptions

Geprüfte Ausnahmen dagegen müssen vom Programmierer mittels einer try-catch-Anweisung immer abgefangen und behandelt werden


Auslösen einer Exception

Der Programmierer kann Methoden definieren, die selbst Ausnahmen auslösen:

Eine Methode kann eine oder mehrere Ausnahmen werfenDies erfolgt mithilfe der throws Anweisung

public long factorial(int n) throws NegativeValueException {//if n<0 then throw an exception

if(n<0) throw new NegativeValueException ("invalid parameter: "+n);

//else return factorial(n) }


Behandeln einer Exception

Da factorial() eine geprüfte Ausnahme wirft (siehe API-Dokumentation), muss jede andere Methode, die factorial() aufrufen will, dies innerhalb einer try-catch-Anweisung tun

public long calculator(int n) {// the calculator method calls the factorial method try{ return factorial(n); } catch (Exception exceptionObject){

System.out.println("The input parameter of factorial "+ +"must be a positive number!");}


Weitergabe von Exceptions

Es ist auch möglich das Abfangen und die Behandlung einer Ausnahme an die aufrufende Methode weiterzugeben, wie das folgende Beispiel zeigt:

public long calculator(int n) throws Exception { int x= n/2; return factorial(x); }


Behandlung von mehreren Ausnahmen

public void printFile(String fileName){//try to read and print the given fileBufferedReader input = null;

try { input = new BufferedReader( new FileReader(fileName) ); String line = null; while (( line = input.readLine()) != null){ System.out.println(line); } } catch (FileNotFoundException ex) { ex.printStackTrace(); } catch (IOException ex){ ex.printStackTrace(); }}


finally

Am Ende einer try-catch-Anweisung kann ein finally-Block stehen

Der fianlly-Block wird immer ausgeführt, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht


finally

public void finalyMethod(){try{ Random rand=new Random();

int x=rand.nextInt(6); System.out.println("x="+x);int y=2/x;//Division durch null -->ArithmeticException:/by 0

}

catch (ArithmeticException arithmeticExceptionObject){

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

finally{System.out.println("Finally-Block");

}}


Erstellung eigener Exception-Klassen

Zur Erstellung einer eigenen Exception-Klasse, muss entschieden werden, ob die neue Ausnahme eine geprüfte

oder eine Laufzeitausnahme sein soll Eine Laufzeitausnahme muss von der Klasse java.lang.RuntimeException oder von einer ihrer Unterklassen abgeleitet werden

Eine geprüfte Ausnahme muss von der Klasse java.lang.Exception oder von einer ihrer Unterklassen abgeleitet werden

Die Klasse soll zwei Konstruktoren deklarieren, einen parameterlosen Konstruktor und einen Konstruktor, der als Parameter eine Textnachricht (message) übergeben bekommt


Erstellung einer geprüften Exception

/** * Checked exception used in the method factorial of the class * SimpleException * */ public class NegativeValueException extends Exception{

public NegativeValueException(){

}public NegativeValueException(String message){

super(message);}

}


Erstellung einer Laufzeit-Exception

/** * Runtime exception used in the method auszahlen() of the class * exceptions.Bankkonto */public class KreditLimitUeberschrittenException extends RuntimeException{

public KreditLimitUeberschrittenException(){

}

public KreditLimitUeberschrittenException(String message){super(message);

}}

Ashraf Abu Baker [email protected]

Documents