prof dr max m hlh user dr guido r ling n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Prof. Dr. Max Mühlhäuser Dr. Guido Rößling PowerPoint Presentation
Download Presentation
Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

Loading in 2 Seconds...

play fullscreen
1 / 115

Prof. Dr. Max Mühlhäuser Dr. Guido Rößling - PowerPoint PPT Presentation


  • 93 Views
  • Uploaded on

Grundlagen der Informatik I Thema 11: Von Scheme zu Java. Prof. Dr. Max Mühlhäuser Dr. Guido Rößling. Inhaltsübersicht. Allgemeine Unterschiede zwischen Scheme und Java Übersetzung von Java-Programmen (Kurzfassung) Variablen in Java Primitive Datentypen

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Prof. Dr. Max Mühlhäuser Dr. Guido Rößling' - avent


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
prof dr max m hlh user dr guido r ling

Grundlagen der Informatik IThema 11: Von Scheme zu Java

Prof. Dr. Max Mühlhäuser

Dr. Guido Rößling

inhalts bersicht
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
von scheme zu java
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
allgemeine unterschiede
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
abstand vom rechner im funktionalen stil
Abstand vom Rechner im funktionalen Stil
  • (define (fold f n)
  • (lambda (x)
  • (if (empty? x)
  • n
  • (f (first x) ((fold f n) (rest x))))))
  • (definesumlist (fold + 0))
  • (definemultlist (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

allgemeine unterschiede1
Allgemeine Unterschiede
  • Java ist eine objektorientierteSprache
    • 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
ein paar worte zur java lexikalik
Ein paar Worte zur Java-Lexikalik
  • SpezielleSymbole: { } ; . ( )
    • { } 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

(incc2 5)

c2.inc(5);

ein paar worte zur java lexikalik1
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
inhalts bersicht1
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
struktur eines java programms
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 durch Java-Interpreter gestartet und ausgeführt
wie alles anf ngt
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

publicclassCounterTest {

// ...

publicstaticvoidmain(String[] args) {

CounterConsumer cc = newCounterConsumer();

cc.doSomethingWithCounters();

}

// ...

}

CounterTest.java

Java- Compiler

javac CounterTest.java

java CounterTest

Java- Bytecode-Interpreter

java bersetzung
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

Bsp1.class

Datei.java

class Bsp1 {...}

class Bsp2 {...}

class Bsp3 {...}

Bsp2.class

Java Compiler

Bsp3.class

berechnungen durchf hren
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
hilfssystem acm jtf bibliothek
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: Associationfor 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)
genereller aufbau bei nutzung von acm jtf
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 „newMyProgram()“
    • 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
interessante methoden in consoleprogram
Interessante Methoden in ConsoleProgram
  • voidprint(X value)
    • Gibt Wert value aus; X steht dabei für einen beliebigen Typ
  • voidprintln(X value)
    • Gibt Wert value aus und fügt einen Zeilenvorschub an
  • voidprintln()
    • Gibt einen Zeilenvorschub aus
  • voidclear()
    • Löscht das Konsolenfenster
  • voidshowErrorMessage(String message)
    • Zeigt eine Fehlermeldung (in rot) an
  • String readLine(String p) / intreadInt(String p) / double readDouble(String p)
    • Zeigt den Text p an und liest eine Textzeile / int / double ein
beispielprogramm hello world console
Beispielprogramm: Hello World - Console

importacm.program.ConsoleProgram; // Binde "ConsoleProgram" ein

public class HelloConsole extends ConsoleProgram {

publicvoidrun() {

println("hello, world");

}

/* Standard Java entrypoint */

/* This method can be eliminated in most Java environments */

public static void main(String[] args) {

newHelloConsole().start(); // startet Console, ruft "run" auf

}

}

Ausgabefenster:

interaktivit t mit dialogprogram
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“
beispielprogramm hello world dialog
Beispielprogramm: Hello World - Dialog

importacm.program.DialogProgram; // Binde "DialogProgram" ein

public class HelloDialog extends DialogProgram {

publicvoidrun() {

println("hello, world");

}

/* Standard Java entrypoint */

/* This method can be eliminated in most Java environments */

public static void main(String[] args) {

newHelloDialog().start(); // startet Dialog, ruft "run" auf

}

}

Ausgabefenster:

beispielprogramm hello world grafik
Beispielprogramm: Hello World - Grafik

importacm.graphics.GLabel; // Binde GLabel (anzeigbarer Text) ein

importacm.program.GraphicsProgram; // Binde "GraphicsProgram" ein

public class HelloGraphics extends GraphicsProgram {

publicvoidrun() {

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 entrypoint */

/* This method can be eliminated in most Java environments */

public static void main(String[] args) {

newHelloGraphics().start(); //startet Graphics,ruft "run" auf

}

} Ausgabefenster (verkleinert):

inhalts bersicht2
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
variablen in java
Variablen in Java
  • Daten werden Java in der Regel in Variablen gespeichert
    • Insbesondere zur Zuweisung des Ergebnisses von Rechenschritten
  • Von Scheme kennen Sie Variablen als gebundene Namen:
  • In Java erfolgen Zuweisungen mittels "=":

;; provide initial value for counter

(define counter-value 0)

;;increment the counter(set! counter-value (succ counter-value))

// provide initial value for counter

counterValue = 0;

// increment the countercounterValue = counterValue + 1;

erste analyse der unterschiede
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

//provide initial value for counter

int counterValue= 0;

// increment the countercounterValue = counterValue + 1;

;; provide initial value for counter

(define counter-value 0)

;;increment the counter(set! counter-value (+ counter-value 1))

arithmetische operationen
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
variablentyp
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:

intcounter;

deklarationen in java
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)
variablentyp1

counter darf nur ganz-zahligeWerte annehmen

intcounter;

counter = 10;

counter = "hello";

Nur für ganze Zahlen definierte Operationen dürfen verwendet werden.

counter

counter++;

counter.move();

4 Speicherzellen

Variablentyp
variablen zuweisung ausdr cke

size

Auswertungsreihenfolge

delta

Variablen: Zuweisung & Ausdrücke

Ausdruck

size = size + delta;

3

4

1

=+

2

Kontrollfluss

  • Die linke Seite der Zuweisung muss einen Speicherplatz bezeichnen (in Scheme: ein Name in der Umgebung).
  • Die rechte Seite muss ein Ausdrucksein.
  • Ein Ausdruck muss einen Wert ergeben.
inhalts bersicht3
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
primitive datentypen
Primitive Datentypen
  • Java bietet mehrere primitive Datentypen:
    • Wahr/Falsch Werte: booleanmit 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"
primitive datentypen1
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

Scheme bewahrt den Nutzer vor diesen maschinenabhängigen Details.  einfacher zu nutzen, weniger fehleranfällig, aber höhere Laufzeit.

zeichen in java
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:
  • Konvertierbar durch Kommandozeilenbefehl native2ascii
inhalts bersicht4
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
zusammengesetzte ausdr cke
Zusammengesetzte Ausdrücke

Beispiele

double a; inti; 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

boolesche ausdr cke
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 afalseist, sonst false
    • Notation in Java: !a
    • Notation in Scheme: (not a)
zusammengesetzte boolesche ausdr cke
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 falsesind (Java: A || B; Scheme: (or A B))

analog zu and, or in Scheme…

zusammengesetzte boolesche ausdr cke1
Zusammengesetzte boolesche Ausdrücke

Beispiele

booleana, b;inti; charc;

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

nicht strikte operatoren
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
bit operationen
Bit-Operationen

a & b Bitweises Und

a | b Bitweises Oder

a ^ b Bitweises Exklusiv-Oder, nicht gleich

~aBitweise 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.

bit operationen1
Bit-Operationen

Beispiele

  • 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 signifikantestenBits das Vorzeichen von negativ zu positiv. Es gibt fünf Inkrementierungen, bis -1 (nur Einser) erreicht ist.
zuweisungsoperator

Ausdruck

Ausdruck

Ausdruck

Ausdruck

Zuweisungsoperator
  • In Java ist die Zuweisungein 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;

zusammengesetzter zuweisungsoperator
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
un re operatoren
Unäre Operatoren
  • Haben nur einen Operanden
    • Negation: !a (Scheme: (not a))
    • Minus als Zeichen (nicht als binärer Operator): -a
  • Inkrement/Dekrement Operatoren
    • Anders als typische unäre Operatoren haben sie einen Nebeneffekt++a, a++, --a, a--
    • Präfix und Postfix Versionen haben unterschiedliche Effekte

Beispiele

a = 4;

a++; // entspricht: a = a + 1;  a==5

b = a++; // entspricht: b = a; a = a + 1;  a==6, b==5

b =++a; // entspricht: a = a + 1; b = a;  a==7, b==7

b = a--; // entspricht: b = a; a = a – 1;  a==6, b==7

operator priorit ten
Operator-Prioritäten
  • Viele arithmetische Ausdrücke können ohne Klammern geschrieben werden
    • Die Auswertungsregeln entsprechen denen der Schulmathematik

a + b > 27 && b + c < 35 || a < 3

bedeutet

((((a + b) > 27) && ((b + c) < 35)) || (a < 3))

In Scheme:

(or (and (> (+ a b) 27) (< (+ b c) 35)) (< a 3))

operator priorit t und assoziativit t
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-rechtsAssoziativität hat.
      • Der Operator ganz rechts wird zuerst angewendet, wenn der Operator eine rechts-nach-linksAssoziativitä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.
operator priorit t und assoziativit t1

Priorität

Operator Priorität und Assoziativität

Assoziativität

In Scheme wegen Präfix Notation nicht notwendig

inhalts bersicht5
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
aufrufen von funktionen
Aufrufen von Funktionen
  • In Scheme werden oft Funktionen angewendet
    • Dazu wurde einfach der Funktionsname, gefolgt von allen Parametern, in Klammern gesetzt
  • In Java erfolgt der Aufruf durch Angabe des Namens, gefolgt von den Parametern in Klammern (und getrennt mit Komma):
    • Das Semikolon ist nur nötig, wenn der Befehl hier endet, „average“ also nicht in weitere Rechnungen eingeht
    • In der Regel wird das Ergebnis eines Funktionsaufrufes einer Variablen zugewiesen oder in weiteren Rechnungen genutzt

(average -42 50) ;; ergibt 4

average(-42, 50); // ergibt 4

definition von funktionen
Definition von Funktionen
  • In Scheme erledigt definedie Definition von Funktionen:
  • In Java ist die Notation etwas anders:
    • Vor dem Namen der Funktion steht der Ergebnistyp (hier: int)
    • Die Parameter stehen in Klammern, getrennt durch Komma
    • Vor jedem Parameter steht sein Typ
      • Auch wenn mehrere Parameter nacheinander den gleichen Typ haben
    • Geschweifte Klammern begrenzen die Funktion (wie „()“ in Scheme)
    • Der Ergebniswert ist ein Ausdruck nach „return“
      • Methoden ohne Ergebnis haben als Ergebnistyp „void“

(define(average x y)

(/ (+ x y) 2))

intaverage(int x,int y){return (x + y) / 2;}

slide50

Funktionen in Java

;;inc:  number

;;purpose: increases currentVal by 1

(define inc ()

(begin

(set!currentVal (+ currentVal 1))

currentVal))

Formulierung der Effekte (später detaillierter)

/**

* Increases the current value of counter by 1

*/

int inc() {

currentVal = currentVal + 1;

return currentVal;

}

Typ der Rückgabe

Liste der formalen Parameter (hier: leer)

Operationskopf

Explizite Anweisung zur Rückgabe von Werten

Operationsrumpf

(Implementierung)

inhalts bersicht6
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
strings in java
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
wichtige methoden der klasse string
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
    • intcompareTo(String o),intcompareToIgnoreCase(String o) – vergleicht den aktuellen String mit o:
      • Sind beidegleich, 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
    • intindexOf(char c), intindexOf(String o),intindexOf(char c, int s), intindexOf(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
    • intlastIndexOf(char c), intlastIndexOf(String o),intlastIndexOf(char c, int s), intlastIndexOf(String o, int s)
      • Analog zu indexOf, liefert aber die letzte gefundene Position.
wichtige methoden der klasse string1
Wichtige Methoden der Klasse String
  • intlength()
    • Liefert die Länge des Strings
  • String replace(charoldChar, charnewChar)
    • Ersetzt alle Vorkommen von oldChar durch newChar und gibt einen entsprechenden neuen String zurück.
  • booleanstartsWith(String s), booleanendsWith(String s)
    • Liefert true oder false, je nachdem, ob der aktuelle String mit dem String s anfängt bzw. endet oder nicht.
  • String substring(intstartIndex),String substring(intstartIndex, intendIndex)
    • 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 endIndexreicht.
wichtige methoden der klasse string2
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.
vergleichen von strings
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 (!)
stringbuffer und zusammenf gen von strings
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):
    • StringBuffersb = newStringBuffer(256);
    • sb.append("Hello, ").append(givenName).append(" ");
    • sb.append(familyName);
  • Umwandlung in einen String: durch toString()
  • Nutzung des StringBuffers ist deutlich effizienter als „+“
inhalts bersicht7
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
kontrollstrukturen in java
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>

bedingungen if anweisung
Bedingungen: if-Anweisung
  • Die Auswertung von Ausdruck muss vom Typ boolean sein
  • Die erste Anweisung wird nur ausgeführt, wenn der Ausdruck als trueausgewertet 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

<If-Anweisung> =

if (<Ausdruck>) <Anweisung> [else <Anweisung>]

fallunterscheidungen if
Fallunterscheidungen: if
  • In Scheme besteht „if“ immer aus drei Teilen:
    • Bedingung
    • Ausdruck, wenn die Bedingung wahr ist
    • Ausdruck, wenn die Bedingung falsch ist
  • In Java ist die Notation fast identisch (Fokus auf „if“!)

(define (absolute x)

(if (< x 0)

(- x)

x))

int absolute(intx) {if (x < 0)return –x;elsereturnx;}

die ausdruck quivalente von if
Die Ausdruck-Äquivalente von if
  • Anweisung versus Ausdruck
  • In Scheme ist if ein Ausdruck mit 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, entspricht der Wert des Ausdrucks exp1, sonst ist der Wert exp2

(if (< num 0) 100 200)

if(num < 0)

x = 100;

else

x = 200;

x = (num < 0) ? 100 : 200;

äquivalent

fallunterscheidung
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 "Farbenichtidentifizierbar"])

)

