Einführung in die Java-Programmierung - Dr. Volker Riediger Tassilo Horn riediger
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Einführung in die Java-
Programmierung
Der hat die früher
handschriftlichen
Folien lesbar
Dr. Volker Riediger gemacht.
Tassilo Horn
riediger|horn@uni-koblenz.de
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
3Anatomie 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 4Die drei Schritte der Java-
Programmierung
5Zahlen
● 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 6Datentypen in Java
Typ Wertebereich Standardwert Beispiele
int ganze Zahlen, 32bit, von 0 -100, 17, 9999
-2^31 bis 2^31-1
long ganze Zahlen, 64bit, von 0 1000000000000l,
-2^63 bis 2^63-1 -13l
double Fließkommazahlen, 0.0 0.0001, -117.3,
64bit, ~16 Dezimalstellen 3.14159
genau
boolean Wahrheitswerte: true false false, true
oder false
String Zeichenketten “Hallo Welt!”
7Variablen in der Mathematik
● In der Mathematik haben Variablen
● einen Namen
● eine Grundmenge
● einen evtl. unbekannten, aber nicht
veränderbaren Wert
8Variablen in der Mathematik
● Mathematische Variablen sind nicht
änderbar, sondern sie sind Namen für
eine Zahl
9Variablen 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!
10Variablendeklaration
● 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 11Zuweisungen
● 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!
12Datentypen
13Ausdrü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
14Einfache Ausgabe
● Zur Ausgabe beliebiger Werte auf der
Standardausgabe (System.out) gibt es in Java
die Methoden:
// Wert von ausgeben
System.out.print()
// Wert von gefolgt von
// einem Zeilenumbruch ausgeben
System.out.println()
15Operationen 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)
16Operationen 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)
17Automatische 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
18Demo: 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
19Operationen 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"
20Operationen auf
Wahrheitswerten
● Für Wahrheitswerte (boolean) definiert:
NOT (!), AND (&&) und OR (||)
// NOT:
!true // false
!false // true
21Vergleichsoperationen
● Für alle Zahlen definiert, liefern einen
Wahrheitswert (boolean):
22Vergleichsoperationen 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
23Nochmal 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
24Zuweisungskurzformen
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: ?
25Demo: ZahlOps.java
● Aufgabe: Lasst uns ZahlOps.java
erweitern, um
● Operationen auf Zeichenketten
● Operationen auf Wahrheitswerten
● Vergleichsoperationen
● Zuweisungskurzformen
26Operatorprä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 27Ein- 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);
28Demo: 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?
29Mathematische 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 30Methoden-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)
31Demo: 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
⇒ c=√ a + b
2 2
32Demo: 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 :
2 b c
x + px+ q=0, p= , q=
a a
2
p p
x=− ±√ D , D=( ) −q
2 2
33Demo: QuadGleichung.java
● Eine quadratische Gleichung kann zwei,
eine, oder gar keine reelle Lösung haben,
je nach Wert der Diskriminante D.
● Statt tue dies tue das tue jenes
● brauchen wir:
2 Lsg.
... berechne D eine Lsg.
keine Lsg.
34Verzweigungen
● Für Fallunterscheidungen gibt es die if-
Anweisung:
if () {
// Anweisungen für true
} else {
// Anweisungen für false
// (der else-Teil ist optional)
}
35Verzweigungen
● Beispiel: Was wird ausgegeben?
if (1 < 2) {
System.out.println("Math works!");
} else {
System.out.println("Math broken!");
}
36Verzweigungen
● Beispiel: Was wird ausgegeben?
if ((1 >= 2) || (7 % 4 == 3)) {
System.out.println("Ja!");
} else {
System.out.println("Nein!");
}
37Verzweigungen
● Beispiel: Was wird ausgegeben?
if (!((9 4))) {
System.out.println("Ja!");
}
System.out.println("Fertig");
38Blö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!
39Demo: 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 :
2 b c
x + px+ q=0, p= , q=
a a
2
p p
x=− ±√ D , D=( ) −q
2 2
40Fehler & 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
41Syntaxfehler
● cannot be resolved
● Ihr versucht auf eine nicht deklarierte
Variable, Klasse oder Methode zuzugreifen
int x1 = 10, x2 = 20;
x = x1 + x2;
42Syntaxfehler
● Duplicate variable
● Ihr versucht eine schon existierende Variable
nochmal zu deklarieren
int x1 = 10, x2 = 20;
int x1 = x1 + x2;
43Typfehler
● The operator 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
}
44Typfehler
● Type mismatch: cannot convert from to
● 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
46Demo: 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
47Sie können auch lesen
