Einführung in Java

Inhalt


03. 09. 2008
Ein neues Projekt in NetBeans erstellen
Minimales Javaprogramm
Hallo Welt
Zahlen vs. Zeichenketten
Escapesequenzen
Links

10. 09. 2008
Kommentare
Vom Quellcode zum Programm
Rechnen mit Ganzzahlen
Rechnen mit Fließkommazahlen
Datentypen für Ganzzahlen und Fließkommazahlen
Links

Hausaufgaben zum 17. 09. 2008
Aufgabe
Lösung

17. 09. 2008
JDK installieren, Javaprogramme ohne Netbeans schreiben
Arbeiten mit Variablen

22. 10. 2008
Mit Variablen rechnen

05. 11. 2008
Verzweigungen (IF)
Verzweigungen (ELSE)
Vergleiche
Boolean
Verknüpfung von Bedingungen

Hausaufgaben zum 26. 11. 2008
Aufgabe
Lösung

26. 11. 2008
Schleifen (WHILE)
Schleifen (FOR)
Vereinfachungen

Hausaufgaben zum 03. 12. 2008
Aufgabe
Lösung

03. 12. 2008
Felder (Arrays)
Aufgabe

10. 12. 2008
Variablennamen
Mathematische Funktionen
Aufgaben

17. 12. 2008
Das ist wichtig für die Klausur

14. 01. 2009
Funktionen

21. 01. 2009
Funktionen

04. 01. 2009
Objektorientierung
Klassen

18. 02. 2009
Vererbung

04. 03. 2009
Wiederholungen

11. 03. 2009
Suchen und Sortieren

Fragen? Email an

03. 09. 2008

Präsentation - OpenDocumentPresentation (odp) <OpenOffice.org>

Ein neues Projekt in NetBeans erstellen

File -> New Project
Im "New Project"-Dialog "Java Application" angeben
Auf Seite zwei einen sinnvollen Projektnamen angeben. "Project Location" sollte in eurem Schülermodul oder eurem USB-Stick liegen, damit ihr nächste Woche wieder auf eure Programme zugreifen könnt. Der Rest kann so bleiben.

Minimales Javaprogramm

Code:

package hallowelt;
public class Main {
    public static void main(String[] args) {

    }
}

Ausgabe:

keine

Hallo Welt

Code:

package hallowelt;
public class Main {
    public static void main(String[] args) {

        System.out.println("Hallo Welt!");

    }
}

Ausgabe:

Hallo Welt!

Zahlen vs. Zeichenketten

Code:

package hallowelt;
public class Main {
    public static void main(String[] args) {

        System.out.println("Hallo Welt!");
        System.out.println(42);
        System.out.println("42");
        System.out.println(16 - 3);
        System.out.println("16 - 3");
    }
}

Ausgabe:

Hallo Welt!
42
42
13
16 - 3

Folgerung:

Was in Anführungszeichen steht ist eine Zeichenkette, die direkt übernommen und angezeigt wird.
Alles andere ist ein Ausdruck, der erst Ausgewertet wird, und dessen Ergebnis erst angezeigt wird.

Escapesequenzen

Beispiel 1:

System.out.println("Hallo\nWelt!");
erzeugt als Ausgabe:
Hallo
Welt!

Beispiel 2:

System.out.println("Hallo\tWelt!");
erzeugt als Ausgabe:
Hallo     Welt!

Liste:

\'
Einfaches Anführungszeichen
\"
Doppeltes Anführungszeichen
\\
umgekehrter Schrägstrich
\0
Nullzeichen (NUL, nicht das Zahlzeichen 0)
\n
Zeilenumbruch (von englisch new line)
\r
Wagenrücklauf (von englisch (carriage) return)
\t
Horizontaler Tabulator (von englisch (horizontal) tabulator)
\xhh
Direkte Zeichenauswahl durch zwei folgende Hexadezimalziffern hh ('A' entspricht '\x41') (von hexadezimal)
\ooo
Direkte Zeichenauswahl durch folgende maximal drei Oktalziffern ooo ('A' entspricht '\101') \0 ist ein Spezialfall dieser Regel
\uhhhh
Start einer Unicode-Zeichensequenz; auf diese müssen vier Hexadezimalziffern hhhh folgen (z. B. steht \u20ac für das Euro-Symbol) (von Unicode)

