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:
- Bezeichner dürfen nur aus Buchstaben, Ziffern und Unterstrichen bestehen
- Großbuchstaben: A-Z
- Kleinbuchstaben: a-z
- Ziffern: 0-9
- Unterstrich: _
- Bezeichner dürfen nicht mit Ziffern beginnen
- Sonst möglicherweise Verwechslung mit Zahlen
- Bezeichner dürfen keine Sonderzeichen enthalten
- Reservierte Wörter dürfen nicht verwendet werden (int, double, if, while, etc...)
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:
- Ausgabe
- Ausgabe mit System.out.print(ln)
- Unterschied zwischen print() und println()
- Escapesequenzen ("\n", "\t", "\\" etc.)
- Kommentare (einzeilig und mehrzeilig)
- Die Variablentypen Integer, Double und Boolean
- Die fünf Rechenoperationen und ihre Wirkung für Integer und Double
- Variablen
- Deklaration
- Zuweisung
- Regeln für Variablenbezeichner
- Arrays
- Anlegen von Arrays
- Zugriff auf Elemente des Arrays (Wichtig: Das letzte Element wird mit dem Index
Größe-des-Arrays MINUS EINS angesprochen
- Verzweigungen
- if
- if-else
- Bedingungen
- Verknüpfen von Bedingungen
- Schleifen
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);