switch und break anweisungen
switch- und break-Anweisungen

Dieswitch-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>

switch und break anweisungen1
switch- und break-Anweisungen

publicclassSwitchAnweisung1 {

publicstaticvoidmain(String[] args) {

intfarbeingabe = 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
vergleich von switch und cond
Vergleich von switch und cond
  • Statt mehreren Bedingungen kann in Java nur ein konstanter Ausdruck genutzt werden
  • Auch die zu prüfenden Werte (case) müssen konstant sein
  • switch passt nur in speziellen Fällen dort, wo man in Scheme ein cond genutzt hätte
  • In der Regel entspricht dem cond von Scheme eine Folge von if-Befehlen
  • Da bei return die Methode verlassen wird, können wir hier auch auf „else“ verzichten

int absolute(int x) {

if (x > 0) return x;

else if (x == 0) return 0;

else return –x;

}

(define (absolute x)

(cond [(>x 0) x]

[(= x 0) 0]

[else (- x)]))

semantik der switch anweisung
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
semantik der switch anweisung1
publicclass SwitchAnweisung1 {

publicstaticvoidmain(String[] args) {

intfarbeingabe = 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");

}

}

}

Semantik der switch-Anweisung

Aufruf: javaSwitchAnweisung1liefert:

rot

gelb

Farbe nicht identifizierbar

Nicht was wir

wollten 

semantik der switch anweisung2
publicclass SwitchAnweisung2 {

publicstaticvoidmain(String [] args) {

intfarbeingabe = 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");

}

}

}

