Programmierung mit Java

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