Upload
gotthold-stucker
View
110
Download
0
Embed Size (px)
Citation preview
Telecooperation/RBG
Technische Universität Darmstadt
Copyrighted material; for TUD student use only
Grundlagen der Informatik IThema 11: Von Scheme zu Java
Prof. Dr. Max MühlhäuserDr. Guido Rößling
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
2
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
3
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
4
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Abstand vom Rechner im funktionalen Stil
5
(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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
6
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
7
(inc c2 5) c2.inc(5);
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
8
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
9
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
10
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
11
public class CounterTest { // ... public static void main(String[] args) { CounterConsumer cc = new CounterConsumer(); cc.doSomethingWithCounters(); } // ...} CounterTest.java
Java- Compiler
Java- Bytecode-Interpreter
javac CounterTest.java
java CounterTest
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
12
Java C
om
pile
rBsp1.class
Bsp2.class
Bsp3.class
class Bsp1 {...}class Bsp2 {...}class Bsp3 {...}
Datei.java
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
13
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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)
14
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
15
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
ein16
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Beispielprogramm: Hello World - Console
import acm.program.ConsoleProgram; // Binde "ConsoleProgram" einpublic 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:
17
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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“
18
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Beispielprogramm: Hello World - Dialogimport acm.program.DialogProgram; // Binde "DialogProgram" einpublic 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:
19
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Beispielprogramm: Hello World - Grafikimport acm.graphics.GLabel; // Binde GLabel (anzeigbarer Text) einimport acm.program.GraphicsProgram; // Binde "GraphicsProgram" einpublic 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):
20
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
21
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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 "=":
22
;; provide initial value for counter(define counter-value 0);; increment the counter(set! counter-value (succ counter-value))
// provide initial value for countercounterValue = 0;// increment the countercounterValue = counterValue + 1;
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Erste Analyse der Unterschiede
• 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
23
;; provide initial value for counter(define counter-value 0);; increment the counter(set! counter-value (+ counter-value 1))
// provide initial value for counterint counterValue = 0;// increment the countercounterValue = counterValue + 1;
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
24
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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; 25
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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)
26
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Variablentyp
27
counter darf nur ganz-zahlige Werte annehmen
counter = 10;counter = "hello";
Nur für ganze Zahlen definierte Operationen dürfen verwendet werden.
counter++;counter.move();
int counter;int counter;
4 Speicherzellen
counter
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Variablen: Zuweisung & Ausdrücke
28
1
size = size + delta;
Ausdruck
• 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.
23
4
deltasize
= +
Kontrollfluss Auswertungsreihenfolge
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
29
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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"
30
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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 768 32 767 2 Bytes (16 Bit)
int -2 147 483 648
2 147 483 647
4 Bytes (32 Bit)
long -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)
boolean false true 1 Bit
31
Scheme bewahrt den Nutzer vor diesen maschinenabhängigen Details. einfacher zu nutzen, weniger fehleranfällig, aber höhere Laufzeit.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
32
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Zusammengesetzte Ausdrücke
Beispiele
33
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 == -5 * (2 + 3) == -5 *5 == -25
b = true; // b == true
b = i > 0; // - 25 > 0 == false b == false
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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)
34
a !a
false true
true false
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Zusammengesetzte boolesche Ausdrücke
• Logische Operatoren ermöglichen die Zusammensetzung von einzelnen booleschen Werten
• Aus der Logik bekannte Operatoren:– logisches Und (AB): ergibt nur true, wenn A und B true sind (Java: A && B; Scheme: (and A B))
– logisches Oder (AB): ergibt nur false, wenn A und B false sind (Java: A || B; Scheme: (or A B))
35
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…
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Zusammengesetzte boolesche Ausdrücke
36
Beispieleboolean 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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
37
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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. 38
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Bit-Operationen
• short i = 5 i = 0000 0000 0000 0101short j = 3 j = 0000 0000 0000 0011
• i & j = 0000 0000 0000 0001 i & j == 1i | j = 0000 0000 0000 0111 i | j == 7i << 1 = 0000 0000 0000 1010 i << 1 == 10i >> 1 = 0000 0000 0000 0010 i >> 1 == 2~i = 1111 1111 1111 1010 ~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.
39
Beispiele
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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.
40
a = b = c = 42;
Ausdruck
Ausdruck
Ausdruck
Ausdruck
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
41
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
42
a = 4; a++; // entspricht: a = a + 1; a==5b = a++; // entspricht: b = a; a = a + 1; a==6, b==5b = ++a; // entspricht: a = a + 1; b = a; a==7, b==7b = a--; // entspricht: b = a; a = a – 1; a==6, b==7
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Operator-Prioritäten• Viele arithmetische Ausdrücke können ohne
Klammern geschrieben werden– Die Auswertungsregeln entsprechen denen der
Schulmathematik
43
a + b > 27 && b + c < 35 || a < 3
((((a + b) > 27) && ((b + c) < 35)) || (a < 3))
bedeutet
(or (and (> (+ a b) 27) (< (+ b c) 35)) (< a 3))
In Scheme:
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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.
44
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Operator Priorität und Assoziativität
45
Unäre Operatoren ++, --, -, ~, ! rechts
Multiplikation / Division / Rest *, /, % linksAddition/ Subtraktion +, - linksShift <<, >> linksVergleich <, >, <=, >= linksGleichheit ==, != linksbitweises und & linksbitweises xor ^ linksbitweises oder | linkslogisches und && linkslogisches oder || linksBedingungsoperator ? : recht
sZuweisung =, +=, -=,
*=, …rechts
Pri
ori
tät
Assoziativität
In Scheme wegen Präfix Notation nicht notwendig
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
46
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
47
(average -42 50) ;; ergibt 4
average(-42, 50); // ergibt 4
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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“
48
(define (average x y) (/ (+ x y) 2))
int average(int x, int y) { return (x + y) / 2;}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11 49
Funktionen in Java
Operationskopf
Operationsrumpf(Implementierung)
Explizite Anweisung zur Rückgabe von
Werten
/** * Increases the current value of counter by 1 */
int inc() {
currentVal = currentVal + 1; return currentVal;}
Liste der formalen Parameter (hier:
leer)
Formulierung der Effekte
(später detaillierter)
;;inc: number;;effect: increases currentVal by 1 (define inc () (begin (set! currentVal (+ currentVal 1)) currentVal))
Typ der Rückgabe
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
50
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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:
51
<Kontrollanweisung> = <If-Anweisung> | <Switch-Anweisung> |
<Return-Anweisung> | <Break-Anweisung> |<While-Schleife> | <Do-Schleife> | <For-Schleife>
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Bedingungen: if-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
52
<If-Anweisung> = if (<Ausdruck>) <Anweisung> [else <Anweisung>]
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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“!)
53
(define (absolute x) (if (< x 0) (- x) x))
int absolute(int x) { if (x < 0) return –x; else return x;}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
54
x = (num < 0) ? 100 : 200;x = (num < 0) ? 100 : 200;
if (num < 0) x = 100; else x = 200;
if (num < 0) x = 100; else x = 200; äquivalent
(if (< num 0) 100 200)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Fallunterscheidung
55
• 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"]) )
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
switch- und break-Anweisungen
56
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>
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
switch- und break-Anweisungen
57
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
58
(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;}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
59
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Semantik der switch-Anweisung
60
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 wirwollten
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Semantik der switch-Anweisung
61
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");
break; case 2: System.out.println("gelb"); break; default: System.out.println(
"Farbe nicht identifizierbar");
} } }
Beispiel
Aufruf: java SwitchAnweisung2 liefert: rot
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
62
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
63
(define (sum-until-n n) (if (<= n 0) 0 (+ n (sum-until-n (- n 1))) ))
int sumUntilN(int n) { if (n <= 0) return 0; return n + sumUntilN(n - 1);}
„Addiere alle Zahlen von 1 bis n"
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Schleifen• Die einfachste Schleife wiederholt eine Anweisung
eine feste Anzahl mal (engl. „counting loop“)
• In Java: for-Schleife
64
<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"
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Schleifen und Rekursion
65
(define (factorial1 n) (if (= n 1) 1 (* n (factorial1 (- n 1))) )
(define (factorial2 n) (local ( (define (iter product counter) (if (> counter n) 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)))
Rekursion im Akkumulator-Stil
Iteration mit Zuweisungen
Natürliche Rekursion
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Schleifen und Rekursion
66
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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.
67
<While-Schleife> = while (<Ausdruck>) <Anweisung>
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Die while-Schleife: Beispiel
68
Entweder wurde ein Divisor kleiner als number gefunden oder factor wurde erhöht, bis es gleich number wurde.
// Zahl ist groeser als 0boolean isPrime(int number) { int factor = 2; // pruefe alle Faktoren, bis einer die Zahl teilt while (number % factor != 0) { factor = factor + 1; } return number == factor;}
„Prüfe, ob eine Zahl prim ist"
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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.69
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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!
70
<initialization>;while (<condition>) { <core loop body>;
<loop advancement>;}
for (<initialization>; <condition>; <loop advancement>) <core loop body>
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
71
<Do-Schleife> = do <Anweisung> while (<Ausdruck>)
<Ausdruck> muss vom Typ boolean sein
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
72
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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?73
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Felder / Arrays: Motivation
• Verwendung vieler Variablen (a1, a2, …) geht nicht– Anzahl der Elemente wäre fest– Mühsame Vergleicheif (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!
74
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?
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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 Ganzzahlenint[] scores = new int[15];
75
Ein zusammenhängender Speicherbereich mit Platz für 15 ganzen Zahlen wird bereit gestellt. Dies erlaubt effizienten Zugriff.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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 Indexint i = 5;a[i+1] = a[i] + a[i–1];
76
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Initialisierung von Arrays
77
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
Deklariert und definiert automatisch ein Array mit 5 Elementen
äquivalentäquivalent
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Referenz-Typ „Array“• Arrays sind Objekte
– Werden mit "new" erzeugt (-> mehr in T12…)– Werden durch garbage collection entsorgt
• Array-Variablen enthalten Referenzen zu Array-Objektenint[] 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
78
3 1 4
b a
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Mehrdimensionale Arrays
• Arrays mit Arrays als Elementen– Deklaration: int[][] table;– Erzeugung:
79
table = new int[3][2]; table = new int[3][]; table[1] = new int[2];oder
0
00
0
0
0 0
0
0 0
Keine Dimension spezifiziert. Vorteil:
effiziente Speicherung von nicht-rechteckigen Strukturen dreieckige
Matrix
– Zugriff: table[1][0] = 42;
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Mehrdimensionale Arrays
int pascal[][] = new int[][] { { 1 },
{ 1, 2, 1}, { 1, 3, 3, 1}, { 1, 4, 6, 4,
1} }
80
pascal[3][1]
pascal[3][1]
1 1
2
1
3
1 3
1
1
4
6
4
1
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Mehrdimensionale Arrays
table.length // 3table[0].length // NullPointerExceptiontable[1].length // 2table[1][2] // IndexOutOfBoundsException
81
042
table
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
82
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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!]
83
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
84
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
85
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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>“
86
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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) 87
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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) { /* … */ }
88
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
89
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
90
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
91
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Der Eclipse-Java-Editor
92
Outline (Übersich
t)
Probleme(Compile-Fehler,
Warnungen)
Tabs für Sichten, hier:
Probleme
Code Edito
r
Package Übersich
t
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Eclipse: Anzeige von JavaDoc
93
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Eclipse: Codevervollständigung
94
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Eclipse: Inhaltshilfe
95
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Eclipse: Refactoring
96
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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“!
97
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Ansichten der Debugging-Perspektive
98
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
schrittweise durch den Code gehen
Editor-Ansicht
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
99
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Tastenkürzel Eclipse für JavaKü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 suche
Strg-I Einrückungen anpassen
Strg-O Outline (Übersicht) einblenden
Strg-T Klassenhierarchie einblenden100
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
101
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Code Refactoring
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
102
• 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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Tastenkürzel für den Debugger
• Auch für den Debugger gibt es hilfreiche Tastenkürzel
103
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
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
• 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
Inhaltsübersicht
104
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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.
105
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
Ü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
106
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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
107
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T11
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!
108