Semantik der switch-Anweisung

Beispiel

Aufruf:java SwitchAnweisung2liefert: rot

semantik der switch anweisung3
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
rekursive funktionsaufrufe
Rekursive Funktionsaufrufe
  • In Scheme haben wir in der Regel Rekursion verwendet, um eine Operation auf mehreren Daten anzuwenden
  • Das geht in Java natürlich auch:
  • Für viele Anwendungen werden stattdessen Schleifen verwendet
  • Eine Schleife führt (nach bestimmten Kriterien) Befehle wiederholt aus

(define(sum-until-n n)

(if(<= n 0) 0

(+ n (sum-until-n (- n 1)))

)

)

„Addiere alle Zahlen von 1 bis n"

intsumUntilN(intn) {

if(n <= 0) return 0;

return n + sumUntilN(n- 1);

}

schleifen
Schleifen
  • Die einfachste Schleife wiederholt eine Anweisung eine feste Anzahl mal (engl. „countingloop“)
  • In Java: for-Schleife

<For-Schleife> =

for([<Anweisung> | <Variablen-Deklaration>];

[<Ausdruck>];[<Anweisung>])

<Anweisung>

Ausdruck muss vom Typ booleansein

  • for(inti = start; i <end; i++) // vorwaerts...
  • for(inti = end; i >start; i-=2) // rueckwaerts, Schrittweite 2

