Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

Ähnliche Präsentationen


Präsentation zum Thema: "Prof. Dr. Max Mühlhäuser Dr. Guido Rößling"—  Präsentation transkript:

1 Prof. Dr. Max Mühlhäuser Dr. Guido Rößling
Grundlagen der Informatik I Thema 11: Von Scheme zu Java Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

2 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

3 Von Scheme zu Java Mit diesem Foliensatz werden Ihnen einige der wesentlichen Elemente von Java präsentiert „Fortgeschrittene“ Themen kommen später Objektorientierung, Vererbung, abstrakte Klassen, Interfaces Schrittweise Verfeinerung Java Interpreter, Compiler, Virtuelle Maschine, Laufzeitumgebung Das Ziel dieses Foliensatzes ist es, Java anhand der Parallelen zu Scheme vorzustellen

4 Allgemeine Unterschiede
Scheme und Java folgen zwei unterschiedlichen Programmierstilen („Paradigmen“) Scheme ist eine funktionale Programmiersprache Im Zentrum stehen Funktionen und die Anwendung von Funktionen Problemlösung anhand von Dekomposition und Komposition “Um das Problem X zu lösen, zerlege es in die kleineren Probleme Y und Z. Definiere, wie die kleinsten (atomaren) Probleme zu lösen sind und wie Y und Z zu X zusammengesetzt werden müssen.“ Weiter von der Maschinen-Ebene entfernt Erzeugt häufig eine gute modulare Struktur im Code Zerteile den Code in der Art, wie das Problem zerlegt wird

5 Abstand vom Rechner im funktionalen Stil
(define (fold f n) (lambda (x) (if (empty? x) n (f (first x) ((fold f n) (rest x)))))) (define sumlist (fold + 0)) (define multlist (fold * 1)) (sumlist ‘(3 4 5)) 12 (multlist ‘(3 4 5))  60 Erwähnt noch nicht einmal die Liste! Abstraktion von den Details der Ausführung

6 Allgemeine Unterschiede
Java ist eine objektorientierte Sprache Objekte sollen reale „Dinge“ oder Sachverhalte nachbilden Details dazu folgen ab T12 Größere Probleme werden durch Delegation von Aufgaben an andere Objekte gelöst Die zugrundeliegende Notation ist imperativ: Denken in Rechenschritten “Um das Problem X zu lösen, führe die folgende Reihenfolge von Rechenschritten aus…” Nah am Rechner orientiert Es wird nur eine Nachricht mit einer Dienstanweisung auf einmal geschickt Wenn mehrere Objekte vorhanden sind, können sie Botschaften aneinander senden Teilaufgaben an bekannte Objekte delegieren

7 Ein paar Worte zur Java-Lexikalik
Spezielle Symbole: ; { } . ( ) { } begrenzen Programmblöcke: die Definition eines Objekttyps (Klassenrumpf), die Definition einer Methode (Methodenrumpf) Sequenzen von Anweisungen, z.B. in den Abzweigungen einer Konditionalanweisung Ausdrücke und Anweisungen inklusive Operationsaufrufe (Dienstanweisungen) werden innerhalb eines Blocks mit “;“ getrennt . trennt den Empfänger vom Operationsnamen ( ) begrenzen die Liste der Parameter einer Operation / eines Operationsaufrufs (inc c2 5) c2.inc(5);

8 Ein paar Worte zur Java-Lexikalik
Name (Identifier): c1, Counter, inc, dec In Namen dürfen nur bestimmte Sonderzeichen wie „_“, „$“ auftreten, aber beispielsweise kein „-“ Schlüsselwörter: new, void, … Werden benutzt, um die primitiven Anweisungen eines Programms zu strukturieren. Nicht als Name erlaubt Groß-/Kleinschreibung wird unterschieden! Void wird als ein Name und nicht als Schlüsselwort interpretiert

9 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

10 Struktur eines Java-Programms
Ein Java-Programm kann aus beliebig vielen Klassen bestehen, von denen mindestens eine die main-Operation besitzen muss (Hauptprogrammklasse). Aufgaben von main: Objekterzeugung  der Aufbau einer anfangs minimalen Welt Siehe Foliensatz T12 Aufruf der ersten Operation Sollte in der Regel keinen weitergehenden Kontrollfluss des Java-Programms enthalten Der Kontrollfluss wird innerhalb der Objektoperationen realisiert Nicht vergessen! Berechnung als Kooperation von vielen Objekten, wobei jedes Objekt nur eine kleine Teilaufgabe erledigt! Wird durchJava-Interpreter gestartet und ausgeführt args ist eine Tabelle mit Zeichenketten und wird benutzt um dem Programm beim Start Parameter zu übergeben Eingabeparameter stehen zunächst nur als Zeichenketten zur Verfügung Möchte man eine Zahl übergeben, so muss die entsprechende Zeichenkette (programmintern) in eine Zahl (z.B. vom Typ int) konvertiert werden  mehr dazu später Statt args kann ein beliebiger Name benutzt werden, die Verwendung von args ist aber üblich

