Grundlagen der Informatik I: T11 - Technische Universität Darmstadt

Technische Universität Darmstadt
Telecooperation/RBG
Grundlagen der Informatik I
Thema 11: Von Scheme zu Java
Prof. Dr. Max Mühlhäuser
Dr. Guido Rößling
Copyrighted material; for TUD student use only
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
2
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
3
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
4
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Erwähnt noch nicht einmal die Liste!
(multlist ‘(3 4 5)) Abstraktion von den Details
 60
der Ausführung
Grundlagen der Informatik I: T11
5
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
6
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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);
Grundlagen der Informatik I: T11
7
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Ein paar Worte zur Java-Lexikalik
• Name (Identifier): c2, 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
Grundlagen der Informatik I: T11
8
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
9
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Struktur eines Java-Programms
• Ein Java-Programm kann aus beliebig vielen Klassen
bestehen, von denen mindestens eine die mainOperation 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 durch Java-Interpreter gestartet und ausgeführt
Grundlagen der Informatik I: T11
10
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
}
JavaCompiler
JavaBytecodeInterpreter
javac CounterTest.java
java
CounterTest
Grundlagen der Informatik I: T11
11
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Java-Übersetzung
• 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
class Bsp1 {...}
class Bsp2 {...}
class Bsp3 {...}
Java Compiler
Datei.java
Grundlagen der Informatik I: T11
Bsp1.class
Bsp2.class
Bsp3.class
12
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Berechnungen durchführen
• Die Aufgabe wird in Dienstanweisungen zerlegt
– Formuliert als Nachrichten (Operationsaufrufe) an Objekte
• Jede Nachricht enthält:
– Name des Empfängerobjektes: c2 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
Grundlagen der Informatik I: T11
13
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 www.acm.org; 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)
Grundlagen der Informatik I: T11
14
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
15
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 (in 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
Grundlagen der Informatik I: T11
16
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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:
Grundlagen der Informatik I: T11
17
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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“
Grundlagen der Informatik I: T11
18
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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:
Grundlagen der Informatik I: T11
19
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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):
Grundlagen der Informatik I: T11
20
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
21
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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:
;; provide initial value for counter
(define counter-value 0)
;; increment the counter
(set! counter-value (succ counter-value))
• In Java erfolgen Zuweisungen mittels "=":
// provide initial value for counter
counterValue = 0;
// increment the counter
counterValue = counterValue + 1;
Grundlagen der Informatik I: T11
22
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 (+ 1 2 3 4 5) wird also 1 + 2 + 3 + 4 + 5
Grundlagen der Informatik I: T11
23
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
+
2+3+7
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
Grundlagen der Informatik I: T11
24
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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;
Grundlagen der Informatik I: T11
25
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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)
Grundlagen der Informatik I: T11
26
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Variablentyp
counter darf nur ganzzahlige Werte annehmen
int counter;
counter = 10;
counter = "hello";
Nur für ganze Zahlen definierte
Operationen dürfen verwendet
werden.
counter
4 Speicherzellen
counter++;
counter.move();
Grundlagen der Informatik I: T11
27
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Variablen: Zuweisung & Ausdrücke
Ausdruck
size =
4
=
size
Kontrollfluss
size
+ delta;
1
3
+
2
delta
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.
Grundlagen der Informatik I: T11
28
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
29
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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"
Grundlagen der Informatik I: T11
30
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
byte
Minimalwert
-128
Maximalwert
Speicherplatz
127 1 Byte (8 Bit)
-32 768
32 767 2 Bytes (16 Bit)
-2 147 483 648
2 147 483 647 4 Bytes (32 Bit)
-263
263-1 8 Bytes (64 Bit)
float
1,402·10-45
3,402·1038 4 Bytes (32 Bit)
double
4,94·10-324
1,797·10308 8 Bytes (64 Bit)
short
int
long
boolean
false
true 1 Bit
Scheme bewahrt den Nutzer vor diesen maschinenabhängigen Details.
 einfacher zu nutzen, weniger fehleranfällig, aber höhere Laufzeit.