Links

http://www.netbeans.org/
Direkter Link zum Downloaden von NetBeans
Wikipedia: Java
Wikipedia: Escapesequenz
Java Homepage
Java API
Java API: PrintStream.println

10. 09. 2008

Präsentation - OpenDocumentPresentation (odp) <OpenOffice.org>

Kommentare

Kommentare sind stellen im Quelltext, die vom Compiler ignoriert werden.
Es gibt in Java zwei Arten von Kommentaren, den einzeiligen Kommentar und den mehrzeiligen Kommentar.

Einzeiliger Kommentar

Beginnen bei den Zeichen
//

Enden mit dem Zeilenende
Beispiel:
System.out.println("Hallo Welt!"); // schreibe Hallo Welt!

Einzeiliger Kommentar

Beginnen bei den Zeichen
/*

Enden bei den Zeichen
*/

Beispiel:
/* main-Methode
   wird beim Programmstart aufgerufen */
public static void main(String[] args) { ... }

Vom Quellcode zum Programm

Es gibt unter den höheren Programmiersprachen drei Arten.

Die einfachste Art sind Sprachen, die Interpretiert werden. Da jede Anweisung einzeln ausgeführt werden, sind sie auch die Langamsten.

Die nächste Art stellen Sprachen dar, die zu Maschinencode kompiliert werden. Der Maschinencode kann direkt vom Prozessor abgearbeitet werden. Deshalb sind diese Programmiersprachen auch die schnellsten.

