Java-Intensivkurs WS07/08 Folie 1 Ashraf Abu Baker Johann Wolfgang Goethe-Universität Professur für Graphische Datenverarbeitung.

Präsentation zum Thema: "Java-Intensivkurs WS07/08 Folie 1 Ashraf Abu Baker Johann Wolfgang Goethe-Universität Professur für Graphische Datenverarbeitung."—  Präsentation transkript:

1 Java-Intensivkurs WS07/08 Folie 1 Ashraf Abu Baker baker@gdv.cs.uni-frankfurt.de Johann Wolfgang Goethe-Universität Professur für Graphische Datenverarbeitung Fachbereich Informatik und Mathematik Prof. Dr. Detlef Krömker

2 Java-Intensivkurs WS07/08 Folie 2 Organisatorisches Intensivkurs vom 01.10.07 bis zum 12.10.07 9:00-10:30 Vorlesung 10:30-12:15 Bearbeitung von theoretischen Multiple- Choice-Aufgaben 12:15-13:00 Tutorium (Lösung der MC-Aufgaben) 13:00-14:00 Pause 14:00-18:00Programmierung an den RBI-Rechnern

3 Java-Intensivkurs WS07/08 Folie 3 Organisatorisches Teilnahmeschein (kein Leistungsschein, keine Kreditpunkte) Voraussetzung: Erfolgreiche und regelmäßige Teilnahme Mindestens 50% der Übungspunkte Bei 7 der Übungsblätter müssen für den theoretischen und praktischen Teil jeweils mindestens 20% der Mindestpunktzahl erreicht werden Programmieraufgaben zählen doppelt so viel wie MC-Aufgaben

4 Java-Intensivkurs WS07/08 Folie 4 Aktuelle Information http://www.gdv.informatik.uni-frankfurt.de/

5 Java-Intensivkurs WS07/08 Folie 5 Einleitung Java ist eine Technologie: Plattform Programmiersprache Plattform (im Allgemeinen): Hardware- oder Softwareumgebung Betriebssystem + Hardware Java ist nur eine Software-Plattform API (Java Application Programming Interface) JVM (Java Virtual Machine)

6 Java-Intensivkurs WS07/08 Folie 6 Einleitung Java-API: Sammlung aus Java-Programmen, die in Pakete (packages) aufgeteilt sind Pakete: Bibliotheken aus Klassen und Interfaces

7 Java-Intensivkurs WS07/08 Folie 7 Einführung JVM: Plattformunabhängige Softwareumgebung, die Java-Bytecode in Maschinensprache übersetzt, interpretiert und ausführt Kann als Bytecode Interpretier- und Ausführungsumgebung verstanden werden Bytecode: Datei mit der Erweiterung „.class“ Entsteht, wenn ein Java-Compiler ein Java-Programm kompiliert und übersetzt Das einzige Codeformat, das die JVM verstehen kann

8 Java-Intensivkurs WS07/08 Folie 8 Einführung Plattformunabhängig? Da Java-Programme von der JVM und nicht direkt von der Hardware ausgeführt werden, sind sie plattformunabhängig.

9 Java-Intensivkurs WS07/08 Folie 9 Entwicklungsgeschichte Java ist 12 Jahre alt JahrVersionPaketeKlassenNeue Features 19961.07 210Applets, AWT, I/O, Net 19971.122ca. 600RMI, JDBC,… 19981.2591524Swing, Collections,… 20001.3761840CORBA ORB, Sound, Servlets… 20021.41352723XML Processing, JNI,… 20041.51653279Generics, Enhanced for Loop, Autoboxing, Enums, Annotations… 20061.62023777Scripting, Compiler Access, Desktop Deployment…

10 Java-Intensivkurs WS07/08 Folie 10 Entwicklung von Java-Programmen Vorbereitung: Java Development Kit (JDK) Entwicklungsumgebung Eclipse

11 Java-Intensivkurs WS07/08 Folie 11 Entwicklung von Java-Programmen Java-Programm Höchstens eine public-Klassendefinition (public top level class definition) Eine unbeschränkte Anzahl von nicht public-Klassendefinitionen (non public top level class definitions) Java-Quelldateien Unicode-Dateien, die mit der Erweiterung „.java“ gespeichert werden

