Datenstrukturen und Algorithmen

Datenstrukturen und Algorithmen
Prof. Dr.-Ing. H. Ney, G. Leusch, C. Plahl, D. Stein
[email protected]
Einführungsveranstaltungen Informatik – Sommersemester 2006
Human Language Technology and Pattern Recognition
Lehrstuhl für Informatik VI
Computer Science Department
RWTH Aachen University, Germany
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
1
Sommersemester 2006
Übersicht
1 Einführung
4
2 Kaltstart
5
3 Variablen
7
4 Grunddatentypen
9
5 Kontrollstrukturen
5.1 if-then-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Abbruch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
11
12
13
6 Methoden
14
7 Felder (Arrays)
15
8 Objekte/Instanzen
17
9 Reference vs. Value
19
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
2
Sommersemester 2006
10 Pakete
23
11 Rekursion
24
12 Was fehlt noch?
25
13 Literatur
26
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
3
Sommersemester 2006
1
Einführung
Grundkonzepte für Java
◮ einfach
◮ objektorientiert
◮ implizites Speichermanagement (garbage collection)
◮ Write Once, Run Anywhere
Weiterführende Informationen:
◮ http://java.sun.com/reference/api/
◮ Informatik-Bibliothek: Handapparat Programmierung
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
4
Sommersemester 2006
2
Kaltstart
Das erste Java-Programm:
public class HelloWorld {
public static void main (String[] args) {
System.out.println("Hello World");
}
}
◮ Groß- und Kleinschreibung wichtig!
◮ Semikolon am Ende von Anweisungen
◮ Dateiname: Klassenname.java
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
5
Sommersemester 2006
Vorgehensweise:
◮ In Datei schreiben: HelloWorld.java
◮ Kompilieren:
> javac HelloWorld.java
⊲ Erzeugt ein ausführbares Programm (Bytecode)
◮ Ausführen:
> java HelloWorld
Hello World
◮ Oder in einer Entwicklungsumgebung (Eclipse etc.)
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
6
Sommersemester 2006
3
Variablen
public class HelloWithVariables {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "World";
System.out.println(s1 + " " + s2);
s2 = "Aachen";
System.out.println(s1 + " " + s2);
}
}
> javac HelloWithVariables.java
> java HelloWithVariables
Hello World
Hello Aachen
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
7
Sommersemester 2006
public class HelloWithVariables {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "World";
System.out.println(s1 + " " + s2);
s2 = "Aachen";
System.out.println(s1 + " " + s2);
}
}
◮ Deklariere Variablen s1 und s2 vom Typ String
◮ Weise Werte Hello und World zu
◮ Greife dann auf Werte zu
◮ Bei Strings: "+" bedeutet Konkatenation
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
8
Sommersemester 2006
4
Grunddatentypen
public class TypTest {
public static void main(String[] args) {
int i1 = 3;
int i2 = 2;
int i = i1 / i2;
System.out.println("int: " + i1 + "/" + i2 + "=" + i);
// int: 3/2=1
double d1 = 3;
double d2 = 2;
double d = d1 / d2;
System.out.println("double: " + d1 + "/" + d2 + "=" + d);
// double: 3.0/2.0=1.5
boolean b = (23 > 42);
System.out.println("boolean: Ist 23 groesser als 42? " + b);
// boolean: Ist 23 groesser als 42? false
char c = ’X’;
System.out.println("char: " + c);
// char: X
}
}
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
9
Sommersemester 2006
Grunddatentypen:
◮ byte, short, int, long
◮ float, double
⊲+ - * /
◮ char, String
◮ boolean
⊲ == != < <= > >=
⊲ && ||
◮ (void)
Typkonversion (Typecasts):
int i = 17;
double d = (double) i;
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
10
Sommersemester 2006
5
Kontrollstrukturen
5.1
if-then-else
public class GoodMorningWorld {
public static void main(String[] args) {
int hour = 6;
if (hour < 9) {
System.out.println("Good Morning World");
} else {
System.out.println("Good Afternoon World");
}
}
}
◮ if-then-else-Struktur
◮ else-Zweig kann auch weggelassen werden
◮ switch-Struktur
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
11
Sommersemester 2006
5.2
Schleifen
public class HelloWorldSpam {
public static void main(String[] args) {
int i = 0;
while (i < 10) {
System.out.println("Hello World Spam!");
i = i + 1;
}
for (i=0; i < 10; i++) {
System.out.println("Even more Hello World Spam!");
}
}
}
◮ for(init; bedingung; zählen)
◮ while(bedingung) { anweisung }
◮ i = i + 1 kann man auch schreiben als i++
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
12
Sommersemester 2006
5.3 Abbruch
public class HelloWorldSpamFilter {
public static void main(String[] args) {
int i = 0;
while (i < 10) {
System.out.println("Hello World Spam!");
i = i + 1;
if (i == 1) {
break;
}
}
}
}
◮ break
◮ continue
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
13
Sommersemester 2006
6
Methoden
public class HelloWithMethod {
static String getHello(String lang) {
if (lang == "de") {
return "Hallo Welt";
} else {
return "Hello World";
}
}
public static void main(String[] args) {
System.out.println( getHello("de") );
System.out.println( getHello("en") );
}
}
◮ Auch: Prozedur, Funktion, . . .
◮ static: keine Klasseninstanz
◮ String: Rückgabetyp String
◮ public: für alle anderen Klassen sichtbar
◮ void: Kein Rückgabewert
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
14
Sommersemester 2006
7
Felder (Arrays)
public class HelloArray {
public static void main(String[] args) {
String[] planeten = {"Merkur", "Venus", "Erde",
"Mars", "Jupiter", "Saturn",
"Uranus", "Neptun", "Pluto"};
int[] quadrate = new int[9];
int i;
for (i = 0; i < 9; i++) {
System.out.println("Hallo " + planeten[i]);
quadrate[i] = i*i;
}
}
}
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
15
Sommersemester 2006
> java HelloArray
Hallo Merkur
Hallo Venus
[. . . ]
Hallo Pluto
◮ Feld gleicher Typen
◮ Feste Größe bei Initialisierung vorgegeben
◮ Zugriff über variable[index]
◮ Index geht von 0 bis N − 1 !!!
◮ Deklaration sowohl als String[] planeten als auch als String planeten[]
möglich
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
16
Sommersemester 2006
8
Objekte/Instanzen
class HelloClass {
public HelloClass(String lang) {
if (lang == "de") {
helloString = "Hallo Welt";
} else {
helloString = "Hello World";
}
}
public String getHello() {
return helloString;
}
private String helloString;
}
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
17
Sommersemester 2006
public class HelloWithClass {
public static void main(String[] args) {
HelloClass h1 = new HelloClass("de");
HelloClass h2 = new HelloClass("en");
System.out.println(h1.getHello());
System.out.println(h2.getHello());
}
}
◮ Neue Instanz (mit new )
◮ Konstruktor initialisiert Variablen
◮ Methode aufrufen
◮ Punktnotation für Methoden (und Variablen)
◮ Grundsätzlich: Kapselung der Daten (Zugriff nur über Methoden)
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
18
Sommersemester 2006
9 Reference vs. Value
Vorsicht bei Zuweisungen/Parameterübergabe:
class RefTestInt {
public int i;
}
public class ReferenzTest {
private static void aendereI(int i) {
i = 4711;
}
private static void aendereR(RefTestInt r) {
r.i = 4711;
}
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
19
Sommersemester 2006
public static void main(String[] args) {
int i1 = 42;
int i2 = i1;
System.out.println("i2 ist jetzt " + i2);
// 42
i1 = 23;
System.out.println("i2 ist jetzt " + i2);
// 42
aendereI(i2);
System.out.println("i2 ist jetzt " + i2);
// 42
RefTestInt r1 = new RefTestInt(); r1.i = 42;
RefTestInt r2 = r1;
System.out.println("r2.i ist jetzt " + r2.i);
// 42
r1.i = 23;
System.out.println("r2.i ist jetzt " + r2.i);
// 23
aendereR(r2);
System.out.println("r2.i ist jetzt " + r2.i);
// 4711
}
}
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
20
Sommersemester 2006
> java ReferenzTest
i2 ist jetzt 42
i2 ist jetzt 42
i2 ist jetzt 42
r2.i ist jetzt 42
r2.i ist jetzt 23
r2.i ist jetzt 4711
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
21
Sommersemester 2006
Merke:
◮ Grunddatentypen:
⊲ Variable enthält Daten selbst
⊲ Wertübergabe (Call by Value)
⊲ Änderungen in Kopie wirken sich nicht auf Original aus
◮ Komplexe Datentypen:
⊲ Variable enthält Referenz auf Daten
⊲ Daten werden grundsätzlich nur einmal im Speicher abgelegt
⊲ Referenzübergabe (Call by Reference)
⊲ Änderungen in „Kopie“ wirken sich auf Original aus
⊲ Wenn nötig, explizite Kopien anlegen (über entspr. Konstruktor etc.)
⊲ Referenzen entsprechen Pointern (Zeigern) in Modula, Pascal, C, . . .
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
22
Sommersemester 2006
10
Pakete
import java.util.Date;
public class HelloToday {
public static void main(String[] args) {
Date today = new Date();
System.out.println("Hello World. Today is "
+ today.toString());
// Hello World. Today is Mon Apr 10 17:10:03 CEST 2006
}
}
◮ import importiert die Methoden aus einem Paket
◮ mit *: Alle Anweisungen aus dem Paket – Beispiel: import java.util.*
◮ Standardmäßig importiert: java.lang
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
23
Sommersemester 2006
11
Rekursion
public class HelloWorldRecursive {
public static void main(String[] args) {
System.out.println( hello(10) );
}
static String hello(int i) {
if ( i > 0 ) {
return hello(i - 1) + ".";
} else {
return "Hello World";
}
}
}
// Hello World..........
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
24
Sommersemester 2006
12
Was fehlt noch?
◮ Vererbung
◮ Interfaces, Collections
◮ Überladen
◮ Dateiein- und -ausgabe
◮ Kommandozeilenparameter
⇒ Später in Frontalübungen, oder aus Literatur
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
25
Sommersemester 2006
13 Literatur
◮ J. Bishop: Java lernen. 2. Aufl., Addison-Wesley, 2001
◮ J. Bishop: Java Gently. 3rd. ed., Addison-Wesley, 2001
◮ E.-E. Doberkat, S. Dißmann: Einführung in die Objektorientierte Programmierung mit Java, Oldenbourg, 2000
◮ H. Mössenböck: Sprechen Sie Java?, 3. Aufl., dpunkt.verlag, 2005
◮ D. Flanagan: Java in a Nutshell, 4. Aufl., O’Reilly & Associates Inc., 2002
◮ R. Sedgewick: Algorithms in Java, 3rd ed., Addison-Wesley, 2002
Stein, Plahl, Leusch: Datenstrukturen und Algorithmen:
26
Sommersemester 2006