Ein Mittelding davon stellen die Sprachen dar, die zuerst zu einem Bytecode kompiliert werden. Dieser Bytecode hat gegenüber dem Maschinencode den Vorteil, dass von der Computerarchitektur und dem Betreibsystem unabhängig ist. Erst beim Ausführen des Programms auf der jeweiligen Plattform (Java für Java-Programme, .net für C#-Programme) wird der Bytecode in Maschinencode umgewandelt und dann vom Prozessor abgearbeitet. Daher brauchen Java-Programme etwas länger zum starten, als andere Programme.

Rechnen mit Ganzzahlen

Code:

package zahlen;
public class Main {
    public static void main(String[] args) {

        System.out.println(42);
        System.out.println(42 + 5);
        System.out.println(42 - 5);
        System.out.println(42 * 5);
        System.out.println(42 / 5);
        System.out.println(42 % 5);

    }
}

Ausgabe:

42
47
37
210
8
2

Folgerung:

+ addiert zwei Zahlen
- subtrahiert zwei Zahlen
* multipliziert zwei Zahlen
/ dividiert zwei ganze Zahlen und gibt das Ergebnis als ganze Zahl zurü, also ohne Nachkommastellen
% ermittelt den Rest, der bei einer Division entsteht

"42 geteilt durch 5 ist gleich 8 Rest 2.", daher ist
42/5 = 8
und
42%5 = 2

Rechnen mit Fließkommazahlen

Code:

package zahlen;
public class Main {
    public static void main(String[] args) {

        System.out.println(42);
        System.out.println(42.0);
        System.out.println(42.6);
        System.out.pirntln();           // gibt eine Leerzeile aus
        System.out.println(42   / 5  );
        System.out.println(42.0 / 5.0);
        System.out.println(42.0 / 5  );
        System.out.println(42   / 5.0);

    }
}

Ausgabe:

42
42.0
42.6

8
8.4
8.4
8.4

Folgerung:

Zahlen, die ein Dezimaltrennzeichen enthalten (in Java ein Punkt und kein Komma), werden als Fließkommazahl (Float) behandelt. Zahlen die kein Dezimaltrennzeichen enthalten werden als Ganzzahlen (Integer) behandelt. Sind in einer Rechnung beide Zahlen Ganzzahlen, wird das Ergebnis ebenfalls eine Ganzzahl, sodass ggf. Nachkommastellen abgeschnitten werden. Ist aber eine Zahl in der Rechnung eine Fließkommazahl, wird auch das Ergebnis eine Fließkommazahl.

Natürlich sind f&uum;r Fließkommazahlen auch alle anderen arithmetischen Funktionen wie Addition (+), Subtraktion (-), und Multiplikation (*) verfügbar, aber nicht Modulo (%)!

Datentypen für Ganzzahlen und Fließkommazahlen

Es gibt in Java drei Datentypen füer Ganzzahlen. Wenn man keine weiteren Angaben macht, werden Zahlen zwischen -2147483648 und 2147483647 als Integer und kleinere bzw. größere Zahlen als Long Integer aufgefasst.
Außerdem gibt es in Java zwei Datentypen füer Fließkommazahlen. Wenn man keine weiteren Angaben macht, werden alle Zahlen als Double aufgefasst.
Datentyp Klassenname Primitivdatentyp Wertebereich
Byte Byte byte -128 - +127
Integer (normale Ganzzahl) Integer int -2147483648 - +2147483647 (2 Milliarden)
große Ganzzahl (long Integer) Long long -18446744073709551616 - +18446744073709551615 (18 Trillion)
Fließkommazahl (floating point number) Float float -1038 - +1038
Fließkommazahl doppelter Genauigkeit (double precision) Double double -10306 - +10306

Links

Wikipedia: Integer
Wikipedia: Float

Hausaufgaben zum 17. 09. 2008

Aufgabe

Schreibe ein Programm das folgende Ausgabe erzeugt:
Produkt:        Netto:          Brutto: (16% MWSt)
1 kg Mehl       0,85 Euro       0,99 Euro
2 kg Mehl       1,70 Euro       1,97 Euro
3 kg Mehl       2,55 Euro       2,96 Euro
4 kg Mehl       3,40 Euro       3,94 Euro
5.6 kg Mehl     4,76 Euro       5,52 Euro
73.28 kg Mehl   62,29 Euro      72,25 Euro

1 Apfel         0,35 Euro       0,41 Euro
2 Apfel         0,70 Euro       0,81 Euro
3 Apfel         1,05 Euro       1,22 Euro
4 Apfel         1,40 Euro       1,62 Euro
7 Apfel         2,45 Euro       2,84 Euro
25 Apfel        8,75 Euro      10,15 Euro
Das Grundgerüst des Programms sieht dabei so aus:
package mehrwertsteuer;
import java.text.*; // Benötigt für die DecimalFormat Klasse
public class Main {
    public static void main(String[] args) {
        /* Es sollen nur zwei Stellen nach dem Komma angezeigt werden */
        DecimalFormat df = new DecimalFormat("##0.00");
		
        // HIER KOMMEN DIE AUSGABEN HIN
		
	}
}
Die Ausgabezeilen können dann so aussehen:
System.out.println("73.28 kg Mehl\t" + df.format(73.28 * 0.85) + " Euro\t" + df.format(73.28 * 0.85 * 1.16) + " Euro" );
df.format() wandelt eine Zahl in eine formatierte Zeichenkette um, in diesem Fall so, dass nur zwei Nachkommastellen angezeigt werden

Erweitere das Programm um ein weiteres Produkt mit verschiedenen Mengen (z.B.: Wasser in Litern)!
Verändere den Parameter von DecimalFormat(), z.B. in dem du weitere Nullen anhängst!
Was passiert, wenn man df.format() weglässt?

Hinweis: Aus Pädagogischen Gründen befinden wir uns noch im Jahr 2006 und haben eine Mehrwertsteuer von 16 Prozent. Auch, dass die Mehrwertsteuer für Grundnahrungsmittel geringer ist, lassen wir getrost außer Acht. =)

Lösung

