Einführung in die Java- Programmierung

Einführung in die JavaProgrammierung
Dr. Volker Riediger
Der hat die früher
handschriftlichen
Folien lesbar
gemacht.
Tassilo Horn
riediger|[email protected]
WiSe 2012/13
1
Heutige Themen
●
Hello World! Unser erstes Programm
●
Datentypen
●
●
Zahlen, Wahrheitswerte, Zeichenketten
Variablen
●
Deklarationen, Zuweisungen
●
Ausdrücke & Operationen
●
Ein- und Ausgabe
●
Verzweigungen
●
Häufige Fehler
2
Demo: HelloWorld.java
●
Ein Java-Projekt in Eclipse anlegen
1.File > New > Java Project
2.Projektname angeben
3.Finish drücken
●
Eine Programm im Projekt anlegen
1.New > Class
2.Klassenname angeben
3.[x] bei public static void main(String[] args)
4.Finish
3
Anatomie eines Java-Programms
●
Java-Programme bestehen aus Klassen
●
Klassen- und Dateinamen korrespondieren:
Klasse HelloWorld ==> HelloWorld.java
●
●
●
●
Klassen enthalten Methoden (Funktionen,
Prozeduren)
Methoden enthalten die eigentlichen
Anweisungen
Die Programmausführung beginnt bei der
Methode main()
Fürs erste, ignoriert die Schlüsselworte public,
static, void
4
Die drei Schritte der JavaProgrammierung
5
Zahlen
●
●
Aus der Mathematik kennt ihr die
●
natürliche Zahlen: N
●
ganze Zahlen: Z
●
rationale Zahlen: Q
●
reelle Zahlen: R
Problem: Diese Mengen sind unendlich und
Zahlen beliebig groß
●
Extremfall: Irrationale Zahlen (z.B. PI) können mit
endlichem Speicherplatz nicht repräsentiert
werden
6
Datentypen in Java
Typ
int
Wertebereich
ganze Zahlen, 32bit, von
-2^31 bis 2^31-1
long
ganze Zahlen, 64bit, von
-2^63 bis 2^63-1
double Fließkommazahlen,
64bit, ~16 Dezimalstellen
genau
boolean Wahrheitswerte: true
oder false
String
Zeichenketten
Standardwert
Beispiele
0
-100, 17, 9999
0
1000000000000l,
-13l
0.0001, -117.3,
3.14159
0.0
false
false, true
“Hallo Welt!”
7
Variablen in der Mathematik
●
In der Mathematik haben Variablen
●
einen Namen
●
eine Grundmenge
●
einen evtl. unbekannten, aber nicht
veränderbaren Wert
8
Variablen in der Mathematik
●
Mathematische Variablen sind nicht
änderbar, sondern sie sind Namen für
eine Zahl
9
Variablen in Java
●
Variablen in Programmen haben
●
●
●
●
einen Namen
einen während der Lebensdauer festen
Datentyp
einen über die Zeit veränderbaren Wert
Wichtig: Vor der Benutzung muss eine
Variable deklariert werden!
10
Variablendeklaration
●
Eine Variablendeklaration besteht aus
●
dem Datentyp (z.B. int, long, oder double)
●
dem Namen
●
optional einer initialen Wertzuweisung
int x;
// x hat Standardwert 0
long y = 17;
●
●
Durch eine Deklaration wird Speicherplatz für genau
einen Wert dieses Typs reserviert
In Programmen sind Variablen Namen für einen
Speicherplatz
11
Zuweisungen
●
●
Der Wert einer Variable kann durch eine
Zuweisung (=) verändert werden
Erst wird der Wert der rechten Seite berechnet und
dann der Variablen auf der linken Seite zugewiesen
int x = 17; // Deklaration & Zuweisung
x = 18;
// Erneute Zuweisung
int x = 19: // Fehler, Typ darf nicht
// erneut angegeben werden!
12
Datentypen
13
Ausdrücke
●
Ein Ausdruck ist ein Literal, eine Variable oder
eine Folge von Operationen auf
Literalen/Ausdrücken, die ein Ergebnis liefern
int x = 11;
// Deklaration
17
// Ausdruck: Literal
x
// Ausdruck: Variable
x + 19
// Ausdruck: Operation
14
Einfache Ausgabe
●
Zur Ausgabe beliebiger Werte auf der
Standardausgabe (System.out) gibt es in Java
die Methoden:
// Wert von <Ausdruck> ausgeben
System.out.print(<Ausdruck>)
// Wert von <Ausdruck> gefolgt von
// einem Zeilenumbruch ausgeben
System.out.println(<Ausdruck>)
15
Operationen auf Zahlen
●
Auf allen Zahlentypen definiert: Addition,
Subtraktion, Multiplikation und Division
17 + 4
// 21 (int)
17 + 4l
// 21l (long)
11 – 21
// -10 (int)
3 * 10
// 30 (int)
10 / 3
// 3 (int, Ganzzahldivision)
10.0 / 3
// 3.33333333333335 (double)
16
Operationen auf Zahlen
●
Auf Zahlen (int, long, double) definiert:
Rest einer Division (Modulo)
17 % 4
// 1 (int)
-4 % 3
// -1 (int)
18 % 4l
// 2 (long)
-18l % 4
// -2 (long)
18.5 % 4
// 2.5 (double)
-16.5 % 2.5
// -1.5 (double)
17
Automatische Konvertierung
●
●
Der „größte“ Zahlentyp in einem Ausdruck
bestimmt den Typ des Wertes
Regel: double > long > int
1 + 1
// int + int => int
1 + 1l
// int + long => long
1.0 + 1
// double + int => double
3 / 2
// int / int => int
3.0 / 2
// double / int => double
18
Demo: ZahlOps.java
●
Aufgabe: Lasst uns ein Programm
schreiben, das
●
●
●
jeweils 2 Variablen der Typen int, long und
double definiert
für verschiedene Kombinationen der
Variablen die Zahlenoperationen benutzt
die Werte der Ausdrücke auf der Konsole
ausgibt
19
Operationen auf Zeichenketten
●
Auf Zeichenketten (String) definiert:
Verkettung (Konkatenation)
"Hallo" + " Welt"
●
// "Hallo Welt"
Werte anderer Typen werden automatisch
in String konvertiert
"Bitte " + 3 + " Bier!" // "Bitte 3 Bier"
20
Operationen auf
Wahrheitswerten
●
Für Wahrheitswerte (boolean) definiert:
NOT (!), AND (&&) und OR (||)
// NOT:
!true // false
!false // true
21
Vergleichsoperationen
●
Für alle Zahlen definiert, liefern einen
Wahrheitswert (boolean):
22
Vergleichsoperationen für
Strings
●
●
Vergleich zweier Zeichenketten:
●
“Hallo“.equals(“Hallo“)
==> true
●
“hallo“.equals(“Hallo“)
==> false
Vergleich ohne Berücksichtigung der
Groß-/Kleinschreibung
●
“Hallo“.equalsIgnoreCase(“Hallo“)
==> true
●
“hallo“.equalsIgnoreCase(“Hallo“)
==> true
●
“hi!“.equalsIgnoreCase(“Hallo“)
==> false
23
Nochmal Zuweisungen & Ausdrücke
●
●
Der Ausdruck auf der rechten Seite einer
Zuweisung darf die Variable der linken
Seite enthalten
Der Ausdruck wird dann mit dem
aktuellen (alten) Wert berechnet und
danach als neuer Wert zugewiesen
x = 2;
x = x * x; // x = 2 * 2
24
Zuweisungskurzformen
int x = 10;
x += 5;
// x = x + 5: ?
x -= 7;
// x = x – 7: ?
x *= 2;
// x = x * 2: ?
x /= 2;
// x = x / 2: ?
x++;
// x = x + 1: ?
x--;
// x = x – 1: ?
25
Demo: ZahlOps.java
●
Aufgabe: Lasst uns ZahlOps.java
erweitern, um
●
Operationen auf Zeichenketten
●
Operationen auf Wahrheitswerten
●
Vergleichsoperationen
●
Zuweisungskurzformen
26
Operatorpräzedenzen
●
●
●
Java kennt die üblichen Rechenregeln wie
“Punkt- vor Strichrechnung”
Die Auswertung von binären Operatoren ist
linksassoziativ (von links nach rechts)
Ratschlag: Macht trotzdem durch
Klammerung die Reihenfolge deutlich
1 + 2 * 3
// 1 + (2 * 3) ==> 7
2 * 2 – 9 / –3
// (2 * 2) – (9 / –3)
// ==> 7
27
Ein- und Ausgabe mit JConsole
●
JConsole ermöglich die einfache Ein- und Ausgabe von Zahlen und
Strings:
// JConsole starten
JConsole.start();
// Eingabe (Benutzer fragen)
int i = JConsole.readInt(“Ein int: “);
long l = JConsole.readLong(“Ein long: “);
double d = JConsole.readDouble(“Ein double: “);
String s = JConsole.readString(“Ein String: “);
// Ausgabe
System.out.println(“i = “ + i + “, l = “ + l
“, d = “ + d + “, s = “ + s);
28
Demo: Greeting.java
●
●
Aufgabe: Lasst uns ein Programm
schreiben, welches
●
den Benutzer nach seinem Namen fragt
●
und ihn dann persönlich begrüßt
Vorüberlegung: EVA
●
Was ist die Eingabe?
●
Wie erfolgt die Verarbeitung?
●
Was ist die gewünschte Ausgabe?
29
Mathematische Funktionen
●
Die in Java enthaltene Klasse Math enthält
mathematische Konstanten und viele Funktionen
Math.PI
// Approx. PI
Math.E
// Approx. e (Basis des nat. Log.)
Math.sqrt(9)
// Wurzel: 3.0
Math.round(1.5)
// Runden: 2
Math.round(1.49) // Runden: 1
Math.pow(2, 3)
// Exponent: 8
Math.abs(-18)
// Absolutwert: 18
30
Methoden-Signaturen lesen
●
Eine Methoden-Signatur legt
●
den Datentyp des Ausgabewerts (A),
●
den Methodennamen (N)
●
und die Datentypen der Eingabewerte (E) fest:
// A: double, N: sqrt, E: double
double sqrt(double a)
// A: double, N: pow, E: double, double
double pow(double a, double b)
31
Demo: Pythagoras.java
●
Aufgabe: Lasst uns ein
Programm schreiben, welches
●
●
die Länge der Katheten a und b
vom Benutzer abfragt und dann
die Länge der Hypotenuse
berechnet und ausgibt
2
2
2
a + b =c
2
2
⇒ c=√ a + b
32
Demo: QuadGleichung.java
●
Aufgabe: Lasst uns ein Programm schreiben,
welches eine quadratische Gleichung löst.
(Nullstellenbestimmung der Parabel)
2
ax + bx+ c=0, (a≠0)
Lösung mit p−q−Formel :
b
c
x + px+ q=0, p= , q=
a
a
2
p
p
x=− ±√ D , D=( ) −q
2
2
2
33
Demo: QuadGleichung.java
●
Eine quadratische Gleichung kann zwei,
eine, oder gar keine reelle Lösung haben,
je nach Wert der Diskriminante D.
●
Statt
●
brauchen wir:
tue dies
tue das
tue jenes
2 Lsg.
...
berechne D
eine Lsg.
keine Lsg.
34
Verzweigungen
●
Für Fallunterscheidungen gibt es die ifAnweisung:
if (<Test-Ausdruck>) {
// Anweisungen für true
} else {
// Anweisungen für false
// (der else-Teil ist optional)
}
35
Verzweigungen
●
Beispiel: Was wird ausgegeben?
if (1 < 2) {
System.out.println("Math works!");
} else {
System.out.println("Math broken!");
}
36
Verzweigungen
●
Beispiel: Was wird ausgegeben?
if ((1 >= 2) || (7 % 4 == 3)) {
System.out.println("Ja!");
} else {
System.out.println("Nein!");
}
37
Verzweigungen
●
Beispiel: Was wird ausgegeben?
if (!((9 <= 10) && (8 > 4))) {
System.out.println("Ja!");
}
System.out.println("Fertig");
38
Blöcke
●
●
Eine von { } eingeschlossene Sequenz von
Anweisungen bezeichnet man als einen Block
Variablen, die in einen Block deklariert wurden,
sind nur in diesem Block sichtbar
int x = 10; int y = 5;
if (x > y) {
int z = x + y;
}
System.out.println(z); // Fehler!
39
Demo: QuadGleichung.java
●
Aufgabe: Lasst uns ein Programm schreiben,
welches eine quadratische Gleichung löst.
(Nullstellenbestimmung der Parabel)
2
ax + bx+ c=0, (a≠0)
Lösung mit p−q−Formel :
b
c
x + px+ q=0, p= , q=
a
a
2
p
p
x=− ±√ D , D=( ) −q
2
2
2
40
Fehler & Fallstricke
●
Viele Fehler im Programm werden schon
beim Kompilieren gefunden und in Eclipse
rot unterkringelt
●
●
Syntaxfehler, Datentypfehler, etc.
Wenn man mit der Maus auf die
Unterkringelung zeigt, dann wird eine
genaue Fehlermeldung angezeigt
41
Syntaxfehler
●
<something> cannot be resolved
●
Ihr versucht auf eine nicht deklarierte
Variable, Klasse oder Methode zuzugreifen
int x1 = 10, x2 = 20;
x = x1 + x2;
42
Syntaxfehler
●
Duplicate variable <something>
●
Ihr versucht eine schon existierende Variable
nochmal zu deklarieren
int x1 = 10, x2 = 20;
int x1 = x1 + x2;
43
Typfehler
●
The operator <x> is undefned for the
argument type(s) boolean, int
●
Ihr wendet einen Operator auf falsche Typen
an
int a = 10, b = 20, c = 30;
if (a < b < c) {
// irgendwas
}
44
Typfehler
●
Type mismatch: cannot convert from <x> to <y>
●
●
In einer Zuweisung ist der Typ der Variable (x) „kleiner“ als
der des Werts des zugewiesenen Ausdrucks
Ihr verwendet eine Zuweisung (=) und wollt eigentlich
einen Vergleich (==) machen
long a = 1;
int b = a + 1;
if (a = 2) {
;; irgendwas
}
45
„Böse“ Fehler
●
Manche Fehler werden nicht vom
Compiler erkannt, sondern sie drücken
sich nur in (aus Sicht des
Programmierers) falschen Ergebnissen
aus
●
●
Ohne Erfahrung schwer zu finden
Z.B. Typkonvertierungen, Überläufe,
Rundungsfehler
46
Demo: BoeseFehler.java
●
●
●
Bei Zuweisungen wird zuerst der Wert des
Ausdrucks auf der rechten Seite
berechnet und erst danach der Variable
auf der linken Seite zugewiesen und ggf.
konvertiert
Zahlen können nicht beliebig groß sein:
siehe auch BigInteger, BigDecimal
Gleitkommazahlen sind nicht immer
genau
47