12 Java-Intensivkurs WS07/08 Folie 12 Programmbeispiel /** * A java program containing 1 public- and 2 non public class * definitions. */ public class HelloWorld {// public class definition} class MyFirstClass {// non public class definition} class MySecondClass {// non public class definition} Enthält ein Java-Programm eine top-level- Klassendefinition z.B. namens MyJavaProgram, so muss seine Quelldatei MyJavaProgram.java heißen

13 Java-Intensivkurs WS07/08 Folie 13 Bestandteile eines Java-Programms Ein Programm kann drei sog. top-level- Kompiliereinheiten beinhalten Paket-Deklaration (package declaration) Import-Anweisungen (import statements) Klassen- oder Interface-Definitionen (class/interface definitions) Alle genannten Kompiliereinheiten sind optional Wenn sie jedoch in einer Java-Quelledatei vorkommen, dann müssen sie in der obigen Reihenfolge erscheinen

14 Java-Intensivkurs WS07/08 Folie 14 Pakete Imports & Klassen package mypackage ; // package declaration import javax.swing.JButton; // import statement import javax.swing.JPanel;// import statement /* * A top-level class definition */ public class MyClass{ //class body (Klassenrupf) } // interface definition interface MyInterface{}

15 Java-Intensivkurs WS07/08 Folie 15 Pakete & Imports Pakete: Dienen der logischen Gruppierung und Organisation von Klassen und Interfaces Entsprechen Programmierbibliotheken in anderen Programmiersprachen Import-Anweisungen: Dienen der Verfügbarkeitsmachung von Klassen aus anderen Paketen

16 Java-Intensivkurs WS07/08 Folie 16 Kommentare Drei Arten von Kommentaren: Zeilenkommentare: Ein Zeilenkommentar ist genau eine Zeile lang Blockkommentare: Können sich über mehrere Zeilen strecken Dokumentationskommentare: -Werden vom Javadoc-Tool verwendet -Für die automatische Generierung von Klassen- und Interface-Dokumentationen -Beginnen mit “/**“ und enden mit “*/“ /** * java-doc comment */ // line comment /* * block comment */

17 Java-Intensivkurs WS07/08 Folie 17 Applikationen und Applets Zwei Arten von Java-Programmen: Applikationen und Applets Eine Applikation ist ein Java-Programm, das als eigenständige Anwendung (stand alone application) von einer auf einem Rechner installierten JVM, ausgeführt werden kann Applets sind Java-Programme, die in HTML-Seiten eingebettet werden und von einem Javafähigen Web-Browser als Web- Anwendungen gestartet werden Ein Javafähiger Browser ist ein Browser, für den die JVM als Plug-In installiert ist

18 Java-Intensivkurs WS07/08 Folie 18 Applikationen Es ist die Aufgabe des Programmierers festzulegen, ob sein Programm als Applikation, als Applet oder auch als beides funktionieren soll Ein Programm, das als eigenständige Applikation ausgeführt werden soll, muss eine sog. main-Methode enthalten Dient als Startpunkt der Applikation //Signatur der main-Methode public static void main(String[] input){ } //bzw. (seit JDK 5) public static void main(String... input) {}

19 Java-Intensivkurs WS07/08 Folie 19 Applikationen Warum muss jede Applikation eine main-Methode enthalten? Was passiert, wenn eine Applikation gestartet werden soll? Die Applikation repräsentiert durch ihre Klasse, wird in die JVM geladen Die JVM durchsucht dann die Klasse nach der main-Methode

20 Java-Intensivkurs WS07/08 Folie 20 Applikationen Wird die main-Methode gefunden, übergibt ihr die JVM ein Parameterarray und fängt anschließend mit der sequenziellen Ausführung der in ihr enthaltenen Anweisungen an Das Parameterarray enthält ggf. die Eingabeparameter, die an das Programm übergeben werden sollen Enthält die Klasse keine solche Methode, so wird eine Fehlermeldung ausgegeben

21 Java-Intensivkurs WS07/08 Folie 21 Bezeichner (Identifier) Java-Bezeichner: Werden zur Benennung von Variablen, Methoden, Klassen, Interfaces, Paketen... verwendet Beliebig lange Folge aus Buchstaben, Ziffern und den Unicode- Zeichen $ und _ Müssen mit einem Buchstaben, einem $-Zeichen oder einem Unterstrich „_“ beginnen int minValue;//legal int $minValue;//legal int _ minValue ;// legal int $;//legal int $_;//legal int _;//legal int _3;//legal int a3;//legal int 3a;//illegal int !maxValue;//illegal int -maxValue;//illegal int min-Value ;// illegal int min!Value ;// illegal int _int; // legal

22 Java-Intensivkurs WS07/08 Folie 22 Bezeichner Dürfen keine Java-Schlüsselwörter sein Sind case-sensitive abstractcontinuefornewswitch assertdefaultgotopackagesynchronized booleandoifprivatethis breakdoubleimplementsprotectedthrow byteelseimportpublicthrows caseenuminstanceofreturntransient catchextendsintshorttry charfinalinterfacestaticvoid classfinallylongstrictfpvolatile constfloatnativesuperwhile int _int;//legal int newVariable;//legal int ifConstant;//legal int If;//legal int New;//legal int Private;//legal int $boolean;//legal

23 Java-Intensivkurs WS07/08 Folie 23 Variablen Variable: Symbol für einen Speicherbereich Speichert Daten eines bestimmten Datentyps Java ist eine stark typisierte Programmiersprache  Jede Variable und jeder Ausdruck muss zur Kompilierzeit an einen bestimmten Datentypen gebunden sein

24 Java-Intensivkurs WS07/08 Folie 24 Datentypen Primitive Datentypen (primative data types) Referenzdatentypen (reference data types)

25 Java-Intensivkurs WS07/08 Folie 25 Primitive Datentypen Datentyp Länge (Bytes)Wertebereich boolean 1 true, false char 2 16-Bit-Unicode-Zeichen (0x0000 … 0xffff) byte 1 –2 7 bis 2 7 –1 short 2 –2 15 bis 2 15 –1 int 4 –2 31 bis 2 31 –1 long 8 –2 63 bis 2 63 –1 float 4 1,4E-45f … 3,4E+38f double 8 4,9E-324 … 1,7E+308 8 Datentypen Boolean -Logischer Datentyp -1 Byte lang -false oder true

26 Java-Intensivkurs WS07/08 Folie 26 Char char: Unicode-Zeichen bzw. Ganzzahlen aus dem Intervall [0, 2 16 -1] char ist der einzige numerische Datentyp, der nicht vorzeichenbehaftet ist Mit char-Variablen können ganzzahlige Berechnungen durchgeführt werden char a='a';//entspricht der Zahl 97 char b='b';//entspricht der Zahl 98 int aPlusb=a+b; char c=99; int aPlusbplusC=aPlusb+c; System.out.println("a+b="+aPlusb+",a+b+c="+aPlusbplusC); Ausgabe: a+b=195, a+b+c=294

27 Java-Intensivkurs WS07/08 Folie 27 Ganzzahlentypen byte, short, int, long Numerische vorzeichenbehaftete Integraltypen Stellen Ganzzahlen dar Können in 3 Formaten dargestellt werden -Dezimalformat : z.B. 281 -Oktalzahlen (Zahlen zur Basis 8 ): beginnen mit „0“ z.B. 0431 -Hexadezimal (Zahlen zur Basis 16 ): beginnen mit „0x“ z.B. 0x119 int _281_as_decimal=281; int _281_as_oktal=0431; int _281_as_hexadecimal=0x119; System.out.println(_281_as_decimal+" "+_281_as_oktal+" "+_281_as_hexadecimal); Ausgabe: 281 281 281

28 Java-Intensivkurs WS07/08 Folie 28 Fließkommatypen float, double numerische vorzeichenbehaftet Fleißkommatypen Stellen Fließkommazahlen dar Double-Zahlen sind doppelt so lang und doppelt so genau wie Float-Zahlen float _22_divided_by_7_as_float=22/7.f; double _22_divided_by_7_as_double =22/7.d; System.out.println("_22_divided_by_7_as_float: "+_22_divided_by_7_as_float); System.out.println("_22_divided_by_7_as_double: "+ _22_divided_by_7_as_double); Ausgabe: _22_divided_by_7_as_float: 3.142857 _22_divided_by_7_as_double: 3.142857142857143

29 Java-Intensivkurs WS07/08 Folie 29 Fließkommatypen Float-Zahlen müssen mit dem Suffix „f“ bzw. groß „F“ enden -Beispiel: 2.4f oder 2.4F Double-Zahlen können mit dem Suffix „d“ bzw. groß „D“ enden -Beispiel: 2.4d oder 2.4D Eine suffixlose Kommazahl wird vom Compiler automatisch als Double-Zahl interpretiert -2.4 ist eine Double-Zahl Um eine Fließkommazahl von einer Ganzzahl unterscheiden zu können, muss mindestens der Dezimalpunkt, der Exponent oder der Suffix vorhanden sein -Beispiele: 1.,.1, 2E4, 2e4, 2f, 5D

30 Java-Intensivkurs WS07/08 Folie 30 Wrapper-Klassen Zu jedem primitiven Datentypen in Java gibt es eine korrespondierende Wrapper-Klasse Kapselt die Variable in einer objektorientierten Hülle Wrapper-Klassen verfügen über Zahlreiche Methoden und Kostanten TypWrapper-KlasseKonstanten boolean BooleanFALASE, TRUE char CharacterMIN_VALUE, MAX_VALUE, SIZE byte ByteMIN_VALUE, MAX_VALUE, SIZE, NaN short ShortMIN_VALUE, MAX_VALUE, SIZE, NaN int IntegerMIN_VALUE, MAX_VALUE, SIZE, NaN long LongMIN_VALUE, MAX_VALUE, SIZE, NaN float Float MAX_EXPONENT,MIN_EXPONENT, MIN_VALUE, MAX_VALUE, SIZE, NaN double Double MIN_EXPONENT,MIN_VALUE, MAX_VALUE, SIZE,MAX_EXPONENT, NaN

31 Java-Intensivkurs WS07/08 Folie 31 Arithmetik- & Fließkommaprobleme FehlerartBeispielErgebnis OverflowInfinity Rundungsfehlertrue Rundungsfehler0.0/0.0NaN Rundungsfehler1.0/0.0Infinity Rundungsfehlertrue Arithmetische Operationen können ungültige Werte produzieren bzw. Rundungsfehler verursachen

32 Java-Intensivkurs WS07/08 Folie 32 Typkonvertierung & Casting Jede Variable in Java ist an einen Typ gebunden Java erlaubt den Datentyp einer Variable in einen anderen Datentyp zu konvertieren Zwei Arten von Typkonvertierungen: Implizite (automatische ) Typkonvertierung -Wird vom Compiler automatisch durchgeführt Explizite Typumwandlung (casting) -Kann bzw. muss vom Programmierer durchgeführt werden

33 Java-Intensivkurs WS07/08 Folie 33 Typkonvertierung & Casting /* * Package: default * Class: Samples * Method: typeConversion() */ //Beispiele für implizite Typkonvertierungen System.out.println(710);//implizite Typumwandlung von //integer in String System.out.println(3.5);//implizite Typumwandlung von //double in String int k=5/2;//ganzzahlige Division. k hat den Wert 2 System.out.println("5/2="+k); Ausgabe: 710 3.5 5/2=2

34 Java-Intensivkurs WS07/08 Folie 34 Typkonvertierung & Casting //Beispiele für implizite Typkonvertierungen System.out.println("5/2.0="+5/2.0+" Das Ergebnis ist vom Type double!"); System.out.println("5/2.0f="+5/2.0f+" Das Ergebnis ist vom Type float!"); int x='u';//implizite Typumwandlung von char zu integer System.out.println(x);//liefert 117 zurück Ausgabe: 5/2.0=2.5 Das Ergebnis ist vom Type double! 5/2.0f=2.5 Das Ergebnis ist vom Type float! 117

35 Java-Intensivkurs WS07/08 Folie 35 Typkonvertierung & Casting Ob explizit oder implizit hängt vom Zieltyp ab Jede Typkonvertierung entgegen der Pfeilrichtung muss explizit durchgeführt werden -Explizite Typkonvertierung wird als Casting bezeichnet -Einschränkende Typkonvertierungen Konvertierungen in Pfeilrichtung werden automatisch durchgeführt -Erweiternde Typkonvertierungen

36 Java-Intensivkurs WS07/08 Folie 36 Typkonvertierung & Casting //Method: Samples.typeConversion() int i=32; short s=4; char c='g'; double d=i;//erweiternde Typumwandlung float ff=(float)d;//einschränkende Typumwandlung byte b=(byte)c;//einschränkende c=(char)s;//einschränkende c=(char)b;//einschränkende

37 Java-Intensivkurs WS07/08 Folie 37 Erweiternde Typkonvertierungen Erweiternde Typkonvertierungen: byte zu short, int, long, float, oder double short zu int, long, float, oder double char zu int, long, float, oder double int zu long, float, oder double long zu float oder double float zu double

38 Java-Intensivkurs WS07/08 Folie 38 Einschränkende Typkonvertierungen Einschränkende Typkonvertierungen (erfordern Casting): short zu byte oder char char zu byte oder short int zu byte, short, oder char long zu byte, short, char, oder int float zu byte, short, char, int, oder long double zu byte, short, char, int, long, oder float

39 Java-Intensivkurs WS07/08 Folie 39 Autoboxing (boxing/unboxing) Autoboxing gibt es erst seit Version 5 Vor Version 5 waren die primitiven Datentypen und ihre korrespondierenden Wrapper-Klassen nicht zuweisungskompatible So war es z. B. nicht möglich eine primitive Integer- Variable einem Integer-Objekt oder umgekehrt zuzuweisen: Integer x=2; int y=new Integer(3);

40 Java-Intensivkurs WS07/08 Folie 40 Autoboxing Unter Boxing versteht man die automatische Umwandlung eines primitiven Wertes in ein Wrapper- Klassenobjekt Unboxing ist die Umkehrung von Boxing, sprich die automatische Umwandlung eines Wrapper- Klassenobjektes in einen primitiven Wert //boxing/unboxing Boolean b=false;//boxing float f=new Float(3.4.f);//unboxing

41 Java-Intensivkurs WS07/08 Folie 41 Autoboxing Da die Umwandlung automatisch vom Compiler erfolgt, spricht man von Autoboxing Primitive Datentypen und ihre korrespondierenden Wrapper-Klassen sind zuweisungskompatibel Vor Version 5 hätte man die Umwandlung manuelle durchführen müssen //Vor Version 5 manuelle Umwandlung Boolean b=new Boolean(false); Float f1=new Float(3.4.f); float f=f1.floatValue();

42 Java-Intensivkurs WS07/08 Folie 42 Arrays Geordnete Folge von Elementen des gleichen Datentyps Felder können enthalten: Elemente eines primitiven Datentyps Referenzen auf andere Arrays bzw. auf Objekte Definition eines Arrays erfolgt in 3 Schritten: Deklaration Konstruktion Initialisierung

43 Java-Intensivkurs WS07/08 Folie 43 Array-Deklaration Die Deklaration teilt dem Compiler den Namen des Arrays und den Typ seiner Elemente mit Bei Deklarationen ist es erlaubt den Arraynamen vor, nach oder zwischen den eckigen Klammerpaaren zu positionieren int [] list1; // Arraydeklaration int list2 [];//Arraydeklaration float [][] twoDimArray; // array of arrays of float float []twoDimArray2[]; // array of arrays of float int [] list3, list4 ; //Deklaration mehrerer Arrays int [] list7, list8, list9[], list10[] ; // Deklaration mehrerer Arrays. list9 und list10 sind zweidimensionale Arrays

44 Java-Intensivkurs WS07/08 Folie 44 Array-Konstruktion Bei der Konstruktion eines Arrays wird ein Arrayobjekt mit dem new-Operator instanziiert und die Länge des Arrays festgelegt: list1= new int[10]; // Arraykonstruktion

45 Java-Intensivkurs WS07/08 Folie 45 Intialisierung Immer, wenn ein Array definiert wird, werden seine Felder automatisch mit den Standardwerten ihres Datentyps initialisiert Standardwerte: -0 für numerische Datentypen -false für boolean -null für Referenztypen Will man während der Definition das Array mit anderen Werten initialisieren, so muss die Deklaration, Konstruktion und Initialisierung zu einem einzelnen Schritt kombiniert werden:

46 Java-Intensivkurs WS07/08 Folie 46 Initialisierung /* * Package: default * Class: Samples2.java * Method: arrays() */ //Explizite Array-Intialisierung int[]factorial = { 1, 1, 2, 6, 24, 120, 720, 5040 }; char ac[] = { 'n','o','t',' ','a',' ','S','t','r', 'i','n','g' }; float [][] _3X2Matrix={{1.0f,2.1f},{.5f,2.1f},{3.1f,.72f}};

47 Java-Intensivkurs WS07/08 Folie 47 Irreguläre Arrays Ein zweidimensionales Array: Array, dessen Felder Referenzen auf andere eindimensionale Arrays enthalten Es ist irreführend sich derartigen Arrays als eine Matrix vorzustellen In Java ist es nämlich erlaubt irreguläre mehrdimensionale zu definieren: Arrays, deren Zeilen unterschiedliche Längen aufweisen

48 Java-Intensivkurs WS07/08 Folie 48 Irreguläre Arrays int [][] irregularArray =new int[][]{{3,1},{-1},{5,2,0}}; irregularArray[0] // entspricht {3,1} (erste Zeile) irregularArray[1] // entspricht {-1} (zweite Zeile) irregularArray[1][0] // entspricht -1 (erstes Element in der zweiten Zeile) irregularArray[2] // entspricht {5,2,0} (dritte Zeile)

49 Java-Intensivkurs WS07/08 Folie 49 Zugriff auf Arrays Jedes Arrayelement hat einen numerischen Index Nummerierung fängt mit 0 an Der Versuch auf ein Element mit einem falschen Index zuzugreifen wirft eine sog. ArrayIndexOutOfBoundsException public static void wrongIndex(){ int [][] intArray =new int[3][3]; intArray=new int[][]{{3,1,3},{-1,0,1},{5,2}}; for(int i=0; i<3;i++) for (int j=0;j<3;j++) System.out.print(intArray[i][j]+" "); } Ausgabe: 3 1 3 -1 0 1 5 2 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at Samples.wrongIndex(HelloWorldApp.java:218) at SamplesApplication.main(HelloWorldApp.java:19)

50 Java-Intensivkurs WS07/08 Folie 50 Kontrollstrukturen if-else-Anweisung Der Fragezeichenoperator: (boolean_condition) ? expression1: expression2; int x=(y>0)?7:8; // wenn y>0 dann x=7 sonst x=8

51 Java-Intensivkurs WS07/08 Folie 51 If-else-Anweisung Asöldfk public static void nullStellen(){ /* * Für eine quadratische Funktion f(X)=aX^²+bX+c mit a!=0 * ist Xi eine Nullstelle falls gilt: f(Xi)=0 * Die Nullstellen einer quadratischen Funktion lassen * sich mithilfe der pq-Formel wie folgt leicht * ermitteln: */ //f(X)=2X^²+3X+1 float a=2f, b=3f, c=1; float p=b/a; float q=c/a;

52 Java-Intensivkurs WS07/08 Folie 52 If-else-Anweisung float d=(float)Math.pow(p/2, 2)-q;//d=(p/2)^²-q; if(d<0) System.out.println("Die Funktion f(X)="+a+"X^²+"+b+"X+"+c+" hat keine Nullstellen!"); else if(d==0){ float x0=-p/2; System.out.println("Die Funktion f(X)="+a+"X^²+"+b+"X+"+c+" hat nur eine Nullstelle: X0="+x0); } else { float x0=-p/2+(float)Math.sqrt(d); float x1=-p/2-(float)Math.sqrt(d); System.out.println("Die Funktion f(X)="+a+"X^²+"+b+"X+"+c+" hat zwei Nullstellen: X0="+x0+" und X1="+x1); }

53 Java-Intensivkurs WS07/08 Folie 53 Switch Eine if-else-Abfrage kann schnell unübersichtlich werden, wenn viele Alternativen berücksichtigt werden müssen Eine kompaktere Anweisungsform bietet das switch- Konstrukt switch(testvaribale){ case C1: statement_1; case C2: statement_2; …. case Cn: statement_n; default: default_statement; }

54 Java-Intensivkurs WS07/08 Folie 54 Switch Die Testvariable muss zuweisungskompatibel mit int sein  Testvariable ist vom Typ byte, char, short, oder int Die sog. case-Labels (OPEN_FILE, DELETE_FILE, …) müssen Konstanten sein final int OPEN_FILE=0;final int DELETE_FILE=1; final int SAVE_FILE=2; switch(command){ //command wird Testvariable genannt case OPEN_FILE: System.out.println("opening file...");break; case DELETE_FILE: System.out.println("deleting file...");break; case SAVE_FILE: System.out.println("saving file...");break; default: System.out.println("invalid command !!!!!"); }

55 Java-Intensivkurs WS07/08 Folie 55 Schleifen while(boolean_condition) repeated_statement_or_block public static void whileBinary(int number) { String binary=""; int number=123 ; int div=number ; int rest; while(div>0 ){ rest=div%2; div=div/2; binary=rest+binary; } System.out.println("Die Binärdarstellung von "+number+" ist "+binary); } whileBinary(123 ); Ausgabe: Die Binärdarstellung von 123 ist 1111011

56 Java-Intensivkurs WS07/08 Folie 56 while Beispiele für endlose while-Schleifen public static void endlessWhileLoop() { byte b=0; while(b<3); b++;//this statement will never execute byte y=0; while(true) System.out.println((++y));//overflow after 128 iterations byte x=1; byte y=10; while(Math.min(x,y)<5);// endless loop: ++x; }

57 Java-Intensivkurs WS07/08 Folie 57 do-while do repeated_statement_or_block while (boolean_condition); public static void doWhileSumOfDigits(int number) { //Berechnung der Quersumme einer positiven Zahl: int sumOfDigits = 0; do { sumOfDigits += number % 10;// sumOfDigits=sumOfDigits+number%10 number /= 10;// number=number/10 } while (number != 0) System.out.println(sumOfDigits);// 25 } doWhileSumOfDigits(283746); Ausgabe: 30

58 Java-Intensivkurs WS07/08 Folie 58 for-Schleife for(statement; boolean_condition;expression) statement_block public static void fibbonacci(int n) { int fib1 = 0, fib2 = 1; int fib = fib1 + fib2; for (int i = 3; i <= n; i++) { fib1 = fib2; fib2 = fib; fib = fib1 + fib2; } System.out.println(fib); } Samples.fibbonacci(11); Ausgabe: 89

59 Java-Intensivkurs WS07/08 Folie 59 for-Schleife public static void strangeForLoop() { // strange loop for(System.out.println("Ich werde ein einziges Mal zu Beginn ausgeführt!"); i<5;System.out.println("Ich werde am Ende eines Schleifendurchlaufs ausgeführt! ")) { System.out.println("Ich werde zum "+(i++)+". Mal ausgeführt!");} } //Die beiden Schleifen sind äquivalent for(System.out.println("Ich werde ein einziges Mal zu Beginn ausgeführt!"); i<5;) {System.out.println("Ich werde zum "+(i++)+". Mal ausgeführt!"); System.out.println("Ich werde am Ende eines Schleifendurchlaufs ausgeführt! ") }

60 Java-Intensivkurs WS07/08 Folie 60 for-each-Schleife Erst seit Version 5 Sie bietet eine komfortable Möglichkeit über Arrays und Kollektionen (Collections) zu iterieren: public static void forEachLoop() { double [] trigonometry=new double[]{Math.PI,Math.sin(Math.PI/2),Math.cos(Math.PI/2)}; for (double d : trigonometry) //for each element d in System.out.println(d); the trigonometry array } //äquivalent zu: for(int i=0;i<trigonometry.length;i++) System.out.println(trigonometry[i]);

61 Java-Intensivkurs WS07/08 Folie 61 break und continue In vielen Fällen ist das Beenden eines Schleifendurchlaufes bzw. das Verlassen eines Schleifenrumpfes erforderlich continue und break break: Abarbeitung der Schleife sofort beendet Schleife wird verlassen Unabhängig davon ob das Abbruchkriterium erfüllt ist oder nicht Anwendungsbeispiel: Textsuche-Programm

62 Java-Intensivkurs WS07/08 Folie 62 break public static void breakSample(){ /* Erstelle eine zufällig generierte * Liste aus Ganzzahlen */ int [] numbers= getRandomIntegerList();//Siehe 6.4 break und continue /* Ermittle die Summe aller Zahlen, die vor der ersten * negativen Zahl in der Liste vorkommen. * Implementierung mit einer for-each-Schleife */ int sum=0; for (int number : numbers) { if(number<0) break; sum+=number; } System.out.println("Die Summe beträgt: "+sum); }

63 Java-Intensivkurs WS07/08 Folie 63 continue break: Schleife wird verlassen continue: aktuelle Schleifendurchlauf wird unterbrochen Nach der Ausführung von continue wird die Schleifenbedingung erneut ausgewertet und ggf. wird mit dem nächsten Schleifendurchlauf fortgefahren.

64 Java-Intensivkurs WS07/08 Folie 64 continue Beispiel Berechne die Wurzel jeder positiven Zahl in einer Liste L und überspringe dabei die negativen Zahlen public static void continueSample(){ int [] numbers= getRandomIntegerList(); /* Berechne die Wurzel jeder positiven Zahl in der Liste und * überspringe dabei die negativen Zahlen * Implementierung mit einer for-each-Schleife */ for (int number : numbers) { if(number<0){ System.out.println(number+" hat keine Wurzel!"); continue; } double sqrt=Math.sqrt(number); System.out.println("Wurzel von "+number+"= "+sqrt); }}

65 Java-Intensivkurs WS07/08 Folie 65 OOP Klasse: Abstrakter Datentyp, der die Eigenschaften, das Verhalten & die Struktur einer Menge gleichartiger Objekte der realen Welt definiert Eigenschaften werden Attribute genannt Das Verhalten legen sog. Methoden fest Objekt =Instanz= konkrete Ausprägung einer Klasse Objekte haben einen Zustand, Verhalten und Identität Der Zustand eines Objektes ist durch die Belegung seiner Attribute definiert Objekte haben Verhalten (führen Aktionen durch) Objekte haben Namen Beispiel: Klasse Mensch

66 Java-Intensivkurs WS07/08 Folie 66 Attribute einer Klasse (attributes) public class Bankkonto {//Klassendeklaration //Beginn des Klassenrumpfes //Attribute legen den Zustand eines Objektes fest public int kontoNummer; //Felddeklaration public float kontoStand;//in € // Felddeklaration public String inhaber; //Felddeklaration //Ende des Klassenrumpfes }

67 Java-Intensivkurs WS07/08 Folie 67 Methoden einer Klasse (methods) public class Bankkonto {//Klassendeklaration public void einzahlen(float betrag){ kontoStand+=betrag; } public void abheben(float betrag){ kontoStand-=betrag; } public float getKontoStand(){ return kontoStand; }

68 Java-Intensivkurs WS07/08 Folie 68 Methoden und Konstruktoren (constructors) Methoden haben Signatur (Methodenkopf): -Zugriffsmodifikator (public, private, protected) -Rückgabetyp (void, int,..) -Namen -Parameterliste Methodenrumpf public void einzahlen(float betrag) //Methodenkopf (Signatur) { //Methodenrumpf }

69 Java-Intensivkurs WS07/08 Folie 69 Konstruktoren Spezielle Methoden Haben keinen Rückgabetyp Heißen genau so wie ihre zugehörigen Klassen Werden in der Regel verwendet, um die Attribute eines Objektes mit Anfangswerten zu initialisieren //Konstruktor public Bankkonto(){ kontoNummer=0; inhaber="Unbekannt"; kontoStand=0.f; }

70 Java-Intensivkurs WS07/08 Folie 70 Konstruktoren Ein Konstruktor wird immer dann aufgerufen, wenn ein Objekt mit dem new-Operator instanziiert wird: Eine Klasse muss keine Konstruktoren definieren In diesem Fall fügt der Compiler den parameterlosen Default-Konstruktor in die Klasse ein Bankkonto alexKonto=new Bankkonto();//Objekt (Instanz)

71 Java-Intensivkurs WS07/08 Folie 71 Default-Konstruktor Default-Konstruktor: Heißt genau so wie seine Klasse Hat keine Parameter und enthält keine Anweisungen //Der Defaultkonstruktor public KlassenName(){ }

72 Java-Intensivkurs WS07/08 Folie 72 Überladen von Methoden (overloading) Zwei Parameterlisten sind unterschiedlich  Sie haben unterschiedliche Anzahl an Parametern Wenn sie dieselbe Anzahl an Parametern haben, jedoch unterschiedliche Reihenfolge der Parametertypen aMethod(float dx, float dy) //2 Parameter aMethod()//keine Parameter aMethod(float dx) //1 Parameter aMethod(float dx, int dy) aMethod(int dx, float dy) aMethod(float dx, float dy) aMethod(int dx, int dy)

73 Java-Intensivkurs WS07/08 Folie 73 Überladen von Methoden Die Bezeichnung der Parameter spielt in beiden Fällen keine Rolle Demnach sind die folgenden Parameterlisten absolut identisch: aMethod(float deltaX, int deltaY) aMethod(float dx, int dy)

74 Java-Intensivkurs WS07/08 Folie 74 Überladen von Methoden Eine Methode ist durch ihren Namen und die exakte Folge ihrer Eingabeparametertypen eindeutig bestimmt Die Wiederverwendung desselben Methodennamens mit einer anderen Parameterliste und evtl. einem anderen Rückgabetyp wird als Überladung bezeichnet Die beiden Methoden müssen unterschiedliche Parameterlisten haben

75 Java-Intensivkurs WS07/08 Folie 75 Überladen von Methoden Alle folgenden Methoden stellen Überladungen der Methode translate dar: public void translate(float dx, float dy) public void translate(int dx, int dy) public void translate(float dx, int dy) public void translate(int dx, float dy) public void translate(int dxy) public void translate(float dxy) public void translate()

76 Java-Intensivkurs WS07/08 Folie 76 Überladen von Methoden Keine Überladung: Auch keine Überladung: Bemerkung: Konstruktoren können auch überladen werden public void translate(float distance) public void translate(float abstand) public void translate(int deltX, float deltaY) public void translate(int dx, float dy) public float translate(int dx, float dy)

77 Java-Intensivkurs WS07/08 Folie 77 Vererbung (inheritance) Ein wesentliches Konzept in der OOP ist die Vererbung Bietet die Möglichkeit die nicht privaten Attribute und Methoden einer existierenden Klasse A auf eine neue Klasse B zu übertragen B erbt die Attribute und Methoden der Klasse A A ist eine Oberklasse von B B ist eine Unterklasse von A Das Konzept unterstützt die Wiederverwendung von bereits existierendem Code

78 Java-Intensivkurs WS07/08 Folie 78 Vererbung Girokonto als Unterklasse der Klasse Bankkonto: class Girokonto extends Bankkonto{ float dispositionsLimit; public void dauerAuftragEinrichten(){ /* * Code für die Einrichtung eines * Dauerauftrags */ }

79 Java-Intensivkurs WS07/08 Folie 79 Vererbung Girokonto Erbt alle Attribute und Methoden von Bankkonto Fügt eigene Attribute und Methoden hinzu: -Kreditrahmen und dauerAuftragEinrichten() Was kann eine Klasse alles von ihrer Vaterklasse erben? Nur die nicht privaten Attribute und Methoden Konstruktoren werden nicht vererbt

80 Java-Intensivkurs WS07/08 Folie 80 Überschreibung von Methoden (overriding) Aus der Oberklasse geerbten Methoden dürfen in der Unterklasse neu definiert werden Wird eine von einer Oberklasse geerbten Methode in der Unterklasse neu definiert ohne ihren Namen und Parameterliste zu verändern, so spricht man von einer Überschreibung der Methode Die überschreibende Methode ersetzt ihre überschriebene Methode in der Unterklasse komplett

81 Java-Intensivkurs WS07/08 Folie 81 Überschreibung von Methoden Die Parameterliste der überschreibenden Methode muss mit der Parameterliste der überschriebenen Methode bis auf die Parameternamen identisch sein

82 Java-Intensivkurs WS07/08 Folie 82 Überschreibung von Methoden public class Point { public float x1; public float y1; //Verschiebung public void translate(float dx, float dy){ this.x1+=dx; this.y1+=dy; } //Gleichmäßige Verschiebung public void translate(float distance){ x1+=distance; y1+=distance; }

83 Java-Intensivkurs WS07/08 Folie 83 Überschreibung von Methoden class Line extends Point{ //Line ist die Unterklasse der Oberklasse Point float x2; float y2; /* *Überschreibung der Methode translate(float dx, float dy) *der Oberklasse */ @Override public void translate(float dx, float dy){ //Wiederverwendung des Codes der Oberklasse super.translate(dx, dy); x2+=dx; y2+=dy; }

84 Java-Intensivkurs WS07/08 Folie 84 Überschreibung von Methoden class Line extends Point{ float x2; float y2; // Überschreibung der Methode translate(float distance) @Override public void translate(float distance){ //Überschreiben ohne Wiederverwendung //des Codes der Oberklasse x1+=distance; y1+=distance; x2+=distance; y2+=distance; }

85 Java-Intensivkurs WS07/08 Folie 85 Polymorphismus (polymorphism) Unter Polymorphismus versteht man die Fähigkeit einer Objektreferenz, Objekte seiner Unterklasse zu referenzieren und sich abhängig davon zu verhalten In Java ist es nämlich erlaubt einer Oberklasssenobjektreferenz ein Unterklassenobjekt O zuzuweisen Verhält sich O in diesem Fall wie ein Objekt der Ober- oder der Unterklasse?

86 Java-Intensivkurs WS07/08 Folie 86 Polymorphismus (polymorphism) Wird einer Oberklassenobjektreferenz R ein Objekt O einer Unterklassen U zugewiesen, so verhält O dementsprechend wie alle anderen Objekte von U

87 Java-Intensivkurs WS07/08 Folie 87 Polymorphismus /* * Package: default * Class: Polymorphism.java * Method: */ class Polygon {//Oberklasse /* * Gibt den Flächeninhalt des Polygons zurück. */ public void getSurface(){ System.out.println("The surface of this polygon is undefined."); }

88 Java-Intensivkurs WS07/08 Folie 88 Polymorphismus class Rectangle extends Polygon{//Unterklasse /** * Ein Rechteck */ public float width; public float height; public Rectangle(float width, float height){ this.width=width; this.height=height; } public void getSurface(){ System.out.println("The surface of this rectangle is: "+this.width*height); }

89 Java-Intensivkurs WS07/08 Folie 89 Polymorphismus class Triangle extends Polygon{ float base; float height; public Triangle(float base, float height){ this.base=base; this.height=height; } public void getSurface(){ System.out.println("The surface of this triangle is: "+.5f*base*height); }

90 Java-Intensivkurs WS07/08 Folie 90 Polymorphismus //polygon ist eine Oberklassenobjektreferenz Polygon polygon=new Polygon(); polygon.getSurface(); polygon =new Rectangle(2,3); polygon.getSurface(); polygon =new Triangle(3,2); polygon.getSurface(); Ausgabe: The surface of this polygon is undefined. The surface of this rectangle is: 6.0 The surface of this triangle is: 3.0

91 Java-Intensivkurs WS07/08 Folie 91 Polymorphismus Umgekehrt ist in Java und vielen anderen Programmiersprachen nicht erlaubt einer Referenz einer Unterklasse ein Objekt seiner Oberklasse zuzuweisen Triangle triangle=new Polygon();//Kompilierfehler Rectangle rectangle=new Polygon();//Kompilierfehler Rectangle rectangle=new Triangle();//Kompilierfehler

92 Java-Intensivkurs WS07/08 Folie 92 Referenzen in Java Zwei Kategorien von Datentypen: Primitive Datentypen Referenztypen (Arrays, Klassen und Interfaces) Es gibt einen wesentlichen Unterschied zwischen einer primitiven Variablen und einer Referenzvariablen

93 Java-Intensivkurs WS07/08 Folie 93 Referenzen in Java public class Student { public String name;//Referenzvariable (Objektreferenz) public Date gebDatum;// Referenzvariable (Objektreferenz) public String studiengang;// Referenzvariable (Objektreferenz) public int semesteranzahl; //primitive Variable }