Eine mögliche Lösung könnte so aussehen:
package mehrwertsteuer;
import java.text.*;
public class Main {
    public static void main(String[] args) {
        DecimalFormat df = new DecimalFormat("####0.00");

        System.out.println("Produkt:\tNetto:\t\tBrutto: (16% MWSt)");
        System.out.println("1 kg Mehl\t" + df.format(1 * 0.85) + " Euro\t" + df.format(1 * 0.85 * 1.16) + " Euro" );
        System.out.println("2 kg Mehl\t" + df.format(2 * 0.85) + " Euro\t" + df.format(2 * 0.85 * 1.16) + " Euro" );
        System.out.println("3 kg Mehl\t" + df.format(3 * 0.85) + " Euro\t" + df.format(3 * 0.85 * 1.16) + " Euro" );
        System.out.println("4 kg Mehl\t" + df.format(4 * 0.85) + " Euro\t" + df.format(4 * 0.85 * 1.16) + " Euro" );
        System.out.println("5.6 kg Mehl\t" + df.format(5.6 * 0.85) + " Euro\t" + df.format(5.6 * 0.85 * 1.16) + " Euro" );
        System.out.println("73.28 kg Mehl\t" + df.format(73.28 * 0.85) + " Euro\t" + df.format(73.28 * 0.85 * 1.16) + " Euro" );
        System.out.println();
        System.out.println("1 Apfel\t\t" + df.format(1 * 0.35) + " Euro\t" + df.format(1 * 0.35 * 1.16) + " Euro" );
        System.out.println("2 Apfel\t\t" + df.format(2 * 0.35) + " Euro\t" + df.format(2 * 0.35 * 1.16) + " Euro" );
        System.out.println("3 Apfel\t\t" + df.format(3 * 0.35) + " Euro\t" + df.format(3 * 0.35 * 1.16) + " Euro" );
        System.out.println("4 Apfel\t\t" + df.format(4 * 0.35) + " Euro\t" + df.format(4 * 0.35 * 1.16) + " Euro" );
        System.out.println("7 Apfel\t\t" + df.format(7 * 0.35) + " Euro\t" + df.format(7 * 0.35 * 1.16) + " Euro" );
        System.out.println("25 Apfel\t" + df.format(25 * 0.35) + " Euro\t" + df.format(25 * 0.35 * 1.16) + " Euro" );
        System.out.println();
        System.out.println("1 l Milch\t" + df.format(1 * 1.12) + " Euro\t" + df.format(1 * 1.12 * 1.16) + " Euro" );
        System.out.println("2 l Milch\t" + df.format(2 * 1.12) + " Euro\t" + df.format(2 * 1.12 * 1.16) + " Euro" );
        System.out.println("3 l Milch\t" + df.format(3 * 1.12) + " Euro\t" + df.format(3 * 1.12 * 1.16) + " Euro" );
        System.out.println("4 l Milch\t" + df.format(4 * 1.12) + " Euro\t" + df.format(4 * 1.12 * 1.16) + " Euro" );
        System.out.println("12.4 l Milch\t" + df.format(12.4 * 1.12) + " Euro\t" + df.format(12.4 * 1.12 * 1.16) + " Euro" );
        System.out.println("18.7 l Milch\t" + df.format(18.7 * 1.12) + " Euro\t" + df.format(18.7 * 1.12 * 1.16) + " Euro" );
    }
}
Es verändert sich die Ausgabe der Zahlen, wenn man den Parameter von DecimalFormat() verändert.
Wenn man df.format() weglässt werden so viele Nachkommastellen wie möglich angezeigt.

17. 09. 2008

Präsentation - OpenDocumentPresentation (odp) <OpenOffice.org>

JDK installieren, Javaprogramme ohne Netbeans schreiben

JDK installieren

Das JDK (Java Development Kit) gibt es auf java.sun.com zum herunterladen. Ich empfehle die Standard Edition - Java SE (JDK).
Das JDK ist auch erforderlich um NetBeans zu installieren.

Javaprogramme ohne Netbeans schreiben

Man kann selbstverständlich auch ohne NetBeans Javaprogramme schreiben. Dazu schreibt man den Quellcode mit einem beliebigen Editor (notepad, Notepad++, etc.) und speichert ihn dann als <Klassenname>.java, also zum Beispiel für die Klasse public class HalloWelt{ ... } als "HalloWelt.java". Die Klasse in der Datei muss genauso heißen, wie im Dateinamen angegeben, also <Klassenname>.
Dann die Kommandozeile aufrufen (Start -> Ausführen -> "cmd") und kompilieren:
javac <Klassenname>.java
oder in der Langform
C:\Programme\Java\jdk1.6.0_05\bin\javac.exe <Klassenname>.java
und schließlich mir Java ausführen:
java <Klassenname>
Dabei solltet ihr euch immer in dem Verzeichnis befinden, in dem Euer Code liegt, ansonsten das Verzeichnis wechseln, mit:
cd <Verzeichnis>

Arbeiten mit Variablen