intsumUntilN(intn) {

intsum = 0;

for(int i = 1; i <= n; i++) sum += i;

returnsum;

}

„Addiere alle Zahlen von 1 bis n"

schleifen und rekursion
Schleifen und Rekursion

Natürliche Rekursion

(define (factorial1 n)

(if (= n 1) 1 (* n (factorial1 (- n 1))) )

(define (factorial2 n)

(local (

(define(iterproductcounter)

(if(> counter n)

product

(iter (* counterproduct) (+ counter 1))))))

(iter 1 1) )

Rekursion im

Akkumulator-Stil

(define (factorial3 n)

(local

((define product 1)

(define counter 1)

(define (iter)

(if (> counter n) product

(begin

(set! product (* counter product))

(set! counter (+ counter 1))

(iter)))))

(iter)))

Iteration mit Zuweisungen

schleifen und rekursion1
Schleifen und Rekursion

classExample {

publicintfactorial1(intn) {

if(n == 1) { return1;}

else{ returnn * factorial1(n-1); }

}

publicintfactorial2(intn) {

returniter(1, 1, n);

}

private intiter(intproduct, intcounter, intn) {

if(counter > n) { returnproduct; }

else { returniter(counter * product, counter + 1, n); }

}

publicintfactorial3(intn) {

intproduct=1;

for(intcounter = 1; counter <= n; counter = counter + 1) {

product = counter * product;

}

returnproduct;

}

}

Natürliche Rekursion

Lineare Iteration

Iteration mit Zuweisungen

die while schleife
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-Bedingungwahrist

Ausdruck muss vom Typ boolean sein

  • Vorderersten und vor jeder weiteren Ausführung der Anweisung wird die Schleifenbedingung geprüft.
  • Sobald die Bedingung als false ausgewertet wird, endet die Schleife.
  • Es ist nicht sicher, dass der Schleifenkörper überhaupt ausgeführt wird.

<While-Schleife> = while(<Ausdruck>) <Anweisung>

die while schleife beispiel
Die while-Schleife: Beispiel

„Prüfe, ob eine Zahl prim ist"

// Zahl ist groeser als 0

booleanisPrime(intnumber) {

intfactor = 2;

// pruefe alle Faktoren, bis einer die Zahl teilt

while(number % factor != 0) {

factor = factor + 1;

}

returnnumber == factor;

}

Entweder wurde ein Divisor kleiner als number gefunden oder factor wurde erhöht, bis es gleich numberwurde.

wie schreibt man eine while schleife
Wie schreibt man eine while-Schleife?
  • 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
  • Formuliere die Aktionen für den Schleifenkörper, der einen Schritt näher an den Abbruch der Schleife führt.
    • z.B.s = s + i; i++, addiere die Werte
  • Meistens braucht man eine Initialisierungvor der Schleife und etwas Nachbearbeitungnach der Schleife.
schleifen while und for
Schleifen: while und for
  • Im Allgemeinen hat eine while-Schleife die Form
  • Das passt genau für die for-Schleife
    • Die Anwendung mit einer festen Ausführungszahl ist nur ein Spezialfall!

<initialization>;

while (<condition>) {

<core loop body>;

<loop advancement>;

}

for (<initialization>;<condition>; <loopadvancement>)<coreloopbody>

die do while schleife
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 Ausdruckfalse ist - die Auswertung findet nach der Ausführung des Schleifenkörpers statt - bricht die Schleife ab

<Do-Schleife> = do <Anweisung> while(<Ausdruck>)

<Ausdruck> muss vom Typ boolean sein

inhalts bersicht8
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
listen in scheme
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?
felder arrays motivation
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!

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?

arrays
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 = newint[15];

Ein zusammenhängender Speicherbereich mit Platz für 15 Ganzzahlen wird reserviert. Dies erlaubt effizienten Zugriff.

arrays1
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 <arraysize> - 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 a0ist die potentielle Verwendung einer Variablen als Index

int i = 5;

a[i+1] = a[i] + a[i–1];

initialisierung von arrays
Initialisierung von Arrays

int[] scores = newint[]{ 6, 4, 2, 8, 3 };

String[] predators = new String[] {

"lion", "tiger", "shark"};

String[] predators = new String[3];

predators[0] = "lion";

predators[1] = "tiger";

predators[2] = "shark";

Deklariert und definiert automatisch ein Array mit 5 Elementen

äquivalent

referenz typ array
Referenz-Typ „Array“
  • Arrays sind Objekte
    • Werden mit "new" erzeugt (-> mehr in T12…)
    • Werden durch garbagecollection entsorgt
  • Array-Variablen enthalten Referenzen zu Array-Objekten

int[] a;

int[] b = newint[]{ 3, 1, 4 };

a = b; // a und b greifen jetzt

// auf das selbe Array zu!

  • Unterschiede zu anderen Referenz-Typen:
    • new-Operator benutzt keinen „Konstruktor"
    • Keine Vererbung zwischen Array Typen

3

1

4

b

a

mehrdimensionale arrays
Mehrdimensionale Arrays
  • Arrays mit Arrays als Elementen
    • Deklaration: int[][] table;
    • Erzeugung:

Keine Dimension spezifiziert. Vorteil: effiziente Speicherung von nicht-rechteckigen Strukturen  dreieckige Matrix

  • table = new int[3][];
  • table[1] = new int[2];

oder

table = newint[3][2];

0

0

0

0

0

0

0

0

0

0

  • Zugriff: table[1][0] = 42;
mehrdimensionale arrays1

1

1

1

1

3

4

2

3

6

1

1

4

1

Mehrdimensionale Arrays

intpascal[][] = newint[][] { { 1 }, { 1, 2, 1}, { 1, 3, 3, 1}, { 1, 4, 6, 4, 1} }

pascal[3][1]

mehrdimensionale arrays2
Mehrdimensionale Arrays

table.length // 3

table[0].length // NullPointerException

table[1].length // 2

table[1][2] // IndexOutOfBoundsException

table

42

0

arrays darstellung
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
arrays darstellung1
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!]
inhalts bersicht9
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
kommentierung von java elementen
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
sonderformate
Sonderformate
  • Es gibt zahlreiche Sonderbefehle
    • Fangen immer mit „@“ an
  • Diese gehören in eine eigene Zeile des Kommentars
    • „*“ am Anfang der Zeile nicht vergessen 
  • @paramx text
    • Kommentar „text“ zu Parameter „x“
  • @returntext
    • Kommentiert, was diese Methode zurückgibt
    • Natürlich nur sinnvoll, wenn die Methode nicht void ist!
  • @authortext
    • Autorangabe, oft in Form „Name <email>“