Grundlagen der Informatik I: T11
31
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Zeichen in Java
• Java verwendet Unicode für den Datentyp char
– Einen 16-Bit-Zeichensatz, in dem fast alle Zeichen aller
Sprachen repräsentiert werden können
• Umlaute etc. sind als Unicode-Escapesequenz anzugeben
– Diese beginnt immer mit \u, gefolgt von vier Hexadezimalziffern
• Die wichtigsten Umlaute und ihre Codierung sind:
char
Code
char
Code
Ä
\u00C4
ä
\u00E4 Á
\u00C1 á
\u00E1
À
\u00C0
à
\u00E0 Ç
\u00C7 ç
\u00E7
É
\u00C9
é
\u00E9 È
\u00C8 è
\u00E8
Ö
\u00D6
ö
\u00F6 Ó
\u00D3 ó
\u00F3
Ü
\u00DC ü
\u00FC Ú
\u00DA ú
\u00FA
Ù
\u00D9
\u00F9 Â
\u00C2 ß
\u00DF
ù
char Code
char
Code
• Konvertierbar durch Kommandozeilenbefehl native2ascii
Grundlagen der Informatik I: T11
32
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
33
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Zusammengesetzte Ausdrücke
Beispiele
double a; int i; char c; boolean b;
a = 3.1415 + 42;
// a == 45.1415
i = 4 – 9;
// i == -5
c = 'T';
// c == 'T'
i = i + 1;
// i == -5 + 1 == -4
a = i * 2 + 3;
// a == -4 * 2 + 3 == -8 + 3 == -5
a = i * (2 + 3);
// a == -4 * (2 + 3) == -4 *5 == -20
b = true;
// b == true
b = i > 0;
// -4 > 0 == false  b == false
Grundlagen der Informatik I: T11
34
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Boolesche Ausdrücke
• Vergleiche:
– == 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
true
false
Grundlagen der Informatik I: T11
35
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
false
false
false
false
true
false
true
true
false
false
true
true
true
true
true
analog zu and, or in Scheme…
Grundlagen der Informatik I: T11
36
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 /2
// Mit 3/2 == 1 (Ganzzahldivision)
//  b ist jetzt true
Grundlagen der Informatik I: T11
37
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Nicht-strikte Operatoren
• Die logischen Operatoren
a && b
a || b
(logisches und)
(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
Grundlagen der Informatik I: T11
38
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Bit-Operationen
a & b
a | b
a ^ b
~a
a << b
a >> b
a >>> b
Bitweises Und
Bitweises Oder
Bitweises Exklusiv-Oder, nicht gleich
Bitweise Negation
Verschiebt a um b Stellen nach links,
entspricht Multiplikation mit 2b
Verschiebt a um b Stellen nach rechts,
entspricht Division mit 2b
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.
Grundlagen der Informatik I: T11
39
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Bit-Operationen
Beispiele
i = 5  i = 0000 0000 0000 0101
j = 3  j = 0000 0000 0000 0011
= 0000 0000 0000 0001  i & j
= 0000 0000 0000 0111  i | j
i << 1 = 0000 0000 0000 1010  i << 1
i >> 1 = 0000 0000 0000 0010  i >> 1
~i
= 1111 1111 1111 1010  ~i
• Warum ist ~i == -6?
• short
short
• i & j
i | j
==
==
==
==
==
1
7
10
2
-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.
Grundlagen der Informatik I: T11
40
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
41
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
42
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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++;
b = a++;
b = ++a;
b = a--;
//
//
//
//
entspricht:
entspricht:
entspricht:
entspricht:
a
b
a
b
=
=
=
=
a + 1;
a; a = a + 1;
a + 1; b = a;
a; a = a – 1;
Grundlagen der Informatik I: T11




a==5
a==6, b==5
a==7, b==7
a==6, b==7
43
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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))
Grundlagen der Informatik I: T11
(< a 3))
44
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Operator-Priorität und Assoziativität
• Operator-Prioritä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.
Grundlagen der Informatik I: T11
45
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Operator Priorität und Assoziativität
Priorität
Assoziativität
Unäre Operatoren
Multiplikation / Division / Rest
Addition/ Subtraktion
Shift
Vergleich
Gleichheit
bitweises und
bitweises xor
bitweises oder
logisches und
logisches oder
Bedingungsoperator
Zuweisung
++, --, -, ~, !
*, /, %
+, <<, >>
<, >, <=, >=
==, !=
&
^
|
&&
||
?:
=, +=, -=, *=, …
rechts
links
links
links
links
links
links
links
links
links
links
rechts
rechts
In Scheme wegen Präfix Notation nicht notwendig
Grundlagen der Informatik I: T11
46
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
47
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Aufrufen von Funktionen
• In Scheme werden oft Funktionen angewendet
– Dazu wurde einfach der Funktionsname, gefolgt von allen
Parametern, in Klammern gesetzt
(average -42 50) ;; ergibt 4
• In Java erfolgt der Aufruf durch Angabe des Namens,
gefolgt von den Parametern in Klammern (und getrennt
mit Komma):
average(-42, 50); // ergibt 4
– 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
Grundlagen der Informatik I: T11
48
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Definition von Funktionen
• In Scheme erledigt define die Definition von Funktionen:
(define (average x y)
(/ (+ x y) 2))
• In Java ist die Notation etwas anders:
int average(int x, int y) {
return (x + y) / 2;
}
– 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“
Grundlagen der Informatik I: T11
49
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
Funktionen in Java
Formulierung der
Effekte (später
detaillierter)
;;inc:  number
;;purpose: increases currentVal by 1
(define inc ()
(begin
(set! currentVal (+ currentVal 1))
currentVal))
/**
* Increases the current value of counter by 1
*/
Typ der
Rückgabe
int inc() {
Operationskopf
©
Liste der formalen
Parameter (hier: leer)
currentVal = currentVal + 1;
return currentVal;
}
Operationsrumpf
(Implementierung)
Explizite Anweisung zur
Rückgabe von Werten
Grundlagen der Informatik I: T11
50
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
51
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Strings in Java
• Auch wenn sie zunächst so aussehen, sind Strings in Java
keine primitiven Datentypen
• Strings werden erzeugt durch die Nutzung von doppelten
Anführungszeichen: "Hello World" erzeugt einen String
– Alternativ durch new String("Hello World")
• Durch die Methode toString() kann jedes Objekt (T12)
in eine String-Repräsentation umgewandelt werden
– Wurde diese Methode nicht „passend“ implementiert, entsteht
in etwa folgender String: MyClassName@1234567ab
– MyClassName steht dabei für den Namen der Klasse
– 1234567ab steht für den „Hash-Code“ der Klasse
• Umwandlung primitiver in String:
– String.valueOf(x) wobei x den Typ int, boolean, … haben kann
Grundlagen der Informatik I: T11
52
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Wichtige Methoden der Klasse String
• Hier ist nur eine Auswahl – bitte lesen Sie die Doku!
– char charAt(int index) – liefert das Zeichen an Position index
– int compareTo(String o),int compareToIgnoreCase(String o) –
vergleicht den aktuellen String mit o:
•
•
•
•
Sind beide gleich, ist das Ergebnis 0
Ist der aktuelle String lexikografisch „kleiner“, ist das Ergebnis < 0
Ist der aktuelle String lexikografisch „größer“, ist das Ergebnis > 0
Die erste Variante unterscheidet Groß-/Kleinbuchstaben, die 2. nicht
– int indexOf(char c), int indexOf(String o),
int indexOf(char c, int s), int indexOf(String o, int s)
• Liefert die erste Position, an der c bzw. o auftritt, sonst -1
• In der zweiten Variante gilt dies erst ab Startposition s
– int lastIndexOf(char c), int lastIndexOf(String o),
int lastIndexOf(char c, int s), int lastIndexOf(String o, int s)
• Analog zu indexOf, liefert aber die letzte gefundene Position.
Grundlagen der Informatik I: T11
53
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Wichtige Methoden der Klasse String
• int length()
– Liefert die Länge des Strings
• String replace(char oldChar, char newChar)
– Ersetzt alle Vorkommen von oldChar durch newChar und gibt
einen entsprechenden neuen String zurück.
• boolean startsWith(String s), boolean endsWith(String s)
– Liefert true oder false, je nachdem, ob der aktuelle String mit
dem String s anfängt bzw. endet oder nicht.
• String substring(int startIndex),
String substring(int startIndex, int endIndex)
– Liefert einen Auszug des aktuellen Strings, der an der Position
beginIndex anfängt und bis zum Ende des Strings bzw. in der
Variante mit zwei Parametern bis vor endIndex reicht.
Grundlagen der Informatik I: T11
54
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Wichtige Methoden der Klasse String
• String toLowerCase(), String toUpperCase()
– Diese Methoden erstellen einen neuen String, der dem aktuellen
String entspricht, aber bei dem alle Großbuchstaben in
Kleinbuchstaben umgewandelt wurden bzw. alle Kleinbuchstaben in
Großbuchstaben umgewandelt wurden. Andere Zeichen sind nicht
betroffen.
• String trim()
– Liefert einen String, der dem aktuellen String entspricht, nachdem
alle führenden und abschließenden "Whitespace"-Zeichen (mit
ASCII-Code kleiner als 32, der Codierung des Leerzeichens) entfernt
wurden. Daher gilt:
– " Hello World! ".trim(); // returns "Hello World!"
• char[] toCharArray()
– Liefert ein char[], bei dem jedes Element genau dem Zeichen an
der entsprechenden Position entspricht.
Grundlagen der Informatik I: T11
55
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Vergleichen von Strings
• Strings bitte nur über String.equals(String s) vergleichen
– Also bitte nicht mit "=="!
– Auch wenn es verführerisch ist…
– "==" testet in Java, ob zwei Elemente identisch sind, d.h. es sich
um das selbe Objekt - nicht nur um ein "gleiches" handelt.
– Daher sollte man "==" auf Objekten inklusive String immer nur
dann verwenden, wenn man wissen will, ob die beiden Objekte
wirklich identisch sind und sich nicht nur gleichen.
• == funktioniert aber bei mir – manchmal?
– Das liegt an einer „Optimierung“ seitens Java, bei der mehrfach
auftretende gleiche Strings nur einmal gespeichert werden.
– Das gilt aber nicht für dynamisch (zur Laufzeit) erzeugte Strings!
• Strings sind „immutable“ (unveränderlich)
– Das heißt: jeder „Änderung“ legt einen neuen String an (!)
Grundlagen der Informatik I: T11
56
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
StringBuffer und „Zusammenfügen“ von Strings
• Insbesondere bei der Ausgabe möchte man gerne
Elemente aneinanderhängen:
– "Hello, " + givenName + " " + familyName
• Dafür gibt es den „+“-Operator für Strings
• Aber: dieser erzeugt jedesmal (!) einen neuen String
• Daher ist es besser, mit einem StringBuffer (s. Doku) zu
arbeiten
• Grundschema (Details siehe Dokumentation):
– StringBuffer sb = new StringBuffer(256);
– sb.append("Hello, ").append(givenName).append(" ");
– sb.append(familyName);
• Umwandlung in einen String: durch toString()
• Nutzung des StringBuffers ist deutlich effizienter als „+“
Grundlagen der Informatik I: T11
57
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
58
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 werden durch
folgende Grammatikregel angegeben:
<Kontrollanweisung> =
<If-Anweisung> | <Switch-Anweisung> |
<Return-Anweisung> | <Break-Anweisung> |
<While-Schleife> | <Do-Schleife> | <For-Schleife>
Grundlagen der Informatik I: T11
59
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Bedingungen: if-Anweisung
<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
Grundlagen der Informatik I: T11
60
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Fallunterscheidungen: if
• In Scheme besteht „if“ immer aus drei Teilen:
– Bedingung
– Ausdruck, wenn die Bedingung wahr ist
– Ausdruck, wenn die Bedingung falsch ist
(define (absolute x)
(if (< x 0)
(- x)
x))
• In Java ist die Notation fast identisch (Fokus auf „if“!)
int absolute(int x) {
if (x < 0)
return –x;
else
return x;
}
Grundlagen der Informatik I: T11
61
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Die Ausdruck-Äquivalente von if
• Anweisung versus Ausdruck
• In Scheme ist if ein Ausdruck mit Rückgabewert
(if (< num 0) 100 200)
– 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, entspricht der Wert des
Ausdrucks exp1, sonst ist der Wert exp2
if (num < 0)
x = 100;
else
x = 200;
x = (num < 0) ? 100 : 200;
äquivalent
Grundlagen der Informatik I: T11
62
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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"])
)
Grundlagen der Informatik I: T11
63
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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>
Grundlagen der Informatik I: T11
64
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
65
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
(define (absolute x)
(cond [(> x 0) x]
[(= x 0) 0]
[else (- x)]))
int absolute(int x) {
if (x > 0) return x;
else if (x == 0) return 0;
else return –x;
}
• Da bei return die Methode verlassen wird, können wir
hier auch auf „else“ verzichten
Grundlagen der Informatik I: T11
66
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
67
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Nicht was wir
gelb
wollten 
Farbe nicht identifizierbar
Grundlagen der Informatik I: T11
68
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Semantik der switch-Anweisung
public class SwitchAnweisung2 {
public static void main(String [] args) {
Beispiel
int farbeingabe = 1;
switch (farbeingabe) {
case 0: System.out.println("schwarz");
break;
case 1: System.out.println("rot");
break;
case 2: System.out.println("gelb");
break;
default: System.out.println(
"Farbe nicht identifizierbar");
}
}
}
Aufruf: java SwitchAnweisung2 liefert: rot
Grundlagen der Informatik I: T11
69
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
70
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Rekursive Funktionsaufrufe
• In Scheme haben wir in der Regel Rekursion verwendet, um eine
Operation auf mehreren Daten anzuwenden
(define (sum-until-n n)
(if (<= n 0) 0
(+ n (sum-until-n (- n 1)))
)
„Addiere alle
)
Zahlen von 1 bis n"
• Das geht in Java natürlich auch:
int sumUntilN(int n) {
if (n <= 0) return 0;
return n + sumUntilN(n - 1);
}
• Für viele Anwendungen werden stattdessen Schleifen verwendet
• Eine Schleife führt (nach bestimmten Kriterien) Befehle
wiederholt aus
Grundlagen der Informatik I: T11
71
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Schleifen
• 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
Grundlagen der Informatik I: T11
von 1 bis n"
72
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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)
Rekursion im
(if (> counter n)
Akkumulator-Stil
product
(iter (* counter product) (+ counter 1))))))
(iter 1 1) )
(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)))
Grundlagen der Informatik I: T11
Iteration mit
Zuweisungen
73
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Schleifen und Rekursion
class Example {
public int factorial1(int n) {
if (n == 1) { return 1;}
else { return n * factorial1(n-1); }
}
Natürliche Rekursion
public int factorial2(int n) {
Lineare Iteration
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;
}
Iteration mit
return product;
}
Zuweisungen
Grundlagen der Informatik I: T11
74
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Die while-Schleife
• Häufig werden Schleifen nicht eine feste Anzahl mal ausgeführt
• Eine while-Schleife führt eine Anweisung aus, solange die
Schleifen-Bedingung wahr ist
<While-Schleife> = while (<Ausdruck>) <Anweisung>
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.
Grundlagen der Informatik I: T11
75
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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.
Grundlagen der Informatik I: T11
76
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Wie schreibt man eine while-Schleife?
1. Formuliere den Test, der festlegt, ob die Schleife
wieder ausgeführt wird.
 z.B. (x - y*y) > 0.005 bedeutet, dass die