Deklaration:
int Punkte;
double PWuerfel; // Wahrscheinlichkeit für eine Würfelseite
Zuweisung:
Punkte = 15;
PWuerfel = 1.0/6;
Deklaration & Initialisierung:
int Punkte = 15;
double PWuerfel = 1.0/6;
Zugriff auf Variablen:
Der Zugriff auf Variable erfolgt wie der Zugriff auf normale Zahlen.
System.out.println("Erreichte Punktzahl: " + Punkte);
pre> Man kann mit Variablen auch ganz normal rechnen.
System.out.println("P für zwei Sechsen hintereinander: " + PWuerfel * PWuerfel);

Allgemein

Deklaration:
<Typ> <Name>;
Zuweisung:
<Name> = <Wert>;
Deklaration & Initialisierung:
<Typ> <Name> = <Wert>;

22. 10. 2008

Mit Variablen rechnen

Folgendes Programm berechnet die Summe zweier Zahlen:

Code:

package rechnen;
public class Main {
    public static void main(String[] args) {

        String s1 = javax.swing.JOptionPane.showInputDialog("Zahl 1");
        String s2 = javax.swing.JOptionPane.showInputDialog("Zahl 2");

        int z1 = Integer.parseInt(s1);
        int z2 = Integer.parseInt(s2);

        int summe = z1 + z2;

        System.out.print("Die Summe der Zahlen ");
        System.out.print(s1 + " und " + s2 );
        System.out.println(" beträgt " + summe);
    }
}

Ausgabe:

Die Summe der Zahlen 5 und 7 beträgt 12
Um das Produkt und Prozente auszurechnen kann man das Programm so erweitern:

Code:

        int produkt = z1 * z2;
        double prozent = (double) z1 * z2 / 100.0;

        System.out.print("Das Produkt der Zahlen ");
        System.out.print(s1 + " und " + s2 );
        System.out.println(" beträgt " + produkt);

        System.out.print(s2 + " Prozent von  ");
        System.out.print(s1 + " sind " + prozent);

Ausgabe:

Die Summe der Zahlen 5 und 7 beträgt 12
Das Produkt der Zahlen 5 und 7 beträgt 35
7 Prozent von  5 sind 0.35
Bei der Prozentrechnung werden die Integer in Double umgewandelt, um Kommazahlen darstellen zu können.

05. 11. 2008

Verzweigungen (IF)

Strukur der if-Verzweigung
if ( /* Bedingung */ )
{
    // Befehle, die Ausgeführt werden wenn
    // die Bedingung zutrifft
}
Beispiel:
package bedingungen;

public class Main {
    public static void main(String[] args) {
        
        int zahl = Integer.parseInt(
javax.swing.JOptionPane.showInputDialog("Zahl 1"));

        if (zahl > 32)
        {
            System.out.print("Du hast eine Zahl größer");
            System.out.println(" als 32 eingegeben");
        }
    }
}

Verzweigungen (ELSE)

Optional kann auch der else-Zweig angehängt werden:
if ( /* Bedingung */ )
{
    // Befehle, die Ausgeführt werden wenn
    // die Bedingung zutrifft
}
else
{
    // Befehle, die Ausgeführt werden wenn
    // die Bedingung NICHT zutrifft
}
Beispiel:
package bedingungen;

public class Main {
    public static void main(String[] args) {
        
        int zahl = Integer.parseInt(
javax.swing.JOptionPane.showInputDialog("Zahl 1"));

        if (zahl == 32)
        {
            System.out.println("Du hast 32 eingegeben");
        }
        else
        {
            System.out.println("Du hast nicht 32 eingegeben");
        }
    }
}

Vergleiche

Für Zahlen gibt es folgende Arten von Vergleichen:
if (a == b) // Überprüft Gleichheit

if (a != b) // Überprüft Ungleichheit

if (a < b)  // Überprüft ob a kleiner als b

if (a <= b) // Überprüft ob a kleiner als b oder gleich b

if (a > b)  // Überprüft ob a größer als b

if (a >= b) // Überprüft ob a größer als b oder gleich b

Boolean

Für Wahrheitswerte (eine Aussage kann WAHR oder FALSCH sein) gibt es den Datentyp boolean. Er kann die Werte true und false annehmen. Das Ergebnis eines Vergleichs ist immer ein Wahrheitswert.
boolean bedingung;

bedingung = true;
bedingung = false;

bedingung = (a == b);
bedingung wird true, wenn a gleich b ansonsten wird bedingung false
If-Bedinungen werden nur ausgeführt, wenn die Bedingung true ergibt