sonderformate ii
Sonderformate II
  • @throwstype text
    • Beschreibt das (mögliche) Auftreten einer Exception ( T18) mit Angabe von Typ und „wann / warum“ das passieren kann
  • @versiondouble
    • Angabe der Versionsnummer
  • @sincetext
    • 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: @seepackagenamen.Klasse#Methode
    • Methoden mit Parameter: Angabe mit Typ der Parameter
      • Z.B. als m(int, String, double)
beispiel
Beispiel

/**

* Thismethod will sortthearraypassed in, thus

* changingitselements.

* Usesquicksort(array, 0, array.length-1) forsorting.

*

* @paramarraythearraytobesorted

* @throwsIllegalArgumentExceptionifthearrayis null

* @authorGuido Roesslingroessling@acm.org

* @version0.2

* @see#quicksort(array, int, int)

*/

publicvoidquicksort(int[] array) { /* … */ }

inhalts bersicht10
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
integrierte entwicklungsumgebung
Integrierte Entwicklungsumgebung
  • Eine integrierte Entwicklungsumgebung(integrateddevelopmentenvironment, 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
der eclipse java editor
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 Übersetzungab
    • 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
der eclipse java editor1
Der Eclipse-Java-Editor

Package Übersicht

Outline (Übersicht)

Code Editor

Tabs für Sichten, hier: Probleme

Probleme(Compile-Fehler, Warnungen)

debugging mit eclipse
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“!
ansichten der debugging perspektive
Ansichten der Debugging-Perspektive

schrittweise durch den Code gehen

Die Debug-Ansicht zeigt den Aufrufstack und die Zustände aller Threads, einschl. der bereits fertig ausgeführten

Ansichten zur Modifi-kation von Variablen und Break-points

Editor-Ansicht

wichtige tastenk rzel f r eclipse
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
code refactoring
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
tastenk rzel f r den debugger
Tastenkürzel für den Debugger
  • Auch für den Debugger gibt es hilfreiche Tastenkürzel
zusammenfassung
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.
bungsm glichkeiten
Ü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
in beiden stilen programmieren
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
in beiden stilen programmieren1
InbeidenStilenprogrammieren
  • 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!