Präzision noch nicht gut genug ist
2. 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
3. Meistens braucht man eine Initialisierung vor der
Schleife und etwas Nachbearbeitung nach der Schleife.
Grundlagen der Informatik I: T11
77
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Schleifen: while und for
• Im Allgemeinen hat eine while-Schleife die Form
<initialization>;
while (<condition>) {
<core loop body>;
<loop advancement>;
}
• Das passt genau für die for-Schleife
– Die Anwendung mit einer festen Ausführungszahl ist nur ein
Spezialfall!
for (<initialization>; <condition>; <loop advancement>)
<core loop body>
Grundlagen der Informatik I: T11
78
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Die do-while-Schleife
• Eine do-while-Schleife prüft die Bedingung nach der
Ausführung des Schleifenkörpers
<Do-Schleife> = do <Anweisung> while (<Ausdruck>)
<Ausdruck> muss vom Typ boolean sein
• 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
Grundlagen der Informatik I: T11
79
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
80
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 haben eine unbegrenzte Länge
– 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?
Grundlagen der Informatik I: T11
81
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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!
Grundlagen der Informatik I: T11
82
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 Ganzzahlen wird reserviert. Dies erlaubt effizienten
Zugriff.
Grundlagen der Informatik I: T11
83
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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];
Grundlagen der Informatik I: T11
84
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Initialisierung von Arrays
int[] scores = new int[]{ 6, 4, 2, 8, 3 };
Deklariert und definiert automatisch ein Array mit 5 Elementen
String[] predators = new String[] {
"lion", "tiger", "shark"};
String[] predators = new String[3];
predators[0] = "lion";
predators[1] = "tiger";
äquivalent
predators[2] = "shark";
Grundlagen der Informatik I: T11
85
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Referenz-Typ „Array“
• 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!
3
b
1
4
a
• Unterschiede zu anderen Referenz-Typen:
– new-Operator benutzt keinen „Konstruktor"
– Keine Vererbung zwischen Array Typen
Grundlagen der Informatik I: T11
86
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Mehrdimensionale Arrays
• Arrays mit Arrays als Elementen
– Deklaration: int[][] table;
– Erzeugung:
table = new int[3][2];
oder
Keine Dimension
spezifiziert. Vorteil:
effiziente Speicherung
von nicht-rechteckigen
Strukturen  dreieckige
Matrix
table = new int[3][];
table[1] = new int[2];
0
0
0
0
0
0
0
0
– Zugriff:
table[1][0] = 42;
Grundlagen der Informatik I: T11
87
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Mehrdimensionale Arrays
int pascal[][] = new int[][] {
{ 1 },
{ 1, 2, 1},
{ 1, 3, 3, 1},
{ 1, 4, 6, 4, 1} }
1
1
1
1
2
3
4
1
3
6
1
4
pascal[3][1]
1
Grundlagen der Informatik I: T11
88
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Mehrdimensionale Arrays
table
42 0
table.length
table[0].length
table[1].length
table[1][2]
//
//
//
//
3
NullPointerException
2
IndexOutOfBoundsException
Grundlagen der Informatik I: T11
89
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
90
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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!]
Grundlagen der Informatik I: T11
91
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
92
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 http://java.sun.com/j2se/javadoc/index.jsp
Grundlagen der Informatik I: T11
93
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 <email>“
Grundlagen der Informatik I: T11
94
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Sonderformate II
• @throws type 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 Klasse: @see packagenamen.Klasse#Methode
– Methoden mit Parameter: Angabe mit Typ der Parameter
• Z.B. als m(int, String, double)
Grundlagen der Informatik I: T11
95
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Beispiel
/**
* This method will sort the array passed in, thus
* changing its elements.
* Uses quicksort(array, 0, array.length-1) for sorting.
*
* @param array the array to be sorted
* @throws IllegalArgumentException if the array is null
* @author Guido Roessling [email protected]
* @version 0.2
* @see #quicksort(array, int, int)
*/
public void quicksort(int[] array) { /* … */ }
Grundlagen der Informatik I: T11
96
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Strings in Java
Kontrollflusssteuerung in Java
– Fallunterscheidungen, Schleifen, Rekursion
• Listen (Scheme) vs. Felder (Java)
• Kommentierung von Java-Elementen
• Einführung in die Eclipse Entwicklungsumgebung
Grundlagen der Informatik I: T11
97
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 Klassenbrowser, einen Objektinspektor und ein Klassenhierarchiediagramm, 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
Grundlagen der Informatik I: T11
98
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
99
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Der Eclipse-Java-Editor
Package
Übersicht
Outline
(Übersicht)
Code
Editor
Tabs für Sichten,
hier: Probleme
Probleme
(Compile-Fehler, Warnungen)
Grundlagen der Informatik I: T11
100
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Eclipse: Anzeige von JavaDoc
Grundlagen der Informatik I: T11
101
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Eclipse: Codevervollständigung
Grundlagen der Informatik I: T11
102
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Eclipse: Inhaltshilfe
Grundlagen der Informatik I: T11
103
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Eclipse: Refactoring
Grundlagen der Informatik I: T11
104
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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“!
Grundlagen der Informatik I: T11
105
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Ansichten der Debugging-Perspektive
schrittweise durch den Code gehen
Die DebugAnsicht zeigt
den Aufrufstack
und die
Zustände aller
Threads,
einschl. der
bereits fertig
ausgeführten
Ansichten
zur Modifikation von
Variablen
und Breakpoints
EditorAnsicht
Grundlagen der Informatik I: T11
106
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
107
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Tastenkürzel Eclipse für Java
Kürzel
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 suchen
Strg-I
Einrückungen anpassen
Strg-O
Outline (Übersicht) einblenden
Strg-T
Klassenhierarchie einblenden
Grundlagen der Informatik I: T11
108
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Tastenkürzel Eclipse für Java
Kürzel
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
Grundlagen der Informatik I: T11
109
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
Grundlagen der Informatik I: T11
110
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Tastenkürzel für den Debugger
• Auch für den Debugger gibt es hilfreiche Tastenkürzel
Kürzel
F11
Effekt
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
Grundlagen der Informatik I: T11
111
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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 OOSprachen 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.
Grundlagen der Informatik I: T11
112
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
Ü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
– http://webtasks.informatik.tu-darmstadt.de/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
Grundlagen der Informatik I: T11
113
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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
– Funktionen höherer Ordnung 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
Grundlagen der Informatik I: T11
114
Dr. G. Rößling
Prof. Dr. M. Mühlhäuser
RBG / Telekooperation
©
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!
Grundlagen der Informatik I: T11
115