Verknüpfung von Bedingungen

Bedingungen lassen sich miteinander verknüpfen.
Bei der ODER-Verknüpfung ist die Gesamtbedingung WAHR, wenn eine der Einzelbedingung WAHR ist.
boolean ergebnis = bedingung1 || bedingung2;
Bei der UND-Verknüpfung ist die Gesamtbedingung WAHR, wenn alle Einzelbedingung WAHR sind.
boolean ergebnis = bedingung1 && bedingung2;
Eine komplexe Verzweigung mit UND- und ODER-Verknüpung kann dann so aussehen: package bedingungen;
public class Main {
    public static void main(String[] args) {      
        int zahl = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Zahl 1"));

        if (zahl <= 10 || (zahl > 20 && zahl % 2 == 0))
        {
            System.out.print("Du hast eine Zahl kleiner");
            System.out.print(" oder gleich 10 oder ");
            System.out.print("eine gerade Zahl größer");
            System.out.println(" als 20 eingegeben.");
        }
    }
}

Hausaufgaben zum 26. 11. 2008

Aufgabe

1. Schreibe ein Programm, das zu einer eingegebenen Schulnote (1-6) die jeweilige Bedeutung ausgibt:
    1: sehr gut
    2: gut
    3: befriedigend
    4: ausreichend
    5: mangelhaft
    6: ungenügend

2. Bei einer Zahl, die keine Schulnote ist, soll eine Fehlermeldung ausgegeben werden.

Lösung

Eine mögliche Lösung könnte so aussehen:
package schulnoten;
import java.text.*;
public class Main {
    public static void main(String[] args) {
        int zahl = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Note"));

        if (zahl == 1)
        {
            System.out.println("Sehr gut");
        }
        if (zahl == 2)
        {
            System.out.println("Gut");
        }
        if (zahl == 3)
        {
            System.out.println("Befriedigend");
        }
        if (zahl == 4)
        {
            System.out.println("Ausreichend");
        }
        if (zahl == 5)
        {
            System.out.println("Mangelhaft");
        }
        if (zahl == 6)
        {
            System.out.println("Ungenuegend");
        }
        if (zahl < 1 || zahl > 6)
        {
            System.out.println("Keine gueltige Schulnote....");
        }
    }
}

26. 11. 2008

Schleifen (WHILE)

Strukur der while-Schleife
while ( /* Bedingung */ )
{
    // Befehle, die solange ausgeführt 
    // werden, wie die Bedingung zutrifft
}
Beispiel:
package schleifen;

public class Main {
    public static void main(String[] args) {
        System.out.println("Bitte Null eingeben!");

        while (0 != Integer.parseInt(
javax.swing.JOptionPane.showInputDialog("Zahl"))
        {
            System.out.println("keine Null");
            System.out.println("Nochmal!");
        }
        System.out.println("Null");
        System.out.println("Zuende!");
    }
}

Schleifen (FOR)

Strukur der for-Schleife
for (/*Initialisierung*/ ; /*Bedingung*/ ; /*Anweisung*/)
{
    // Befehle, die solange ausgeführt 
    // werden, wie die Bedingung zutrifft
}
Damit kann man
        int zaehler = 1;