11 Java- Bytecode-Interpreter
Wie alles anfängt… Die „ausgezeichnete“ Methode namens main wird aufgerufen, wenn ein Java-Programm ausgeführt wird… Dazu muss main in einer Klasse (Schlüsselwort class) stehen Mehr dazu folgt in T12 public class CounterTest { // ... public static void main(String[] args) { CounterConsumer cc = new CounterConsumer(); cc.doSomethingWithCounters(); } CounterTest.java Java- Compiler javac CounterTest.java java CounterTest Java- Bytecode-Interpreter

12 Java-Übersetzung Datei.java Bsp1.class class Bsp1 {...} Java Compiler
Eingabe: Java-Quelltextdatei, Datei.java, die eine oder mehrere Klassendefinitionen enthält Eine derartige Datei nennt man eine Übersetzungseinheit Ausgabe: pro Klasse Bsp wird genau eine Datei Bsp.class erzeugt, die das Bytecode-Format der Klasse enthält Bsp1.class class Bsp1 {...} class Bsp2 {...} class Bsp3 {...} Datei.java Bsp2.class Java Compiler Bsp3.class

13 Berechnungen durchführen
Die Aufgabe wird in Dienstanweisungen zerlegt Formuliert als Nachrichten (Operationsaufruf) an Objekte Jede Nachricht enthält: Name des Empfängerobjektes: c1 im Beispiel Namen des Dienstes (der Operation), der (die) vom Empfänger ausgeführt werden soll inc(), dec(), ... Die Operation muss in der Schnittstelle des Empfängers enthalten sein Es wird nur eine Nachricht mit einer Dienstanweisung auf einmal geschickt Wenn mehrere Objekte vorhanden sind, können sie Botschaften aneinander senden Teilaufgaben an bekannte Objekte delegieren

14 Hilfssystem: ACM JTF Bibliothek
Wir nutzen eine Hilfsbibliothek zur Programmierung Diese erlaubt es uns, … Programme mit grafischer Oberfläche zu bauen – ab sofort; Nutzerinteraktion (Werteingaben, …) auch grafisch zu tätigen; Viele Beispiele zu nutzen (siehe Webseite); Den Programmstart mittels „main“ zu vereinfachen Die Bibliothek ist die „ACM JTF“ Bibliothek ACM: Association for Computing Machinery, die größte Dachorganisation für Informatiker und verwandte Berufe weltweit Siehe ein Beitritt (19$ pro Jahr!) lohnt sich! JTF: Java Task Force; 10 erfahrene Informatik-Dozenten ACM JTF: Die von der JTF der ACM entwickelte Bibliothek Verlinkt als „acm.jar“ auf der Webseite (etwa 400 kB)

15 Genereller Aufbau bei Nutzung von ACM JTF
Ihr Programm erbt (T12) von einer dieser Klassen: acm.program.ConsoleProgram – für eine Eingabekonsole a la DOS acm.program.DialogProgram – für dialogbasierte Ein-/Ausgabe acm.program.GraphicsProgram – für grafikbasierte Ausgabe In der main-Methode erfolgen nur zwei Operationen: Erzeugen eines neuen Objekts (T12) mit „new MyProgram()“ Aufrufen der Methode start(String[] args) Damit wird das Aufgabefenster angelegt etc. Dann wird die von Ihnen zu schreibende Methode run() aufgerufen Diese Methode sollte dann alle weiteren Aktionen veranlassen

16 Interessante Methoden in ConsoleProgram
void print(X value) Gibt Wert value aus; X steht dabei für einen beliebigen Typ void println(X value) Gibt Wert value aus und fügt einen Zeilenvorschub an void println() Gibt einen Zeilenvorschub aus void clear() Löscht das Konsolenfenster void showErrorMessage(String message) Zeigt eine Fehlermeldung (rot) an String readLine(String p) / int readInt(String p) / double readDouble(String p) Zeigt den Text p an und liest eine Textzeile / int / double ein

17 Beispielprogramm: Hello World - Console
import acm.program.ConsoleProgram; // Binde "ConsoleProgram" ein public class HelloConsole extends ConsoleProgram { public void run() { println("hello, world"); } /* Standard Java entry point */ /* This method can be eliminated in most Java environments */ public static void main(String[] args) { new HelloConsole().start(); // startet Console, ruft "run" auf Ausgabefenster:

18 Interaktivität mit DialogProgram
Die Methoden sind identisch zu ConsoleProgram Für Ein- und Ausgabe werden nun aber Dialoge genutzt Pro Ausgabe oder Eingabe erscheint ein entsprechendes Fenster Starten Sie dazu das Programm „Add2Dialog“

19 Beispielprogramm: Hello World - Dialog
import acm.program.DialogProgram; // Binde "DialogProgram" ein public class HelloDialog extends DialogProgram { public void run() { println("hello, world"); } /* Standard Java entry point */ /* This method can be eliminated in most Java environments */ public static void main(String[] args) { new HelloDialog().start(); // startet Dialog, ruft "run" auf Ausgabefenster:

20 Beispielprogramm: Hello World - Grafik
import acm.graphics.GLabel; // Binde GLabel (anzeigbarer Text) ein import acm.program.GraphicsProgram; // Binde "GraphicsProgram" ein public class HelloGraphics extends GraphicsProgram { public void run() { GLabel label = new GLabel("hello, world"); // neuer Text label.setFont("SansSerif-100"); // Font: ohne Serifen double x = (getWidth() - label.getWidth()) / 2; // mittig double y = (getHeight() + label.getAscent()) / 2; // mittig add(label, x, y); // Text hinzufügen } /* Standard Java entry point */ /* This method can be eliminated in most Java environments */ public static void main(String[] args) { new HelloGraphics().start(); //startet Graphics,ruft "run" auf } Ausgabefenster (verkleinert):

21 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

22 Variablen in Java Daten werden Java in der Regel in Variablen gespeichert Insbesondere zur Zuweisung des Ergebnisses von Rechenschritten Von Scheme kennen Sie Variablen als gebundene Namen: In Java erfolgen Zuweisungen mittels "=": ;; provide initial value for counter (define counter-value 0) ;; increment the counter (set! counter-value (succ counter-value)) // provide initial value for counter counterValue = 0; // increment the counter counterValue = counterValue + 1;

23 Erste Analyse der Unterschiede
;; provide initial value for counter (define counter-value 0) ;; increment the counter (set! counter-value (+ counter-value 1)) // provide initial value for counter int counterValue = 0; // increment the counter counterValue = counterValue + 1; Kommentare mit „//“ statt „;“ Der Variablendeklaration wird ein Typ vorangestellt (int) Variablennamen ohne „-“, dafür Großschreibung im Wort „(set! Variable Ausdruck)“ wird zu „Variable = Ausdruck“ Statt Klammerung enden Anweisungen mit „;“ Statt Präfixnotation (operator param1 … paramn) wird Infixnotation genutzt Aus ( ) wird also

24 Arithmetische Operationen
Java unterstützt alle wesentlichen arithmetischen Operationen Beachten Sie, dass die Infixnotation genutzt wird! Im Folgenden sei a eine int-Variable (Ganzzahl) mit Wert 15 Die Tabelle ist nicht vollständig, mehr in einigen Folien Operation In Java Beispiel Ergebnis Addition + 12 Subtraktion - a – 2 13 Multiplikation * a * 4 60 Division / a / 5 3 Divisionsrest % a % 4 3 (da 15=3*4+3) Negation -a -15

25 Variablentyp … Jede Variable hat einen Typ, der festlegt…
welche Art von Daten in der Variablen gespeichert werden können. wie viele Speicherzellen benötigt werden. int  4 Zellen long  8 Zellen welche Operationen auf dem (durch diese Variable bezeichneten) Objekt aufgerufen werden können. Der Typ wird der Variablen bei Deklaration vorangestellt: int counter;

26 Deklarationen in Java Führen neue Namen ein, oft zusammen mit einem Wert (define …) in Scheme In Java assoziieren Deklarationen auch einen Typ mit dem Namen: Der Typ legt fest, wie die Namen im Programm benutzt werden dürfen  statisch typisierte Sprachen (später mehr)

27 Variablentyp counter darf nur ganz-zahlige Werte annehmen int counter;
counter = "hello"; int counter; 4 Speicherzellen counter Nur für ganze Zahlen definierte Operationen dürfen verwendet werden. counter++; counter.move();

28 Variablen: Zuweisung & Ausdrücke
Ausdruck size = size delta; 3 4 = + 1 2 size delta Kontrollfluss Auswertungsreihenfolge Die linke Seite der Zuweisung muss einen Speicherplatz bezeichnen (in Scheme: ein Name in der Umgebung). Die rechte Seite muss ein Ausdruck sein. Ein Ausdruck muss einen Wert ergeben.

29 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

30 Primitive Datentypen Java bietet mehrere primitive Datentypen:
Wahr/Falsch Werte: boolean mit Werten true, false Ganze Zahlen: byte, short, int, long, z.B. 3 Fließkommazahlen: float, double, z.B. 0.84 Buchstaben: char, z.B. 'A' Kein primitiver Datentyp, aber bereits vordefiniert: Zeichenketten: String, z.B. "Hello World"

31 Primitive Datentypen Warum gibt es mehrere Typen für den gleichen Zweck? Was ist der Unterschied zwischen short und int? Verschiedene Typen mit unterschiedlichen Wertebereichen Je größer der Bereich, desto mehr Speicher wird gebraucht Typ Minimalwert Maximalwert Speicherplatz byte -128 127 1 Byte (8 Bit) short 32 767 2 Bytes (16 Bit) int 4 Bytes (32 Bit) long -263 263-1 8 Bytes (64 Bit) float 1,402·10-45 3,402·1038 double 4,94·10-324 1,797·10308 boolean false true 1 Bit Scheme bewahrt den Nutzer vor diesen maschinenabhängigen Details.  einfacher zu nutzen, weniger fehleranfällig, aber höhere Laufzeit.

32 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

33 Zusammengesetzte Ausdrücke
Beispiele double a; int i; char c; boolean b; a = ; // a == i = 4 – 9; // i == -5 c = 'T'; // c == 'T' i = i + 1; // i == == -4 a = i * 2 + 3; // a == -4 * == == -5 a = i * (2 + 3); // a == -5 * (2 + 3) == -5 *5 == -25 b = true; // b == true b = i > 0; // - 25 > 0 == false  b == false

34 Boolesche Ausdrücke Vergleiche: Logisches Nicht (a):
== für Gleichheit, != für Ungleichheit Vorsicht: = alleine steht für die Zuweisung <, <=, >=, > wie üblich, aber in Infixnotation Logisches Nicht (a): true wenn a false ist, sonst false Notation in Java: !a Notation in Scheme: (not a) a !a false true

35 Zusammengesetzte boolesche Ausdrücke
Logische Operatoren ermöglichen die Zusammensetzung von einzelnen booleschen Werten Aus der Logik bekannte Operatoren: logisches Und (AB): ergibt nur true, wenn A und B true sind (Java: A && B; Scheme: (and A B)) logisches Oder (AB): ergibt nur false, wenn A und B false sind (Java: A || B; Scheme: (or A B)) A B A && B A || B false true analog zu and, or in Scheme…

36 Zusammengesetzte boolesche Ausdrücke
Beispiele boolean a, b; int i; char c; c = 'A'; i = 2; a = false; b = c == 'A'; // b ist jetzt true b = a && b; // b ist jetzt false b = !b; // b ist jetzt true b = i > 0 && 3 / i == 1; // Da i == 2: b == 2 > 0 and 3 / // Mit 3/2 == 1 (Ganzzahldivision) //  b ist jetzt true

37 Nicht-strikte Operatoren
Die logischen Operatoren a && b (logisches und) a || b (logisches oder) werten den zweiten Operanden nur aus, wenn wirklich benötigt Auswertungsabkürzung (nicht-strikte Auswertung) Beispiel: if (a != 0 && b / a > 1) Für a == 0 würde b/a einen Fehler erzeugen Aber false && x ist immer false  x wird nicht ausgewertet

38 Bit-Operationen a & b (bitweises Und) a | b (bitweises Oder) a ^ b (bitweises Exklusiv-Oder, nicht gleich) ~a (bitweise Negation) a << b (verschiebt a um b Stellen nach links, entspricht Multiplikation mit 2b) a >> b (verschiebt a um b Stellen nach rechts, entspricht Division mit 2b) a >>> b (verschiebt a um b Stellen nach rechts und behält das Vorzeichen bei) Diese Operatoren sind für die Typen byte, short, int, long und char definiert.

39 Bit-Operationen Beispiele
short i = 5  i = short j = 3  j = i & j =  i & j == 1 i | j =  i | j == 7 i << 1 =  i << 1 == 10 i >> 1 =  i >> 1 == 2 ~i =  ~i == -6 Warum ist ~i == -6? Weil short Zahlen mit Vorzeichen [signed], sind, wird beim Umkippen des signifikantesten Bits das Vorzeichen von negativ zu positiv. Es gibt fünf Inkrementierungen, bis -1 (nur Einser) erreicht ist.

40 Zuweisungsoperator In Java ist die Zuweisung ein Operator
Sie ist ein Ausdruck und keine Anweisung Eine Zuweisung hat einen Rückgabewert, neben ihrem essentiellen "Nebeneffekt", den Wert des linken Operanden zu verändern. a = b = c = 42; Ausdruck Ausdruck Ausdruck Ausdruck

41 Zusammengesetzter Zuweisungsoperator
Variablenwerte werden sehr oft etwa wie folgt geändert: i = i + STEP; Die Zielvariable tritt an der ersten Stelle des Ausdrucks auf Hierfür gibt es eine Kurzschreibweise: i += STEP; Entsprechende Varianten gibt es für fast alle Operatoren: +=, -=, *=, /=, |=, &=, ^=, %=, <<=, >>=, >>>= Nützlich, wenn das Ziel komplex ist oder nur einmal ausgewertet werden soll, z.B. a[i++]+=2; // Kein guter Stil! Bei vielen Programmierern als „Abkürzung“ sehr beliebt

42 Unäre Operatoren Haben nur einen Operanden
Negation: !a (Scheme: (not a)) Minus als Zeichen (nicht als binärer Operator): -a Inkrement/Dekrement Operatoren Anders als typische unäre Operatoren haben sie einen Nebeneffekt ++a, a++, --a, a-- Präfix und Postfix Versionen haben unterschiedliche Effekte Beispiele a = 4; a++; // entspricht: a = a + 1;  a==5 b = a++; // entspricht: b = a; a = a + 1;  a==6, b==5 b = ++a; // entspricht: a = a + 1; b = a;  a==7, b==7 b = a--; // entspricht: b = a; a = a – 1;  a==6, b==7

43 Operator-Prioritäten
Viele arithmetische Ausdrücke können ohne Klammern geschrieben werden Die Auswertungsregeln entsprechen denen der Schulmathematik a + b > 27 && b + c < 35 || a < 3 bedeutet ((((a + b) > 27) && ((b + c) < 35)) || (a < 3)) In Scheme: (or (and (> (+ a b) 27) (< (+ b c) 35)) (< a 3))

44 Operator-Priorität und Assoziativität
In einem Ausdruck mit mehreren Operatoren werden Operatoren mit höherer Priorität vor denen mit niedriger Priorität angewendet. In Scheme trat dies durch Präfixnotation und Klammerung nicht auf. Operator Assoziativität: In einem Ausdruck mit mehr als einem Operator gleicher Priorität ... Der Operator ganz links wird zuerst angewendet, wenn der Operator eine links-nach-rechts Assoziativität hat. Der Operator ganz rechts wird zuerst angewendet, wenn der Operator eine rechts-nach-links Assoziativität hat Die Prioritäts- und Assoziativitätsregeln in Java sind im Wesentlichen die „üblichen“, wie man sie aus der Algebra und der Logik kennt. Die Verwendung von Klammern, um die Prioritätsregeln zu überschreiben, ist ebenfalls aus der Algebra bekannt.

45 Operator Priorität und Assoziativität
Unäre Operatoren ++, --, -, ~, ! rechts Multiplikation / Division / Rest *, /, % links Addition/ Subtraktion +, - Shift <<, >> Vergleich <, >, <=, >= Gleichheit ==, != bitweises und & bitweises xor ^ bitweises oder | logisches und && logisches oder || Bedingungsoperator ? : Zuweisung =, +=, -=, *=, … In Scheme wegen Präfix Notation nicht notwendig

46 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

47 Aufrufen von Funktionen
In Scheme werden oft Funktionen angewendet Dazu wurde einfach der Funktionsname, gefolgt von allen Parametern, in Klammern gesetzt In Java erfolgt der Aufruf durch Angabe des Namens, gefolgt von den Parametern in Klammern (und getrennt mit Komma): Das Semikolon ist nur nötig, wenn der Befehl hier endet, „average“ also nicht in weitere Rechnungen eingeht In der Regel wird das Ergebnis eines Funktionsaufrufes einer Variablen zugewiesen oder in weiteren Rechnungen genutzt (average ) ;; ergibt 4 average(-42, 50); // ergibt 4

48 Definition von Funktionen
In Scheme erledigt define die Definition von Funktionen: In Java ist die Notation etwas anders: Vor dem Namen der Funktion steht der Ergebnistyp (hier: int) Die Parameter stehen in Klammern, getrennt durch Komma Vor jedem Parameter steht sein Typ Auch wenn mehrere Parameter nacheinander den gleichen Typ haben Geschweifte Klammern begrenzen die Funktion (wie „()“ in Scheme) Der Ergebniswert ist ein Ausdruck nach „return“ Methoden ohne Ergebnis haben als Ergebnistyp „void“ (define (average x y) (/ (+ x y) 2)) int average(int x, int y) { return (x + y) / 2; }

49 Funktionen in Java ;;inc:  number ;;effect: increases currentVal by 1
(define inc () (begin (set! currentVal (+ currentVal 1)) currentVal)) Formulierung der Effekte (später detaillierter) /** * Increases the current value of counter by 1 */ int inc() { currentVal = currentVal + 1; return currentVal; } Typ der Rückgabe Liste der formalen Parameter (hier: leer) Operationskopf Explizite Anweisung zur Rückgabe von Werten Operationsrumpf (Implementierung)

50 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

51 Kontrollstrukturen in Java
Kontrollstrukturen beeinflussen die Ausführung von Programmen Zwei grundlegende Typen: Bedingung: Anweisungen werden nur ausgeführt, wenn eine Bedingung erfüllt ist if- und cond-Spezialformen in Scheme Schleife: Anweisungen werden mehrfach ausgeführt Die Kontrollstrukturen von Java sind durch folgende Grammatikregel angegeben: <Kontrollanweisung> = <If-Anweisung> | <Switch-Anweisung> | <Return-Anweisung> | <Break-Anweisung> | <While-Schleife> | <Do-Schleife> | <For-Schleife>

52 Bedingungen: if-Anweisung
if (<Ausdruck>) <Anweisung> [else <Anweisung>] Die Auswertung von Ausdruck muss vom Typ boolean sein Die erste Anweisung wird nur ausgeführt, wenn der Ausdruck als true ausgewertet wird. Andernfalls wird der (optionale) else-Zweig ausgeführt Anweisung kann ein Block sein, also eine Sequenz von Ausdrücken In Java geben if-Anweisungen keinen Wert zurück Der else-Zweig ist optional

53 Fallunterscheidungen: if
In Scheme besteht „if“ immer aus drei Teilen: Bedingung Ausdruck, wenn die Bedingung wahr ist Ausdruck, wenn die Bedingung falsch ist In Java ist die Notation fast identisch (Fokus auf „if“!) (define (absolute x) (if (< x 0) (- x) x)) int absolute(int x) { if (x < 0) return –x; else return x; }

54 Die Ausdruck-Äquivalente von if
Anweisung versus Ausdruck In Scheme ist if ein Ausdruck: es hat einen Rückgabewert Dieser Ausdruck liefert entweder 100 oder 200 als Ergebnis Ein Scheme-artiges if gibt es in Java durch das Konstrukt (condition) ? exp1 : exp2 Falls die Bedingung wahr ist, dann ist der Wert des Ausdrucks gleich dem Wert von exp1, sonst dem Wert von exp2 (if (< num 0) ) if (num < 0) x = 100; else x = 200; x = (num < 0) ? 100 : 200; äquivalent

55 Fallunterscheidung Wir wollen ein einfaches Programm zur Farbunterscheidung schreiben Je nach übergebenem Parameter soll ein „passender“ Farbname ausgegeben werden Häufig in Grafikanwendungen benutzt Sogenannte „CLUT“ (Color Look-up Table) (define (color-choice color) (cond [(= color 0) "schwarz"] [(= color 1) "rot"] [(= color 2) "gelb"] [else "Farbe nicht identifizierbar"]) )

56 switch- und break-Anweisungen
Die switch-Anweisung kann als verallgemeinerte Form der Programmverzweigung aufgefasst werden Mehr oder weniger äquivalent zu cond in Scheme <Switch-Anweisung> = switch(<KonstanterAusdruck>) {<SwitchBlockAnweisungsGruppe>} <SwitchBlockAnweisungsGruppe> = <BedingungsFall> ... <BedingungsFall> <DefaultFall> <BedingungsFall> = case <CaseLabel>: <LokalerBlock> <DefaultFall> = default: <LokalerBlock> <LokalerBlock> = <VariablenDeklarationen> | <Anweisungen>

57 switch- und break-Anweisungen
public class SwitchAnweisung1 { public static void main(String[] args) { int farbeingabe = 1; switch(farbeingabe) { case 0: System.out.println("schwarz"); case 1: System.out.println("rot"); case 2: System.out.println("gelb"); default: System.out.println( "Farbe nicht identifizierbar"); } Maximal eine default-Alternative! KonstanterAusdruck muss zur Übersetzungszeit berechnet werden können

58 Vergleich von switch und cond
Statt mehreren Bedingungen kann in Java nur ein konstanter Ausdruck genutzt werden Auch die zu prüfenden Werte (case) müssen konstant sein switch passt nur in speziellen Fällen dort, wo man in Scheme ein cond genutzt hätte In der Regel entspricht dem cond von Scheme eine Folge von if-Befehlen Da bei return die Methode verlassen wird, können wir hier auch auf „else“ verzichten int absolute(int x) { if (x > 0) return x; else if (x == 0) return 0; else return –x; } (define (absolute x) (cond [(> x 0) x] [(= x 0) 0] [else (- x)]))

59 Semantik der switch-Anweisung
Auswertung des konstanten Ausdrucks und Durchsuchung der case-Labels nach einem passenden Wert Passendes case-Label gefunden Ausführung aller folgenden Anweisungen Beachte: das sind auch die Anweisungen der eventuell folgenden case- und default-Labels Kein passendes case-Label gefunden Sprung zum (optimal) vorhandenen default-Label Ausführung aller folgenden Anweisungen: Das könnten auch die Anweisungen der eventuell folgenden case- und default-Labels sein

60 Semantik der switch-Anweisung
public class SwitchAnweisung1 { public static void main(String[] args) { int farbeingabe = 1; switch (farbeingabe) { case 0: System.out.println("schwarz"); case 1: System.out.println("rot"); case 2: System.out.println("gelb"); default: System.out.println( "Farbe nicht identifizierbar"); } Aufruf: java SwitchAnweisung1 liefert: rot gelb Farbe nicht identifizierbar Nicht was wir wollten 

61 Semantik der switch-Anweisung
public class SwitchAnweisung2 { public static void main(String [] args) { int farbeingabe = 1; switch (farbeingabe) { case 0: System.out.println("schwarz"); break; case 1: System.out.println("rot"); case 2: System.out.println("gelb"); default: System.out.println( "Farbe nicht identifizierbar"); } Beispiel Aufruf: java SwitchAnweisung2 liefert: rot

62 Semantik der switch-Anweisung
Bemerkungen: Die break- (oder auch return-) Anweisung kann verwendet werden, um den switch-Block zu verlassen Ist kein default-Label vorhanden und keines der case-Labels passt, dann wird der switch-Block übersprungen Üblicherweise ist break die letzte Anweisung eines case-Labels Das default-Label sollte das letzte Label sein

63 Rekursive Funktionsaufrufe
In Scheme haben wir in der Regel Rekursion verwendet, um eine Operation auf mehreren Daten anzuwenden Das geht in Java natürlich auch: Für viele Anwendungen werden stattdessen Schleifen verwendet Eine Schleife führt (nach bestimmten Kriterien) Befehle wiederholt aus (define (sum-until-n n) (if (<= n 0) 0 (+ n (sum-until-n (- n 1))) ) „Addiere alle Zahlen von 1 bis n" int sumUntilN(int n) { if (n <= 0) return 0; return n + sumUntilN(n - 1); }

64 Schleifen „Addiere alle Zahlen von 1 bis n"
Die einfachste Schleife wiederholt eine Anweisung eine feste Anzahl mal (engl. „counting loop“) In Java: for-Schleife <For-Schleife> = for ([<Anweisung> | <Variablen-Deklaration>]; [<Ausdruck>];[<Anweisung>]) <Anweisung> Ausdruck muss vom Typ boolean sein for (int i = start; i < end; i++) // vorwaerts ... for (int i = end; i > start; i-=2) // rueckwaerts, Schrittweite 2 int sumUntilN(int n) { int sum = 0; for (int i = 1; i <= n; i++) sum += i; return sum; } „Addiere alle Zahlen von 1 bis n"

65 Schleifen und Rekursion
(define (factorial1 n) (if (= n 1) 1 (* n (factorial1 (- n 1))) ) Natürliche Rekursion (define (factorial2 n) (local ( (define (iter product counter) (if (> counter n) product (iter (* counter product) (+ counter 1)))))) (iter 1 1) ) Rekursion im Akkumulator-Stil (define (factorial3 n) (local ((define product 1) (define counter 1) (define (iter) (if (> counter n) product (begin (set! product (* counter product)) (set! counter (+ counter 1)) (iter))))) (iter))) Iteration mit Zuweisungen

66 Schleifen und Rekursion
class Example { public int factorial1(int n) { if (n == 1) { return 1;} else { return n * factorial1(n-1); } } public int factorial2(int n) { return iter(1, 1, n); private int iter(int product, int counter, int n) { if (counter > n) { return product; } else { return iter(counter * product, counter + 1, n); } public int factorial3(int n) { int product=1; for (int counter = 1; counter <= n; counter = counter + 1) { product = counter * product; return product; Natürliche Rekursion Lineare Iteration Iteration mit Zuweisungen

67 Die while-Schleife Häufig werden Schleifen nicht eine feste Anzahl mal ausgeführt Eine while-Schleife führt eine Anweisung so lange aus, wie die Schleifen-Bedingung wahr ist Ausdruck muss vom Typ boolean sein Vor der ersten und vor jeder weiteren Ausführung der Anweisung wird die Schleifenbedingung geprüft. Sobald die Bedingung als false ausgewertet wird, endet die Schleife. Es ist nicht sicher, dass der Schleifenkörper überhaupt ausgeführt wird. <While-Schleife> = while (<Ausdruck>) <Anweisung>

68 Die while-Schleife: Beispiel
„Prüfe, ob eine Zahl prim ist" // Zahl ist groeser als 0 boolean isPrime(int number) { int factor = 2; // pruefe alle Faktoren, bis einer die Zahl teilt while (number % factor != 0) { factor = factor + 1; } return number == factor; Entweder wurde ein Divisor kleiner als number gefunden oder factor wurde erhöht, bis es gleich number wurde.

69 Wie schreibt man eine while-Schleife?
Formuliere den Test, der festlegt, ob die Schleife wieder ausgeführt wird. z.B. (x - y*y) > bedeutet, dass die Präzision noch nicht gut genug ist Formuliere die Aktionen für den Schleifenkörper, der einen Schritt näher an den Abbruch der Schleife führt. z.B. s = s + i; i++, addiere die Werte Meistens braucht man eine Initialisierung vor der Schleife und etwas Nachbearbeitung nach der Schleife.

70 Schleifen: while und for
Im Allgemeinen hat eine while-Schleife die Form Das passt genau für die for-Schleife Die Anwendung mit einer festen Ausführungszahl ist nur ein Spezialfall! <initialization>; while (<condition>) { <core loop body>; <loop advancement>; } for (<initialization>; <condition>; <loop advancement>) <core loop body>

71 Die do-while-Schleife
Eine do-while-Schleife prüft die Bedingung nach der Ausführung des Schleifenkörpers Der Schleifenkörper wird wenigstens einmal ausgeführt Wenn Ausdruck false ist - die Auswertung findet nach der Ausführung des Schleifenkörpers statt - bricht die Schleife ab <Do-Schleife> = do <Anweisung> while (<Ausdruck>) <Ausdruck> muss vom Typ boolean sein

72 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Aufrufen von Funktionen Definition von Funktionen Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

73 Listen in Scheme In Scheme wurde sehr viel rekursiv auf Listen gearbeitet Listen sind rekursiv definiert (first, rest) und eignen sich sehr gut für rekursive Algorithmen Listen sind „fest eingebaut“, müssen also nicht neu definiert werden Im Gegensatz etwa zu unseren Bäumen und Graphen Listen sind der Länge unbegrenzt Sie „wachsen mit“, wenn neue Daten eingefügt werden Es gibt spezialisierte Zugriffsfunktionen first, second, third, … Sehr einfach zu definieren, falls nicht „schon vorhanden“ Was bietet Java an Vergleichbarem an?

74 Felder / Arrays: Motivation
Mathe: a1, a2, a3,... Referenz-Typ "Array" Wie kann man schnellen Zugriff auf eine potentiell große Anzahl an Elementen bieten, z.B. um sie zu sortieren? Verwendung vieler Variablen (a1, a2, …) geht nicht Anzahl der Elemente wäre fest Mühsame Vergleiche if (a1 < a2) { if (a1 < a3) ... Erzeugt sehr schwer erweiterbaren Code Verwendung von Datenstrukturen mit sequentiellem Zugriff auf die Elemente ist häufig zu ineffizient Das ist aber genau das, was Scheme mit Listen bietet!

75 Arrays Lösung: Array Eine Zusammenfassung mehrerer Elemente des selben Typs, indizierbar durch die Array Variable <Array-type> ::= <type>[] <Array-Creation> ::= new <type>[<size>] Beispiel: // erzeuge ein Array mit 15 Ganzzahlen int[] scores = new int[15]; Ein zusammenhängender Speicherbereich mit Platz für 15 ganzen Zahlen wird bereit gestellt. Dies erlaubt effizienten Zugriff.

76 Arrays Zugriff auf ein bestimmtes Array Element
z.B. a[0], a[1], a[3] In Java hat das erste Array Element den Index 0, das letzte hat immer den Index <array size> - 1 Abfragen der Länge eines Arrays a: a.length ohne Klammern! Die Nutzung eines illegalen Index verursacht eine Exception (ArrayIndexOutOfBoundsException)  Laufzeitfehler Der Vorteil von a[0] im Vergleich zu a0 ist die potentielle Verwendung einer Variablen als Index int i = 5; a[i+1] = a[i] + a[i–1];

77 Initialisierung von Arrays
int[] scores = new int[]{ 6, 4, 2, 8, 3 }; String[] predators = new String[] { "lion", "tiger", "shark"}; String[] predators = new String[3]; predators[0] = "lion"; predators[1] = "tiger"; predators[2] = "shark"; Deklariert und definiert automatisch ein Array mit 5 Elementen äquivalent

78 Referenz-Typ „Array“ b a Arrays sind Objekte
Werden mit "new" erzeugt (-> mehr in T12…) Werden durch garbage collection entsorgt Array-Variablen enthalten Referenzen zu Array-Objekten int[] a; int[] b = new int[]{ 3, 1, 4 }; a = b; // a und b greifen jetzt // auf das selbe Array zu! Unterschiede zu anderen Referenz-Typen: new-Operator benutzt keinen „Konstruktor" Keine Vererbung zwischen Array Typen 3 1 4 b a

79 Mehrdimensionale Arrays
Keine Dimension spezifiziert. Vorteil: effiziente Speicherung von nicht-rechteckigen Strukturen  dreieckige Matrix Arrays mit Arrays als Elementen Deklaration: int[][] table; Erzeugung: oder table = new int[3][]; table[1] = new int[2]; table = new int[3][2]; Zugriff: table[1][0] = 42;

80 Mehrdimensionale Arrays
int pascal[][] = new int[][] { { 1 }, { 1, 2, 1}, { 1, 3, 3, 1}, { 1, 4, 6, 4, 1} } 1 2 3 4 6 pascal[3][1]

81 Mehrdimensionale Arrays
table 42 table.length // 3 table[0].length // NullPointerException table[1].length // 2 table[1][2] // IndexOutOfBoundsException

82 Arrays - Darstellung Mehrdimensionale Arrays
nutze Zeilen-Spalten-Folge: auf A[2,4] folgt A[2,5] nutze Spalten-Zeilen-Folge: auf A[2,4] folgt A[3,4] Unterschied kann wichtig sein im Hinblick auf Caching

83 Arrays - Darstellung Mehrdimensionale Arrays
Kann in Java auch ein „Array von Referenzen zu Arrays“ sein. Frage: Was sind die Vor- und Nachteile von “fortlaufender Belegung” und “Arrays von Pointern auf Arrays” ? [C/C++ Notation!]

84 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Aufrufen von Funktionen Definition von Funktionen Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

85 Kommentierung von Java-Elementen
Bei Nutzung der korrekten Kommentarnotation kann Java automatisch Dokumentationen in HTML erzeugen Möglich für alle „nach außen“ sichtbaren Elemente: Klassen Konstante Klassen- und Objektattribute Methoden Grundlegende Notation: vor dem Element steht ein Kommentar folgender Form /** * Kommentartext */ Viel mehr unter

86 Sonderformate Es gibt zahlreiche Sonderbefehle
Fangen immer mit an Diese gehören in eine eigene Zeile des Kommentars „*“ am Anfang der Zeile nicht vergessen  @param x text Kommentar „text“ zu Parameter „x“ @return text Kommentiert, was diese Methode zurückgibt Natürlich nur sinnvoll, wenn die Methode nicht void ist! @author text Autorangabe, oft in Form „Name < >“

87 Sonderformate II @throws type text @version double @since text
Beschreibt das (mögliche) Auftreten einer Exception ( T18) mit Angabe von Typ und „wann / warum“ das passieren kann @version double Angabe der Versionsnummer @since text Angabe, seit wann diese Version existiert Im JDK oft „1.5“: erst seit Java 1.5/5.0 @see Referenz Querverweis auf andere Elemente Bei anderer packagenamen.Klasse#Methode Methoden mit Parameter: Angabe mit Typ der Parameter Z.B. als m(int, String, double)

88 Beispiel /** * This method will sort the array passed in, thus * changing its elements. * Uses quicksort(array, 0, array.length-1) for sorting. * array the array to be sorted IllegalArgumentException if the array is null Guido Roessling 0.2 #quicksort(array, int, int) */ public void quicksort(int[] array) { /* … */ }

89 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Schleifen, Rekursion Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung

90 Integrierte Entwicklungsumgebung
Eine integrierte Entwicklungsumgebung (integrated development environment, IDE) ist ein Programm zur Unterstützung von Entwicklern bei der Erstellung von Anwendungen Eine IDE besteht normalerweise aus einem Quellcode-Editor, einem Compiler und/oder Interpreter, Werkzeugen zur automatisierten Anwendungserzeugung, und (normalerweise) einem Debugger Viele moderne IDEs verfügen außerdem über einen Klassen-browser, einen Objektinspektor und ein Klassenhierarchie-diagramm, die in der Erstellung objektorientierter Anwendungen verwendet werden können. Eine IDE ist typischerweise für eine bestimmte Sprache gedacht, wie z. B. die Visual Basic IDE. IDEs, die mehrere Programmiersprachen unterstützen: Eclipse, NetBeans, Microsoft Visual Studio Sometimes a version control system and various tools to simplify the construction of a GUI are integrated as well.

91 Der Eclipse-Java-Editor
Die Fähigkeiten des Eclipse-Editors umfassen auch Codevervollständigung und Syntaxprüfung. Codevervollständigung stellt eine kontextsensitive Liste von Vorschlägen dar, die mit der Tastatur oder Maus ausgewählt werden können: Eine Liste von Methoden, die zu einem Objekt passen, oder ein zu ergänzendes Codestück, basierend auf Schlüsselwörtern wie for oder while Kann durch Strg-Leertaste aufgerufen werden Syntaxprüfung hängt von inkrementeller Übersetzung ab Wenn der Quelltext gespeichert wird, wird er im Hintergrund übersetzt und auf Syntaxfehler überprüft Kein separater Übersetzungsschritt! Standardmäßig werden Syntaxfehler rot unterstrichen, und ein roter Punkt mit einem weißen "X" erscheint am linken Rand. Fehler, die durch eine Glühbirne am linken Rand des Editors angezeigt werden, kann der Editor selbst beheben  Quick Fix Erreichbar durch Strg-1

92 Der Eclipse-Java-Editor
Package Übersicht Outline (Übersicht) Code Editor Tabs für Sichten, hier: Probleme Probleme (Compile-Fehler, Warnungen)

93 Eclipse: Anzeige von JavaDoc

94 Eclipse: Codevervollständigung

95 Eclipse: Inhaltshilfe

96 Eclipse: Refactoring

97 Debugging mit Eclipse Der JDT-Debugger von Eclipse kann ein Java-Programm Zeile für Zeile ausführen, z. B. um Variablenwerte an bestimmten Punkten zu untersuchen Eine der mächtigsten Möglichkeiten, um Fehler im Code aufzuspüren Entspricht der schrittweisen Auswertung in DrScheme Um das Debugging vorzubereiten, wird ein Unterbrechungspunkt (breakpoint) im Code gesetzt An diesem Punkt unterbricht der Debugger die Ausführung und wechselt zur Debugger-Perspektive Ein Breakpoint wird durch einen Doppelklick in den grauen Rahmen auf der linken Seite des Editors gesetzt Es erscheint ein blauer Punkt, der den Breakpoint anzeigt Starten Sie das Program mit „Debug“, nicht mit „Run“ im Menü „Run“! Without a breakpoint, the program will run to completion Die Debugging-Perspektive stellt verschiedene neue Ansichten zur Verfügung, die für Debugging nützlich sind

98 Ansichten der Debugging-Perspektive
schrittweise durch den Code gehen Die Debug-Ansicht zeigt den Aufrufstack und die Zustände aller Threads, einschl. der bereits fertig ausgeführten Ansichten zur Modifi-kation von Variablen und Break-points program, which Eclipse started, has hit a breakpoint, and its status is shown as Suspended In the title bar of the Debug view is a toolbar that lets you control the program's execution. The first few tool buttons, which resemble the familiar controls of electronic devices such as CD players, allow you to resume, suspend, or terminate the program. Several buttons incorporate arrows in their design; these allow you to step through a program a line at a time. Holding the mouse over each button in turn will cause tool tips to appear, identifying them as Step With Filters, Step Into, Step Over, Step Return, and so on. For example, click the second step button, Step Into. Doing so executes the line of code that is currently highlighted in the editor area below the Debug view: the call to the say() method. Step Into, as the name suggests, takes you into the method that is called. After clicking Step Into, the highlighted line is the first executable line in say()—the for statement. The Step With Filters button works the same as Step Into, but it's selective about what methods it will step into. You normally want to step only into methods in your own classes and not into the standard Java packages or third-party packages. You can specify which methods Step Filter will execute and return from immediately by selecting Window.Preferences.Java.Debug.Step Filtering and defining step filters by checking the packages and classes listed there. Taking a moment to set these filters is well worth the trouble, because Step With Filters saves you from getting lost deep in unknown code—something that can happen all too often when you use Step Into. Sometimes a program has many variables, but you're interested in only one or a few. To watch select variables or expressions, you can add them to the watch list in the Expression view. To do this, select a variable—i, for instance—by double-clicking on it in the editor, and then right-clicking on the selection and choosing Watch from the context menu. The variable (and its value, if it's in scope) will appear in the Expressions view. One significant advantage of watching variables in the Variables and Expressions views over using print statements for debugging is that you can inspect objects and their fields in detail and change their values—even normally immutable strings. Return to the Variables view and expand the msg variable to show its attributes. One of these is a char array, value, which can be expanded to reveal the individual characters in the msg String. For example, double-click on the character H, and you will be prompted to enter a new value, such as J. Editor-Ansicht

99 Wichtige Tastenkürzel für Eclipse
Eclipse bietet sehr viele sehr gute Möglichkeiten zur Unterstützung des Programmierens Hier die wichtigsten allgemeinen Tastenkürzel Für Windows; auf anderen Betriebssystemen (Mac; im Pool, …) evtl. teilweise anders Kürzel Effekt Strg-Leertaste Code vervollständigen Strg-F Text suchen / ersetzen Strg-H Spezielle Suche (nach Klassen, in Dateien, …) Strg-J Inkrementelle Suche („Weitersuchen“) Strg-K Zur nächsten Fundstelle springen Strg-Shift-K Zur vorherigen Fundstelle springen Strg-F11 Programm ausführen F11 Programm im Debugger starten

100 Tastenkürzel Eclipse für Java
Effekt F3 Deklaration des Elements unter dem Cursor öffnen F4 Klassenhierarchie im View zeigen Alt-Shift-S Source-Menü einblenden Alt-Shift-Z Codeblock umschließen (etwa mit try/catch, s. später) Shift-F2 Externe Javadoc-Dokumentation öffnen Strg-/ Zeilen auskommentieren Strg-1 Quick Fix (automatische Korrektur) Strg-2 Abkürzungen für Quick Assist Strg-Alt-H Aufrufhierarchie der aktuellen Methode Strg-G Deklaration der Klasse im Workspace suche Strg-I Einrückungen anpassen Strg-O Outline (Übersicht) einblenden Strg-T Klassenhierarchie einblenden

101 Tastenkürzel Eclipse für Java
Effekt Strg-Shift-F Code automatisch formatieren Strg-Shift-G Referenzen der selektierten Klasse im Workspace suchen Strg-Shift-O Import-Anweisungen automatisch erstellen (-> T15) Strg-Shift-T Schnellsuche für Klassen

102 Code Refactoring Beim Refactoring können Methoden einfach umbenannt, Parametertypen geändert werden etc. Normalerweise viel „Handarbeit“ Neben der Methode selbst sind auch alle Methoden anzupassen, die darauf zugreifen Eclipse erledigt das automatisch Kürzel Effekt Alt-Shift-C Parameter einer Methode ändern Alt-Shift-I Methode einbetten Alt-Shift-M Methode extrahieren Alt-Shift-R Umbennenen Alt-Shift-T Refactoring-Menü anzeigen Alt-Shift-V Verschieben

103 Tastenkürzel für den Debugger
Auch für den Debugger gibt es hilfreiche Tastenkürzel Kürzel Effekt F11 Programm im Debugger starten Strg-Shift-B Haltepunkt an aktueller Codezeile setzen Strg-Shift-I Variable inspizieren F5 Step into (in Methodenaufrufe etc. hineingehen) F6 Step over (über Methodenaufrufe etc. hinweggehen) F7 Step return (Methode bis zum return ausführen) F8 Ausführung fortsetzen

104 Inhaltsübersicht Allgemeine Unterschiede zwischen Scheme und Java
Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen Operatoren für Arithmetik, Logik und Bitoperationen Funktionen in Java Kontrollflusssteuerung in Java Fallunterscheidungen, Rekursion, Schleifen Listen (Scheme) vs. Felder (Java) Kommentierung von Java-Elementen Einführung in die Eclipse Entwicklungsumgebung Zusammenfassung

105 Zusammenfassung OOP ist ein Programmierparadigma, das Berechnungen als Mengen von Objekten strukturiert, die über Methodenaufrufe kooperieren. Klassen und Objekte in Java ähneln Konstruktorfunktionen und den entsprechenden Objekten in Scheme. Die Unterschiede sind in erster Linie syntaktischer Natur! Die Dispatch-Mechanismen sind fest in die Semantik von OO-Sprachen eingebaut (Details dazu folgen später) Java basiert auf VM-Technologie  die beste der Compiler- und Interpreter-Technologien Konditionale in Java ähneln denen in Scheme; Kontrollstrukturen werden oft an Stelle von Rekursion eingesetzt. Entwicklungsumgebungen unterstützen den Entwicklungsprozess.

106 Übungsmöglichkeiten Auf der Webseite finden Sie einige Programmbeispiele Binden Sie „acm.jar“ in den CLASSPATH ein, wie dort beschrieben Außerdem betreibt der Fachbereich Informatik Webtasks Viele Programmieraufgaben, von „sehr einfach“ bis „recht schwer“ Außerdem auch einige Multiple-Choice Tests für „höhere Semester“ Insbesondere die Aufgaben zu Arrays und Schleifen sind gut zum Üben geeignet – auch für „erfahrenere Programmierer“ Jede Einreichung wird mit javac übersetzt und mit Junit getestet Sie erhalten passendes Feedback, was „schief ging“ und können den Code entsprechend überarbeiten und neu einreichen Wer eine Aufgabe gelöst hat, hat Zugriff auf alle anderen Lösungen dieser Aufgabe und kann davon lernen bzw. sie kommentieren Nutzung erfolgt mit RBG-Login oder freier Login-Wahl

107 In beiden Stilen programmieren
Programmieren in Java Fördert den imperativen Stil auf viele Arten Bequemer syntaktischer Zucker für viele imperative Konstrukte, z.B. verschiedene Schleifen für unterschiedliche Zwecke Erster-Klasse-Funktionen fehlen Dies macht es schwieriger, manche interessante Muster der funktionalen Programmierung auszudrücken Können teils durch Objekte simuliert werden Programmieren in Scheme Scheme unterstützt den funktionalen Stil sehr gut Der imperative Stil wird auch unterstützt siehe das factorial3-Beispiel

108 In beiden Stilen programmieren
Man kann in Scheme und Java in beiden Stilen programmieren! Ein guter Programmierer muss in beiden Stilen ein Experte sein. Ziel #1 dieser Vorlesung: Sie sollen beide Stile können! “Objektorientierter Stil” ist ein anderes Thema!


Herunterladen ppt "Prof. Dr. Max Mühlhäuser Dr. Guido Rößling"

Ähnliche Präsentationen


Google-Anzeigen