Einführung in die Java-Programmierung - Dr. Volker Riediger Tassilo Horn riediger

 
Einführung in die Java-Programmierung - Dr. Volker Riediger Tassilo Horn riediger
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
Einführung in die Java-Programmierung - Dr. Volker Riediger Tassilo Horn riediger
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
Einführung in die Java-Programmierung - Dr. Volker Riediger Tassilo Horn riediger
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 Java-
    Programmierung

                              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         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!”

                                                                    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  ausgeben
    System.out.print()

    // Wert von  gefolgt von
    // einem Zeilenumbruch ausgeben
    System.out.println()
                                                   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
         ⇒ c=√ a + b
                2    2

                                         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 :

2              b     c
x + px+ q=0, p= , q=
               a     a
                   2
      p          p
 x=− ±√ D , D=( ) −q
      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         tue dies     tue das   tue jenes

●   brauchen wir:
                                            2 Lsg.

            ...   berechne D              eine Lsg.

                                          keine Lsg.
                                                       34
Verzweigungen
●   Für Fallunterscheidungen gibt es die if-
    Anweisung:

    if () {
        // 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  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 :

2              b     c
x + px+ q=0, p= , q=
               a     a
                   2
      p          p
 x=− ±√ D , D=( ) −q
      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
●    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 
    ●   Ihr versucht eine schon existierende Variable
        nochmal zu deklarieren

    int x1 = 10, x2 = 20;
    int x1 = x1 + x2;

                                                    43
Typfehler
●   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
    }
                                                      44
Typfehler
●   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

                                              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
Sie können auch lesen
NÄCHSTE FOLIEN ... Stornieren