        while (zaehler <= 100)
        {
            System.out.println(zaehler);
            zaehler++;
        }
durch
        for (int zaehler = 1; zaehler <= 100; zaehler++)
        {
            System.out.println(zaehler);

        }
ersetzen.

Damit kann man zum Beispiel die Fakultät einer Zahl berechnen:
package fakulaet;

public class Main {
    public static void main(String[] args) {
        int input = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Zahl");
        int ergebnis = 1;
        
        for (int i = 1; i <= max; i++)
        {
            ergebnis *= i;
        }
        System.out.println("Ergebnis: die Fakultaet von " + input + " ist " + ergebnis);
    }
}

Vereinfachungen

Folgende Vereinfachungen sind in Java möglich. Dabei haben zwei übereinanderstehende Zeile jeweils die gleiche Wirkung:
a = a + b;
a += b;

a = a - b;
a -= b;

a = a * b;
a *= b;

a = a / b;
a /= b;

a = a + 1;
a++;

a = a - 1;
a--;

Hausaufgaben zum 03. 12. 2008

Aufgabe

Schreibe ein Programm, dass eine Zahl n einliest und dann die Summer aller Zahlen von eins bis n ausgibt.
Also x = 1 + 2 + 3 + ... + (n-2) + (n-1) + n
Dafür kann zum Beispiel das Programm zur Errechnung der Fakultät abgewandelt werden.

Lösung

Eine mögliche Lösung könnte so aussehen:
package summation;

public class Main {
    public static void main(String[] args) {
        int input = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Zahl");
        int ergebnis = 0;
        
        for (int i = 1; i <= max; i++)
        {
            ergebnis += i;
        }
        System.out.println("Ergebnis: die Summation der Zahlen von 0 bis " + input + " ist " + ergebnis);
    }
}

03. 12. 2008

Felder (Arrays)

Klassisch kann man die Quadratzahlen von 0 bis 4 so berechnen und ausgeben:
int quadrat0;
int quadrat1;
int quadrat2;
int quadrat3;
int quadrat4;

quadrat0 = 0 * 0;
quadrat1 = 1 * 1;
quadrat2 = 2 * 2;
quadrat3 = 3 * 3;
quadrat4 = 4 * 4;

System.out.println(quadrat0);
System.out.println(quadrat1);
System.out.println(quadrat2);
System.out.println(quadrat3);
System.out.println(quadrat4);
Mit Arrays geht das auch so:
int[] quadrate = new int[5];

for (int i = 0; i < 5; i++)
{
    quadrate[i] = i * i;
}

for (int i = 0; i < 5; i++)
{
    System.out.println(quadrate[i]);
}
Das ist besonders bei der Behandlung von sehr vielen ähnlichen Daten hilfreich.

Deklaration eines Arrays:
// Deklaration
datentyp[] variablenname = new datentyp[feldgröße];
Zugriff auf Elemente eines Arrays:
// Zugriff
variablenname[index]

Aufgabe

Quellcode bis spätestens zum 10. 12. 2008 an roczech@web.de schicken!

Link zur Java-API:
http://java.sun.com/javase/6/docs/api/

Suche eine Funktion zum Erzeugen von Zufallszahlen.
Tipp: Paket ist „java.lang“

Schreibe ein Programm zum Zahlenraten. Das Programm erzeugt eine Zufallszahl zwischen 1 und 1000 und lässt den Benutzer dann bis zu 10 mal raten. Es gibt aus, ob die Zahl zu groß, zu klein, oder richtig geraten ist. Am Ende sollen alle Rateversuche nochmal ausgegeben werden.

10. 12. 2008

Variablennamen

Es gelten die folgenden Regeln für Variablen (und auch für alle anderen Arten von Bezeichnern, wie Funktionen, Klassen, etc.) in Java:

Mathematische Funktionen

Das Math-Objekt in Java implementiert einige wichtige mathematische Funktionen. Die wichtigsten davon sind:
Math.abs(double a)            // Betrag (Absolutwert)
Math.pow(double a, double b)  // Potenz (a hoch b)
Math.sqrt(double a)           // Quadratwurzel
Math.random()                 // Zufallszahl (zwischen 0 und 1)
Math.round(double a)          // runden auf Ganzzahl

Math.sin(double a)            // Sinus, Kosinus, Tangens
Math.cos(double a)
Math.tan(double a)
Math.asin(double a)           // Arkussinus, etc.
...

Math.PI                       // Kreiszahl Pi
Math.E                        // Eulersche Zahl
Eine vollständige Auflistung findet sich in der Java-API.

Aufgaben

a) Schreibe ein Programm, dass jede Quadratische Gleichung der Form

x2 + p x + q = 0

auflösen kann.
Lies dafür p und q ein und berechne x1 und x2, falls Lösungen existieren.

b) Erweitere das Programm so, dass es jede Quadratische Gleichung der Form

x2 + p x + q = a

auflösen kann.
Lies dafür p, q und a ein und berechne x1 und x2, falls Lösungen existieren.

c) Erweitere das Programm so, dass es jede Quadratische Gleichung der Form

o x2 + p x + q = a

auflösen kann.
Lies dafür o, p, q und a ein und berechne x1 und x2, falls Lösungen existieren.

17. 12. 2008

Das ist wichtig für die Klausur:

14. 01. 2009

Funktionen

package Fakultaet;
public class Main {
	public static void main(String[] args)
	{    
		int bar = fakultaet(5);
		
		System.out.println(bar);
	}
	
	static int fakultaet(int x)
	{
		if (x <= 1)
			return 1;
		else
			return (fakultaet(x-1) * x);
	}
}

21. 01. 2009

Funktionen

04. 02. 2009

Präsentation - OpenDocumentPresentation (odp) <OpenOffice.org>

Objektorientierung

Objektorientierung bezeichnet das zusammenfassen von Daten (Variablen) und Methoden (Funktionen) zu Objekten. Dies dient einerseits zur Abstraktion von komplexen Vorgängen und andererseits zur Darstellung von realen Sachverhalten.

Klassen

Eine Klasse muss immer in eine einer Datei mit dem gleichen Namen stehen. (Also die Klasse "Blub" in der Datei "Blub.java").
Das Grundgerüst einer Klasse (in diesem Fall mit dem Namen "Auto") sieht so aus:
public class Auto
{
}
Fügt man jetzt noch Daten und Methoden hinzu, könnte die Klasse so aussehen:
public class Auto
{
	private int maxGeschwindigkeit;
	private String farbe;
	
	public void fahren(int v)
	{
		if (v <= maxGeschwindigkeit)
			System.out.println("Brumm...");
		else
			System.out.println("zu schnell");
	}
	
	public void sehen()
	{
		System.out.println("Du siehst ein " + farbe + "es Auto");
	}
}
Der Konstruktor ist eine Funktion die Aufgerufen wird, wenn man eine neue Instanz der Klasse anlegt. Der Konstruktor muss genauso heißen wie die Klasse.
	public Auto(int maxV, String color){
		maxGeschwindigkeit = maxV;
		farbe = color;
	}
Neue Instanzen einer Klasse lassen sich mit new anlegen, dabei wird der Konstruktor aufgerufen:
Auto meinAuto = new Auto(200,"rot");
Auf die Elemente der Klasse kann man jetzt mit einem Punkt zugreifen:
meinAuto.fahren(120);
meinAuto.sehen();
Zusammenfassend sieht unsere Autoklasse jetzt so aus:
public class Auto {
	private int maxGeschwindigkeit;
	private String farbe;
	
	public Auto(int maxV, String color){
		maxGeschwindigkeit = maxV;
		farbe = color;
	}		
	
	public void fahren(int v){
		if (v <= maxGeschwindigkeit)
			System.out.println("Brumm...");
		else
			System.out.println("zu schnell");
	}
	
	public void sehen(){
		System.out.println(
		"Du siehst ein " + farbe + 
		"es Auto");
	}
	
	public static void main(String[] args){
		Auto meinAuto = new Auto(200,"rot");
		meinAuto.fahren(120);
		meinAuto.sehen();
	}
}

18. 02. 2009

Präsentation - OpenDocumentPresentation (odp) <OpenOffice.org>

Vererbung

04. 03. 2009

Wiederholungen

11. 03. 2009

Suchen und Sortieren

Programmgrundgerüst
package searchnsort;

public class Main {
	public static void main(String[] args) {
		int[] data = new int[100];
		for (int i = 0; i < 100; i++)
			data[i] = (int) (Math.random() * 1000);
		
		printArray(data);
		
		// Der restliche Code hier...
	}
	
	private static void printArray(int[] array)
	{
		for (int i = 0; i < array.length; i++)
			System.out.print(array[i] + " ");
		System.out.println();
	}
}
Aufgaben:
1. Durchsuche das Array nach dem kleinstem [größtem] Wert und gib diesen aus!
2. Sortiere das Array und gib das sortierte Array aus!

Beispiellösungen:
1.
		int min = 10000;
		for (int i = 0; i < 100; i++)
			if (data[i] < min)
				min = data[i];
		System.out.println(min);
		int max = 0;
		for (int i = 0; i < 100; i++)
			if (data[i] > max)
				max = data[i];
		System.out.println(max);
2.
		for (int i = 99; i > 0; i--)
			for (int j = 0; j < i; j++)
				if (data[j] > data[j+1])
				{
					int tmp = data[j];
					data[j] = data[j+1];
					data[j+1] = tmp;
				}
		printArray(data);