Programmierung mit Java.pdf - von P. Merkelbach
Programmierung mit Java.pdf - von P. Merkelbach
Programmierung mit Java.pdf - von P. Merkelbach
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
BBS Gerolstein<br />
Informatik<br />
<strong>Programmierung</strong><br />
<strong>mit</strong> <strong>Java</strong><br />
Stand: 15.08.2010<br />
www.p-merkelbach.de − 1 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
Inhaltsverzeichnis<br />
1. Die Funktionsweise <strong>von</strong> <strong>Java</strong> ..................................................................................................3<br />
1.1. Der Bytecode ...................................................................................................................3<br />
1.2. <strong>Java</strong> JDK installieren .......................................................................................................4<br />
1.3. Übung 1 ...........................................................................................................................4<br />
1.4. Kommentare ....................................................................................................................5<br />
1.5. Übung 2 ...........................................................................................................................5<br />
2. Datentypen und Rechenoperationen .......................................................................................6<br />
2.1. Datentypen ......................................................................................................................6<br />
2.2. Rechenoperationen..........................................................................................................7<br />
2.3. Übung 3 ...........................................................................................................................8<br />
2.4. Übung 4 ...........................................................................................................................8<br />
3. Benutzereingaben und formatierte Ausgaben..........................................................................9<br />
3.1. Benutzereingaben <strong>mit</strong> der Klasse Scanner ......................................................................9<br />
3.2. Formatierte Ausgaben......................................................................................................9<br />
3.3. Übung 5 .........................................................................................................................10<br />
4. Kontrollstrukturen ..................................................................................................................10<br />
4.1. Sequenz (Folgeanweisung) ...........................................................................................11<br />
4.2. Selektion (bedingte Verzweigung, Auswahlanweisung)..................................................11<br />
4.3. Mehrfachauswahl...........................................................................................................12<br />
4.4. Repetition (Wiederholungsanweisung, Schleife) ............................................................12<br />
4.5. Zählschleife....................................................................................................................13<br />
4.6. Logische Operatoren .....................................................................................................13<br />
4.7. Übung 6 .........................................................................................................................13<br />
4.8. Übung 7 .........................................................................................................................14<br />
4.9. Übung 8 .........................................................................................................................15<br />
4.10. Übung 9 .....................................................................................................................16<br />
4.11. Übung 10 ...................................................................................................................17<br />
5. String-Methoden ....................................................................................................................19<br />
6. Parametereingabe .................................................................................................................20<br />
7. Inkrement / Dekrement ..........................................................................................................21<br />
8. For-Schleifen .........................................................................................................................22<br />
8.1. Sterne0.java...................................................................................................................22<br />
8.2. Sterne1.java...................................................................................................................22<br />
8.3. Sterne2.java...................................................................................................................23<br />
8.4. Sterne3.java...................................................................................................................24<br />
8.5. Sterne4.java...................................................................................................................25<br />
www.p-merkelbach.de − 2 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
1. Die Funktionsweise <strong>von</strong> <strong>Java</strong><br />
Die <strong>Java</strong>.exe ist eine virtuelle Maschine, die als Bindeglied zwischen dem Programm im<br />
Bytecode und dem entsprechenden Betriebssystem fungiert.<br />
Der Bytecode ist dabei Plattform unabhängig. Er wird erst <strong>von</strong> dem entsprechenden <strong>Java</strong>-<br />
Interpreter (Virtuelle Maschine) passend zum vorliegenden Betriebssystem übersetzt.<br />
Hardware 1 Hardware 2<br />
<strong>Java</strong>-Interpreter <strong>Java</strong>-Interpreter java.exe<br />
Bytecode<br />
HelloWorld.class<br />
<strong>Java</strong>-Compiler<br />
javac.exe<br />
Quellcode<br />
HelloWorld.java<br />
1.1. Der Bytecode<br />
Zunächst schreibt man die <strong>Java</strong>befehle im Quellcode in eine normale Textdatei z.B.<br />
HelloWorld.java. Die Quellcodedatei muss die Endung .java haben und der Dateiname sollte<br />
<strong>mit</strong> einem Großbuchstaben beginnen.<br />
Um ein <strong>Java</strong> Programm durch die virtuelle Maschine (<strong>Java</strong> Prozessor) ausführen zu lassen, muss<br />
der Quellcode in den Bytecode (Maschinensprache für den <strong>Java</strong> Prozessor) übersetzt werden.<br />
Das Programm javac.exe ist ein Compiler (Übersetzer) der den Quellcode in eine Bytecodedatei<br />
<strong>mit</strong> dem Namen HelloWorld.class übersetzt.<br />
Der <strong>Java</strong> Compiler auf einem Macintosh wird exakt den gleichen Bytecode erzeugen, wie der<br />
<strong>Java</strong> Compiler auf einem Intel System, d.h. er arbeitet Betriebssystem unabhängig. Man nennt<br />
das auch „Plattformunabhängig“.<br />
Die virtuelle Maschine (<strong>Java</strong> Prozessor) installiert man <strong>mit</strong> Hilfe der JRE bzw. JDK auf einem<br />
Rechnersystem. Diese virtuelle Maschine java.exe liest den Bytecode und führt ihn aus. Das<br />
Programm java.exe ist ein sogenannter Interpreter.<br />
Jedes Computersystem kann <strong>Java</strong> Bytecode Programme ausführen, wenn es einen <strong>Java</strong><br />
Interpreter hat. Der <strong>Java</strong> Interpreter muss speziell für den bestimmten Prozessortyp des<br />
www.p-merkelbach.de − 3 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
Computersystems geschrieben sein, aber wenn das geschehen ist, kann das Computersystem<br />
eine <strong>Java</strong> Virtuelle Maschine werden. Das heißt, es verhält sich wie ein Computer <strong>mit</strong> einem <strong>Java</strong><br />
Hardware Prozessorchip der <strong>Java</strong> Bytecode ausführen kann.<br />
1.2. <strong>Java</strong> JDK installieren<br />
Das <strong>Java</strong> SE Development Kit (JDK) ist eine kostenlose Sammlung <strong>von</strong> Software <strong>von</strong> Sun<br />
Microsystems. Der Download ist bei java.sun.com erhältlich. Wenn Sie <strong>Java</strong> noch nicht installiert<br />
haben, besorgen Sie sich die neueste Version. Die aktuelle Version ist die JDK 6.<br />
Möchte man nur <strong>Java</strong> Programme auf einem Rechner ausführen reicht die sogenannte <strong>Java</strong> SE<br />
Runtime Environment (JRE) aus. Möchte man aber <strong>Java</strong> Programme oder Applets selber entwickeln,<br />
benötigt man die JDK. In der JDK ist die JRE enthalten.<br />
Beim Download muss man das Betriebssystem, für welches man die JDK benötigt auswählen, da<br />
jedes Betriebssystem eine andere virtuelle <strong>Java</strong>-Maschine benötigt. Die aktuelle Datei für Windows<br />
heißt z.B. jdk-6u12-windows-i586-p.exe.<br />
Sobald Sie die Datei haben können Sie <strong>Java</strong> installieren, indem Sie diese Datei (doppelt)<br />
anklicken. Da<strong>mit</strong> starten Sie das Installationsprogramm. Alles, was Sie dann noch zu tun haben ist<br />
auf die Schaltflächen zu klicken und die Standardeinstellungen zu akzeptieren.<br />
1.3. Übung 1<br />
a) Öffnen Sie einen Texteditor und schreiben Sie folgende Programmzeilen ab:<br />
public class HelloWorld<br />
{<br />
public static void main(String argv[ ])<br />
{<br />
System.out.println(„Hallo Welt“);<br />
}<br />
}<br />
b) Speichern Sie die Datei unter dem Namen HelloWorld.java im Unterordner bin im JDK-<br />
Ordner ab.<br />
c) Öffnen Sie die Eingabeaufforderung und wechseln Sie in den Unterordner bin im JDK-Ordner.<br />
Geben Sie dort folgende Zeile ein:<br />
javac HelloWorld.java<br />
Aufruf des Compilers<br />
erstellt die Datei HelloWorld.class<br />
Wenn keine Fehlermeldung erscheint geben Sie folgende Zeile ein:<br />
java HelloWorld<br />
Aufruf des Programms (HalloWelt.class)<br />
es wird die Klasse aufgerufen<br />
Erläuterungen zu dem Programm:<br />
1. Eine <strong>Java</strong>-Quellcodedatei beginnt immer <strong>mit</strong> Großbuchstaben, darf keine Leerzeichen oder<br />
Sonderzeichen enthalten und hat die Endung .java<br />
2. Die Klasse muss genauso heißen wie der Dateiname<br />
www.p-merkelbach.de − 4 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
3. public class HelloWorld besagt, dass dieses Quellprogramm eine öffentliche Klasse<br />
<strong>mit</strong> dem Namen "HelloWorld" definieren wird. Eine Klasse ist ein Abschnitt eines<br />
Programms. Kleine Programme bestehen oft nur aus einer Klasse. Wenn das Programm<br />
kompiliert ist, wird der Compiler eine Datei aus Bytecode <strong>mit</strong> dem Namen HelloWorld.class<br />
erzeugen.<br />
Manche Klassen enthalten viele Zeilen. Alles, was eine Klasse ausmacht, wird zwischen<br />
die erste geschweifte Klammer ( { ) und die dazugehörige letzte geschweifte Klammer ( } )<br />
gestellt.<br />
4. Das Wort main bedeutet, dass die Methode den Namen main hat und für die <strong>Java</strong><br />
Virtuelle Maschine bedeutet es, dass hier der Startpunkt des Programms ist.<br />
public bedeutet die Methode ist öffentlich, static bedeutet, die Methode ist statisch und<br />
void bedeutet, die Methode gibt an das aufrufende Programm keinen Wert zurück.<br />
String argv[ ] bedeutet, dass mehrere Parameter <strong>mit</strong> dem Namen argv[0], argv[1],<br />
argv[2] … übergeben werden können. Jeder Parameter wird als Zeichenkette (String)<br />
interpretiert.<br />
5. Die main() Methode dieses Programms besteht aus einer einzigen Anweisung:<br />
System.out.println(„Hallo Welt“);<br />
Diese Anweisung gibt die Zeichen innerhalb der Anführungszeichen auf den Bildschirm des<br />
Computersystems aus.<br />
Dabei ist System wiederum eine schon vordefinierte Klasse <strong>mit</strong> der Methode<br />
.out.println . Wichtig ist die Groß- und Kleinschreibung bei den <strong>Java</strong>befehlen zu<br />
beachten.<br />
6. Jede Programmzeile endet <strong>mit</strong> einem Semikolon.<br />
1.4. Kommentare<br />
Ein Kommentar ist ein Hinweis des Programmierers im Programm. Ein Kommentar beginnt <strong>mit</strong><br />
zwei Slash-Zeichen "//". Diese Zeichen und alles, was nach diesen Zeichen bis zum Ende der Zeile<br />
folgt, wird vom <strong>Java</strong> Compiler ignoriert. Mehrzeilige Kommentare werden zwischen /* und */<br />
gesetzt.<br />
Beispiele:<br />
System.out.println("Hallo Welt");<br />
//Hier steht ein Kommentar<br />
/* Hier steht<br />
ein mehrzeiliger<br />
Kommentar */<br />
1.5. Übung 2<br />
Erstellen Sie das Programm Lattenzaun.java, dass folgenden Text ausgibt. Vor dem Text soll im<br />
Quellcode als Kommentar stehen: „Der Lattenzaun <strong>von</strong> Christian Morgenstern“.<br />
Es war einmal ein Lattenzaun<br />
<strong>mit</strong> Zwischenraum, hindurchzuschaun<br />
Ein Architekt, der dieses sah,<br />
stand eines Abends ploetzlich da<br />
und nahm den Zwischenraum heraus<br />
und baute draus ein grosses Haus.<br />
Der Zaun indessen stand ganz dumm,<br />
<strong>mit</strong> Latten ohne was herum.<br />
www.p-merkelbach.de − 5 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
Ein Anblick graesslich und gemein.<br />
Drum zog ihn der Senat auch ein.<br />
2. Datentypen und Rechenoperationen<br />
2.1. Datentypen<br />
Mit Datentypen kann man das Aussehen <strong>von</strong> Variablen definieren und den Speicherbedarf für eine<br />
variable festlegen. Bei <strong>Java</strong> müssen Variablen einen Datentyp zugewiesen bekommen, weil <strong>Java</strong><br />
zu Beginn des Programms den Speicherbedarf für alle Variablen reserviert.<br />
Bei <strong>Java</strong> unterscheidet man folgende Datentypen:<br />
Ganze Zahlen: byte, short, int und long<br />
Kommazahlen: float und double<br />
Ein Zeichen: char<br />
Wahrheitswert: boolean<br />
Speicherbedarf und Bereiche der Datentypen:<br />
Datentyp Speicherbedarf<br />
Bereich<br />
byte 1 Byte -128 bis +127<br />
short 2 Byte -32768 bis +32767<br />
int 4 Byte -2147483648 bis +2147483647<br />
long 8 Byte -9223372036854775808 bis +9223372036854775807<br />
float 4 Byte ±3,40282347E+38 bis ±1,40239846E-45<br />
double 8 Byte ±1,7976931348623157E+308 bis ±4,94065645841246544E-324<br />
char 2 Byte Unicode-Zeichen con \u0000 bis \uffff<br />
boolean 1 Bit true oder false<br />
Bei vielen anderen Programmiersprachen gibt es auch einen Datentyp String für lange<br />
Zeichenketten. Bei <strong>Java</strong> ist dies kein Datentyp sondern ein Objekt.<br />
Beispiel: Variablendeklaration.java<br />
public class Variablendeklaration<br />
{<br />
public static void main(String argv[])<br />
{<br />
//Deklaration <strong>von</strong> Variablen<br />
byte b1;<br />
short s1;<br />
int i1;<br />
long l1,l2,l3;<br />
float a1,a2,a3,a4;<br />
double d1;<br />
boolean bo1;<br />
char c1;<br />
String str1 = "Weihnachten";<br />
//Deklaration <strong>von</strong> Konstanten<br />
final float PI=3.1415f;<br />
final byte MWST=16;<br />
//Zuweisung <strong>von</strong> Werten<br />
b1 = 50;<br />
s1 = 15000;<br />
i1 = 15;<br />
l1 = 100;<br />
//sehr kurze Ganzzahl<br />
//kurze Ganzzahl<br />
//Ganzzahl<br />
//lange Ganzzahl<br />
//reelle Zahl<br />
//reelle Zahl <strong>mit</strong> doppelter Genauigkeit<br />
//boolsche Variable<br />
//ein Zeichen<br />
//Zeichenkette<br />
//Variable kann im Programm nicht mehr<br />
//geändert werden<br />
www.p-merkelbach.de − 6 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
a1 = (float)1.2345; //1.2345 ist konstant und so<strong>mit</strong> <strong>mit</strong> 64 Bit gespeichert<br />
a2 = 1.2345f; //daher muss sie in Float umgewandelt werden d.h. 32 Bit<br />
a3 = a1*5+7;<br />
d1 = 1.5E+20;<br />
bo1 = true;<br />
c1 = 'z';<br />
//nur einfache Anführungszeichen bei char-Variablen<br />
l2 = 5/3; //Ganzzahldivision Ergebnis = 1<br />
l3 = 5%3; //Modulo Ergebnis = 1<br />
a4 = a2 / a3;<br />
//Ausgabe<br />
System.out.println(b1);<br />
System.out.println(s1);<br />
System.out.println(i1);<br />
System.out.println(l1);<br />
System.out.println(a1);<br />
System.out.println(a2);<br />
System.out.println(a3);<br />
System.out.println(d1);<br />
System.out.println(bo1);<br />
System.out.println(c1);<br />
System.out.println(l2);<br />
System.out.println(l3);<br />
System.out.println(a4);<br />
System.out.println(PI);<br />
System.out.println(MWST);<br />
}//public static void main(String argv[])<br />
}//public class Variablendeklaration<br />
2.2. Rechenoperationen<br />
Die Rechenoperationen sind als Methoden in der Klasse java.lang.Math definiert.<br />
Rechenoperation Rechenzeichen Beispiel<br />
Addition + c=a+b a=5 b=3 c=8<br />
Subtraktion - c=a-b a=5 b=3 c=2<br />
Multiplikation * c=a*b a=5 b=3 c=15<br />
Division / c=a/b a=5.0 b=3.0 c=1.666<br />
Ganzzahldivision / c=a/b a=5 b=3 c=1<br />
Modulo bei Ganzzahldivision % c=a%b a=5 b=3 c=2 (Rest)<br />
Quadratwurzel<br />
Math.sqrt(Radikand)<br />
Potenz<br />
Math.pow(Basis,Exponent)<br />
e-Funktion<br />
Math.exp()<br />
Logarithmus<br />
Math.log()<br />
Sinus<br />
Math.sin()<br />
Cosinus<br />
Math.cos()<br />
Tangens<br />
Math.tan()<br />
Runde ganzzahlig auf<br />
Math.ceil()<br />
Runde ganzzahlig ab<br />
Math.floor()<br />
Runde zur nächsten Ganzzahl Math.round()<br />
Betrag eines Wertes<br />
Math.abs()<br />
Maximum zweier Werte<br />
Math.max()<br />
Minimum zweier Werte<br />
Math.min()<br />
Zufallswert zwischen 0 und 1 Math.random()<br />
www.p-merkelbach.de − 7 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
2.3. Übung 3<br />
Erstellen Sie das <strong>Java</strong> Programm Reihenschaltung.java<br />
zur Berechnung des Gesamtwiderstands bei zweier in<br />
Reihe geschalteter Ohmscher Widerstände.<br />
Richten Sie Ihren Programmaufbau nach dem gegebenen<br />
Struktogramm.<br />
Die Variablen bekommen die Werte zunächst im Programm<br />
direkt zugewiesen.<br />
Reihenschaltung.java<br />
Ausgabe:<br />
Berechnung des Gesamtwiderstands<br />
bei einer Reihenschaltung<br />
r1 = 10 Ohm<br />
r2 = 20 Ohm<br />
Verarbeitung:<br />
rges = r1 + r2<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges"<br />
Ohm.<br />
2.4. Übung 4<br />
Erstellen Sie das <strong>Java</strong> Programm Parallelschaltung.java<br />
zur Berechnung des Gesamtwiderstands bei zweier parallel<br />
geschalteter Ohmscher Widerstände.<br />
Parallelschaltung.java<br />
Ausgabe:<br />
Berechnung des Gesamtwiderstands<br />
bei einer Parallelschaltung<br />
r1 = 10 Ohm<br />
r2 = 20 Ohm<br />
Verarbeitung:<br />
rges = (r1 * r2)/(r1 + r2)<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges"<br />
Ohm.<br />
www.p-merkelbach.de − 8 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
3. Benutzereingaben und formatierte Ausgaben<br />
import java.text.DecimalFormat;<br />
import java.util.Scanner;<br />
public class Programmname<br />
{<br />
public static void main(String argv[])<br />
{<br />
//Variablendeklaration<br />
float a;<br />
int b;<br />
DecimalFormat df = new DecimalFormat("###,##0.00");<br />
Scanner eingabe = new Scanner(System.in);<br />
//Eingabe<br />
System.out.println("Geben Sie a ein: ");<br />
a = eingabe.nextFloat();<br />
System.out.println("Geben Sie b ein: ");<br />
b = eingabe.nextInt();<br />
//Ausgabe<br />
System.out.println("Die Variable a hat den Wert "+df.format(a)+".");<br />
}<br />
}<br />
3.1. Benutzereingaben <strong>mit</strong> der Klasse Scanner<br />
Da<strong>mit</strong> der Benutzer Eingaben machen kann, muss man die Klasse Scanner benuzten (Alternativ<br />
den Buffered Reader). Die Klasse Scanner muss vor der Definition der Klasse importiert werden.<br />
Man erzeugt ein Objekt <strong>mit</strong> dem Namen eingabe vom Typ Scanner. Mit a =<br />
eingabe.nextFloat(); wird die nächste Float-Variable eingelesen und der Variablen a<br />
zugewiesen. Die Datentypen müssen dabei übereinstimmen!<br />
3.2. Formatierte Ausgaben<br />
Da<strong>mit</strong> der Benutzer formatierte Ausgaben machen kann, muss man die Klasse DecimalFormat<br />
benuzten. Die Klasse DecimalFormat muss vor der Definition der Klasse importiert werden.<br />
Man erzeugt ein Objekt <strong>mit</strong> dem Namen df vom Typ DecimalFormat. Mit df.format(a) wird die<br />
Variable a nach dem definierten Format ausgegeben.<br />
www.p-merkelbach.de − 9 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
3.3. Übung 5<br />
Erweitern Sie die Programme aus Übung 3 und Übung 4 so, dass der Benutzer die Widerstände r1<br />
und r2 eingeben kann.<br />
Reihenschaltung2.java<br />
Ausgabe:<br />
Berechnung des Gesamtwiderstands<br />
bei einer Reihenschaltung<br />
Ausgabe:<br />
Geben Sie den Widerstand R1 in<br />
Ohm ein:<br />
Eingabe:<br />
r1<br />
Ausgabe:<br />
Geben Sie den Widerstand R2 in<br />
Ohm ein:<br />
Eingabe:<br />
r2<br />
Verarbeitung:<br />
rges = r1 + r2<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges"<br />
Ohm.<br />
Parallelschaltung2.java<br />
Ausgabe:<br />
Berechnung des Gesamtwiderstands<br />
bei einer Parallelschaltung<br />
Ausgabe:<br />
Geben Sie den Widerstand R1 in<br />
Ohm ein:<br />
Eingabe:<br />
r1<br />
Ausgabe:<br />
Geben Sie den Widerstand R2 in<br />
Ohm ein:<br />
Eingabe:<br />
r2<br />
Verarbeitung:<br />
rges = (r1 * r2)/(r1 + r2)<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges"<br />
Ohm.<br />
4. Kontrollstrukturen<br />
Man unterscheidet drei Elementaralgorithmen:<br />
Anweisung (Sequenz) Anweisung 1, Anweisung 2, Anweisung 3 ...<br />
Entscheidung (Selektion) Wenn Bedingung Dann Anweisung 1 Sonst Anweisung 2<br />
Wiederholung (Repetition) Solange Bedingung Tue Anweisung EndeSolange<br />
Diese drei Elementaralgorithmen besitzen jeweils einen Startpunkt und einen Endpunkt.<br />
Zu jedem Algorithmus gibt es stets einen äquivalenten Algorithmus, der sich aus den<br />
drei Kontrollstrukturen:<br />
Sequenz, Selektion und Repetition aufbauen lässt.<br />
Unter Kontrollstrukturen versteht man sprachliche Ausdrucks<strong>mit</strong>tel, die die Abfolge<br />
<strong>von</strong> Aktionen regeln.<br />
www.p-merkelbach.de − 10 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
4.1. Sequenz (Folgeanweisung)<br />
Struktogramm<br />
Anweisung 1<br />
Anweisung 2<br />
Anweisung 3<br />
Programmablaufplan (PAP)<br />
Anweisung 1<br />
Anweisung 2<br />
Anweisung 3<br />
<strong>Java</strong>:<br />
System.out.println("Geben Sie a ein: ");<br />
a = eingabe.nextFloat();<br />
System.out.println("Geben Sie b ein: ");<br />
b = eingabe.nextInt();<br />
4.2. Selektion (bedingte Verzweigung, Auswahlanweisung)<br />
Einseitige<br />
Auswahl<br />
Bedingung<br />
Ja<br />
Nein<br />
Anweisung %<br />
Bedingung<br />
Ja<br />
Anweisung<br />
Nein<br />
<strong>Java</strong>:<br />
if (Bedingung) Anweisung;<br />
Zweiseitige<br />
Auswahl<br />
Bedingung<br />
Ja<br />
Nein<br />
Anweisung 1 Anweisung 2<br />
Ja<br />
Bedingung<br />
Nein<br />
Anweisung 1 Anweisung 2<br />
<strong>Java</strong>:<br />
if (Bedingung)<br />
{<br />
Anweisung 1;<br />
}<br />
else<br />
{<br />
Anweisung 2;<br />
}<br />
www.p-merkelbach.de − 11 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
4.3. Mehrfachauswahl<br />
Mehrfache<br />
Auswahl<br />
1<br />
2<br />
3<br />
c<br />
4<br />
Sonst<br />
c<br />
Anw Anw Anw Anw Anw<br />
1 2 3 4 5<br />
Anw 1<br />
Anw 2 Anw 3 Anw 4 Anw 5<br />
<strong>Java</strong>:<br />
switch(c)<br />
{<br />
case wert1: Anweisung1; break;<br />
case wert2: Anweisung2; break;<br />
case wert3: Anweisung3; break;<br />
default: Anweisung5;<br />
}<br />
4.4. Repetition (Wiederholungsanweisung, Schleife)<br />
Kopfgesteuerte<br />
Schleife<br />
Solange Bedingung (Wahr)<br />
Bedingung<br />
Falsch<br />
Anweisung<br />
Wahr<br />
Anweisung<br />
Die Bedingungsprüfung wird auf jeden Fall einmal durchgeführt!<br />
<strong>Java</strong>:<br />
WHILE (Bedingung) Anweisung;<br />
Fußgesteuerte<br />
Schleife<br />
Anweisung<br />
Solange Bedingung (Wahr)<br />
Wahr<br />
Anweisung<br />
Bedingung<br />
Die Anweisung wird das erste Mal ohne Bedingungsprüfung durchgeführt!<br />
Falsch<br />
<strong>Java</strong>:<br />
DO<br />
{<br />
Anweisung1; ...Anweisung n;<br />
}<br />
while (Bedingung);<br />
www.p-merkelbach.de − 12 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
4.5. Zählschleife<br />
Für Zähler = i Bis k<br />
Anweisung<br />
Zähler = i<br />
Zähler < k<br />
Wahr<br />
Anweisung<br />
Zähler = Zähler + 1<br />
Falsch<br />
<strong>Java</strong>:<br />
for (Zähler=Anfangswert; Zähler b true<br />
=b false<br />
== (ist gleich) a=5 b=5 a==b true<br />
!= (ist ungleich) a=5 b=5 a!=b false<br />
&& (und) a=5 b=3 c=7 d=9 a>b && cb || c>d true<br />
4.7. Übung 6<br />
Erstellen Sie aus den <strong>Java</strong>-Programmen der Übung 5 ein Programm <strong>mit</strong> dem Namen<br />
Widerstand.java. Der Benutzer soll durch eine Auswahl die Möglichkeit haben, zu entscheiden, ob<br />
er eine Reihen- oder Parallelschaltung haben möchte.<br />
Verwenden Sie für die Auswahl eine Character-Variable.<br />
Der Benutzer darf Klein- und Großbuchstaben eingeben.<br />
www.p-merkelbach.de − 13 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
Erläuterungen zu der neuen Syntax:<br />
Einlesen einer Character-Variablen:<br />
variablenname = (char)System.in.read();<br />
System.in.skip(2);<br />
System.in.read() liest insgesamt 3 Zeichen ein. 1. den Buchstaben, den der Benutzer eingibt,<br />
2. ein Carrige Return (Wagenrücklauf) und ein LineFeed (neue Zeile). Die letzten beiden<br />
Steuerzeichen muss man <strong>mit</strong> System.in.skip(2) wieder löschen, da<strong>mit</strong> sie beim nächsten<br />
Einlesevorgang nicht aus dem Zeichenpuffer eingelesen werden und einen Fehler erzeugen.<br />
Die Methode System.in.read() benötigt eine Fehlerbehandlung die durch die Ergänzung <strong>von</strong><br />
throws IOException in der Zeile public static void main(String argv[]) throws<br />
IOException eingefügt wird. Zusätzlich muss man noch hierfür ein Paket importieren: import<br />
java.io.*;<br />
4.8. Übung 7<br />
Erstellen Sie zu Übung 6 ein Struktogramm.<br />
Widerstand.java<br />
float r1, r2, rges<br />
char auswahl<br />
Ausgabe:<br />
Widerstandsberechnung<br />
(P)arallel- oder (R)eihenschaltung<br />
Eingabe:<br />
auswahl<br />
Ausgabe:<br />
R1 in Ohm:<br />
Eingabe:<br />
r1<br />
Ausgabe:<br />
R2 in Ohm:<br />
Eingabe:<br />
r2<br />
J<br />
Verarbeitung:<br />
rges = r1 + r2<br />
Wenn auswahl = "R" oder "r"<br />
J<br />
Verarbeitung:<br />
rges = (r1 * r2)/(r1 + r2)<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges" Ohm.<br />
Wenn auswahl = "P" oder "p"<br />
Ausgabe:<br />
Fehlerhafte Eingabe!<br />
N<br />
N<br />
www.p-merkelbach.de − 14 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
4.9. Übung 8<br />
a) Ergänzen Sie das Programm aus Übung 7 so, dass der Benutzer die Berechnung solange<br />
wiederholen kann bis er das Programm abbricht.<br />
Nennen Sie das Programm Widerstand_2.java.<br />
b) Verändern Sie das Programm so, dass die Eingabe der Schaltungsart solange wiederholt wird,<br />
bis der Benutzer ein „p“, „P“, „r“ oder „R“ eingegeben hat.<br />
Was können Sie dann wieder <strong>von</strong> den IF-Verzweigungen wieder entfernen?<br />
Widerstand_2.java<br />
float r1, r2, rges<br />
char auswahl, wiederholen<br />
Ausgabe:<br />
Widerstandsberechnung<br />
(P)arallel- oder (R)eihenschaltung<br />
Eingabe:<br />
auswahl<br />
Ausgabe:<br />
R1 in Ohm:<br />
Eingabe:<br />
r1<br />
Ausgabe:<br />
R2 in Ohm:<br />
Eingabe:<br />
r2<br />
J<br />
Verarbeitung:<br />
rges = r1 + r2<br />
Solange wiederholen = "J" oder "j"<br />
Wenn auswahl = "R" oder "r"<br />
Ausgabe:<br />
Der Gesamtwiderstand beträgt "rges" Ohm.<br />
Ausgabe:<br />
Möchten Sie das Programm wiederholen?<br />
Eingabe:<br />
wiederholen<br />
J<br />
Verarbeitung:<br />
rges = (r1 * r2)/(r1 + r2)<br />
Wenn auswahl = "P" oder "p"<br />
Ausgabe:<br />
Fehlerhafte Eingabe!<br />
N<br />
N<br />
www.p-merkelbach.de − 15 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
4.10.<br />
4.11. Übung 9<br />
Erstellen Sie ein Programm zur Berechnung <strong>von</strong> quadratischen Gleichungen.<br />
Was das Programm können soll sehen Sie in den abgebildeten Boxen.<br />
Verwenden Sie als Datentyp double.<br />
Nennen Sie das Programm QuadratischeGleichung.java.<br />
Erstellen Sie ein Struktogramm zu Ihrem Programm.<br />
Hinweise:<br />
Diskriminante<br />
c ⎛ b ⎞<br />
D = − +<br />
a ⎜<br />
2a<br />
⎟<br />
⎝ ⎠<br />
2<br />
in <strong>Java</strong>: z.B. (a+b) 2 Math.pow((a+b),2)<br />
D < 0 es existiert keine Lösung<br />
D = 0 es existiert eine Lösung<br />
−b<br />
x1<br />
=<br />
2a<br />
D > 0<br />
−b<br />
es existieren zwei Lösungen x1<br />
= −<br />
2a<br />
D<br />
−b<br />
x2<br />
= +<br />
2a<br />
D<br />
in <strong>Java</strong>: z.B. x Math.sqrt(x)<br />
www.p-merkelbach.de − 16 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
Struktogramm<br />
QuadratischeGleichung.java<br />
double --> a,b,c,d<br />
char --> wiederholen<br />
Ausgabe:<br />
Berechnung quadratischer Gleichungen<br />
Geben Sie die Koeffizienten der quadratischen Gleichung in der Form a*x^2+b*x+c=0 ein:<br />
Ausgabe: a=<br />
Eingabe: a<br />
Ausgabe: b=<br />
Eingab: b<br />
Ausgabe: c=<br />
Eingab: c<br />
d = (-c/a)+(b/2a)^2<br />
J<br />
d
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
DezimalInBinär.java<br />
int --> zahl, dezimalzahl, rest<br />
String --> binärzahl<br />
Ausgabe:<br />
Umrechnung <strong>von</strong> Dezimalzahlen in Binärzahlen<br />
Ausgabe:<br />
Geben Sie die Dezimalzahl ein:<br />
Eingabe:<br />
dezimalzahl<br />
rest = zahl modulo 2<br />
zahl = zahl / 2<br />
binärzahl = rest + binärzahl<br />
Solange zahl > 0<br />
Ausgabe:<br />
Die Binaerzahl lautet: "binärzahl"<br />
www.p-merkelbach.de − 18 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
5. String-Methoden<br />
Zeichenketten werden in <strong>Java</strong> nicht <strong>mit</strong>tels eines elementaren Datentyps, sondern in Form eines<br />
Referenzdatentyps namens String darggestellt. Es gibt verschiedene Möglichkeiten ein String-<br />
Objekt zu erzeugen:<br />
String s1 = „abc“;<br />
String s2 = new String(„abc“);<br />
Da es sich bei den Strings s1 und s2 um Objekte handelt, sind es Referenzvariablen die auf<br />
unterschiedliche String-Objekte verweisen. Auch wenn s1 und s2 die gleiche Zeichenkette<br />
beinhaltet, liefern Vergleiche wie s1 == s2 immer false.<br />
Das kommt daher, weil beim Vergleich <strong>von</strong> Referenzvariablen nur die Referenzen und nicht die<br />
Objektinhalte verglichen werden.<br />
Um die Objektinhalte zu vergleichen benutzt man z.B. die Methode: s1.equals(s2).<br />
Die Methoden der Klasse java.lang.String:<br />
1 public class StringTest {<br />
2 public static void main (String[ ] args)<br />
3 String s1 = "Weihnachten";<br />
4 String s2 = "Veihnachten";<br />
5 String s3 = "Xeihnachten";<br />
6 String s4 = "WEIHNACHTEN";<br />
7 // Ausgabe<br />
8 System.out.println(s1);<br />
9 System.out.println(s1.charAt(4));<br />
10 System.out.println(s1.compareTo(s1));<br />
11 System.out.println(s1.compareTo(s2));<br />
12 System.out.println(s1.compareTo(s3));<br />
13 System.out.println(s1.endsWith("ten"));<br />
14 System.out.println(s1.equals(s2));<br />
15 System.out.println(s1.equalsIgnoreCase(s4));<br />
16 System.out.println(s1.indexOf("n"));<br />
17 System.out.println(s1.indexOf("ach"));<br />
18 System.out.println(s1.length());<br />
19 System.out.println(s1.replace('e','E'));<br />
20 System.out.println(s1.startsWith("Weih"));<br />
21 System.out.println(s1.substring(3));<br />
22 System.out.println(s1.substring(3,7));<br />
23 System.out.println(s1.toLowerCase());<br />
24 System.out.println(s1.toUpperCase());<br />
25 System.out.println(String.valueOf(1.5e2));<br />
26 }<br />
27 }<br />
Ergebnis der String-Methoden:<br />
Weihnachten<br />
n<br />
0<br />
1<br />
-1<br />
true<br />
false<br />
true<br />
4<br />
5<br />
11<br />
WEihnachtEn<br />
true<br />
hnachten<br />
hnac<br />
weihnachten<br />
WEIHNACHTEN<br />
150.0<br />
www.p-merkelbach.de − 19 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
6. Parametereingabe<br />
Parameter.java<br />
public class Parameter<br />
{<br />
// Aufruf: java Parameter Vorname Nachname<br />
public static void main(String argv[])<br />
{<br />
System.out.println("Hallo, " + argv[0] + "!");<br />
System.out.println(argv[1] + " ist ein schoener Name!");<br />
}//public static void main(String argv[])<br />
}//public class Parameter<br />
Configure OptionsJDK-Tools<br />
Run Application auswählen<br />
Default markieren<br />
Edit auswählen<br />
Parameters auswählen<br />
Bei Main (...) die Parameter eingeben<br />
Haken setzen<br />
www.p-merkelbach.de − 20 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
7. Inkrement / Dekrement<br />
Inkrement_Dekrement.java<br />
public class Inkrement_Dekrement<br />
{<br />
public static void main(String argv[])<br />
{<br />
//Deklaration <strong>von</strong> Variablen<br />
int a = 0;<br />
int b = 7;<br />
//<br />
System.out.println("a = " + a);<br />
System.out.println("b = " + b);<br />
System.out.println();<br />
//Postinkrement<br />
b = 7;<br />
a = 3 + b++;<br />
System.out.println("Postinkrement");<br />
System.out.println("a = " + a);<br />
System.out.println("b = " + b);<br />
System.out.println();<br />
//Präinkrement<br />
b = 7;<br />
a = 3 + ++b;<br />
System.out.println("Praeinkrement");<br />
System.out.println("a = " + a);<br />
System.out.println("b = " + b);<br />
System.out.println();<br />
//Postdekrement<br />
b = 7;<br />
a = 3 + b--;<br />
System.out.println("Postdekrement");<br />
System.out.println("a = " + a);<br />
System.out.println("b = " + b);<br />
System.out.println();<br />
//Prädekrement<br />
b = 7;<br />
a = 3 + --b;<br />
System.out.println("Praedekrement");<br />
System.out.println("a = " + a);<br />
System.out.println("b = " + b);<br />
System.out.println();<br />
}//public static void main(String argv[])<br />
}//public class Inkrement_Dekrement<br />
www.p-merkelbach.de − 21 − © <strong>Merkelbach</strong>
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
8. For-Schleifen<br />
8.1. Sterne0.java<br />
import java.io.*;<br />
public class Sterne0<br />
{<br />
public static void main(String argv[])throws IOException<br />
{<br />
//********Vereinbarungen**************************************************<br />
int anzahl;<br />
//int i; globale Variable<br />
BufferedReader input = new BufferedReader(new<br />
InputStreamReader(System.in));<br />
//********Anweisungen******************************************************<br />
System.out.println("Geben Sie die Anzahl der Zeilen ein:");<br />
System.out.print("Anzahl = ");<br />
anzahl=Integer.parseInt(input.readLine());<br />
}<br />
//System.out.println(i);<br />
System.out.println("Programmende.");<br />
}//public static void main<br />
}//class<br />
8.2. Sterne1.java<br />
Geben Sie die Anzahl<br />
for (int i=1; i
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
8.3. Sterne2.java<br />
import java.io.*;<br />
public class Sterne2<br />
{<br />
public static void main(String argv[])throws IOException<br />
{<br />
//********Vereinbarungen**************************************************<br />
int anzahl;<br />
BufferedReader input = new BufferedReader(new<br />
InputStreamReader(System.in));<br />
//********Anweisungen******************************************************<br />
System.out.println("Geben Sie die Anzahl der Zeilen ein:");<br />
System.out.print("Anzahl = ");<br />
anzahl=Integer.parseInt(input.readLine());<br />
for (int k=1; k
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
8.4. Sterne3.java<br />
import java.io.*;<br />
public class Sterne3<br />
{<br />
public static void main(String argv[])throws IOException<br />
{<br />
//********Vereinbarungen**************************************************<br />
int anzahl;<br />
BufferedReader input = new BufferedReader(new<br />
InputStreamReader(System.in));<br />
//********Anweisungen******************************************************<br />
System.out.println("Geben Sie die Anzahl der Zeilen ein:");<br />
System.out.print("Anzahl = ");<br />
anzahl=Integer.parseInt(input.readLine());<br />
for (int k=0; k
<strong>Programmierung</strong> <strong>mit</strong> <strong>Java</strong><br />
8.5. Sterne4.java<br />
import java.io.*;<br />
public class Sterne4<br />
{<br />
public static void main(String argv[])throws IOException<br />
{<br />
//********Vereinbarungen**************************************************<br />
int anzahl;<br />
BufferedReader input = new BufferedReader(new<br />
InputStreamReader(System.in));<br />
//********Anweisungen******************************************************<br />
System.out.println("Geben Sie die Anzahl der Zeilen ein:");<br />
System.out.print("Anzahl = ");<br />
anzahl=Integer.parseInt(input.readLine());<br />
for (int k=0; k