Programmierung mit Java.pdf - von P. Merkelbach

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 



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 Java- 

Interpreter (Virtuelle Maschine) passend zum vorliegenden Betriebssystem übersetzt. 

Hardware 1 Hardware 2 

Java-Interpreter Java-Interpreter java.exe 

Bytecode 

HelloWorld.class 

Java-Compiler 

javac.exe 

Quellcode 

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 



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 JDK- 

Ordner 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 



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. 



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; 

//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 



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(d1); 

System.out.println(bo1); 

System.out.println(c1); 




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 

Modulo bei Ganzzahldivision % c=a%b a=5 b=3 c=2 (Rest) 

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() 



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: 


bei einer Parallelschaltung 

r1 = 10 Ohm 

r2 = 20 Ohm 

Verarbeitung: 

rges = (r1 * r2)/(r1 + r2) 

Ausgabe: 


Ohm. 



3. Benutzereingaben und formatierte Ausgaben 

import java.text.DecimalFormat; 

import java.util.Scanner; 

public class Programmname 

{ 


{ 

//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. 



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. 

Reihenschaltung2.java 

Ausgabe: 


bei einer Reihenschaltung 

Ausgabe: 

Geben Sie den Widerstand R1 in 

Ohm ein: 

Eingabe: 

r1 

Ausgabe: 


Ohm ein: 

Eingabe: 

r2 

Verarbeitung: 


Ausgabe: 


Ohm. 

Parallelschaltung2.java 

Ausgabe: 


bei einer Parallelschaltung 

Ausgabe: 


Ohm ein: 

Eingabe: 

r1 

Ausgabe: 


Ohm ein: 

Eingabe: 

r2 

Verarbeitung: 

rges = (r1 * r2)/(r1 + r2) 

Ausgabe: 


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. 



4.1. Sequenz (Folgeanweisung) 

Struktogramm 

Anweisung 1 

Anweisung 2 

Anweisung 3 

Programmablaufplan (PAP) 

Anweisung 1 

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) 

Einseitige 

Auswahl 

Bedingung 

Ja 

Nein 

Anweisung % 

Bedingung 

Ja 

Anweisung 

Nein 


if (Bedingung) Anweisung; 

Zweiseitige 

Auswahl 

Bedingung 

Ja 

Nein 

Anweisung 1 Anweisung 2 

Ja 

Bedingung 

Nein 

Anweisung 1 Anweisung 2 


if (Bedingung) 

{ 

Anweisung 1; 

} 

else 

{ 

Anweisung 2; 

} 



4.3. Mehrfachauswahl 

Mehrfache 

Auswahl 

1 

2 

3 

c 

4 

Sonst 

c 

Anw Anw Anw Anw Anw 

1 2 3 4 5 

Anw 1 

Anw 2 Anw 3 Anw 4 Anw 5 


switch(c) 

{ 

case wert1: Anweisung1; break; 



default: Anweisung5; 

} 

4.4. Repetition (Wiederholungsanweisung, Schleife) 

Kopfgesteuerte 

Schleife 

Solange Bedingung (Wahr) 

Bedingung 

Falsch 

Anweisung 

Wahr 

Anweisung 

Die Bedingungsprüfung wird auf jeden Fall einmal durchgeführt! 


WHILE (Bedingung) Anweisung; 

Fußgesteuerte 

Schleife 

Anweisung 

Solange Bedingung (Wahr) 

Wahr 

Anweisung 

Bedingung 

Die Anweisung wird das erste Mal ohne Bedingungsprüfung durchgeführt! 

Falsch 


DO 

{ 

Anweisung1; ...Anweisung n; 

} 

while (Bedingung); 



4.5. Zählschleife 

Für Zähler = i Bis k 

Anweisung 

Zähler = i 

Zähler < k 

Wahr 

Anweisung 

Zähler = Zähler + 1 

Falsch 


for (Zähler=Anfangswert; Zähler b true 

=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 && cb || 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. 



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: 


Wenn auswahl = "R" oder "r" 

J 

Verarbeitung: 

rges = (r1 * r2)/(r1 + r2) 

Ausgabe: 

Der Gesamtwiderstand beträgt "rges" Ohm. 

Wenn auswahl = "P" oder "p" 

Ausgabe: 

Fehlerhafte Eingabe! 

N 

N 



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 

J 

Verarbeitung: 


Solange wiederholen = "J" oder "j" 

Wenn auswahl = "R" oder "r" 

Ausgabe: 

Der Gesamtwiderstand beträgt "rges" Ohm. 

Ausgabe: 

Möchten Sie das Programm wiederholen? 

Eingabe: 

wiederholen 

J 

Verarbeitung: 

rges = (r1 * r2)/(r1 + r2) 

Wenn auswahl = "P" oder "p" 

Ausgabe: 

Fehlerhafte Eingabe! 

N 

N 



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 

c ⎛ b ⎞ 

D = − + 

a ⎜ 

2a 

⎟ 

⎝ ⎠ 

2 

in Java: z.B. (a+b) 2 Math.pow((a+b),2) 

D < 0 es existiert keine Lösung 

D = 0 es existiert eine Lösung 

−b 

x1 

= 

2a 

D > 0 

−b 

es existieren zwei Lösungen x1 

= − 

2a 

D 

−b 

x2 

= + 

2a 

D 

in Java: z.B. x Math.sqrt(x) 



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 

J 

d


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" 



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 String- 

Objekt 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 public class StringTest { 

2 public static void main (String[ ] args) 

3 String s1 = "Weihnachten"; 

4 String s2 = "Veihnachten"; 

5 String s3 = "Xeihnachten"; 

6 String s4 = "WEIHNACHTEN"; 

7 // Ausgabe 

8 System.out.println(s1); 

9 System.out.println(s1.charAt(4)); 

10 System.out.println(s1.compareTo(s1)); 



13 System.out.println(s1.endsWith("ten")); 

14 System.out.println(s1.equals(s2)); 

15 System.out.println(s1.equalsIgnoreCase(s4)); 

16 System.out.println(s1.indexOf("n")); 

17 System.out.println(s1.indexOf("ach")); 

18 System.out.println(s1.length()); 

19 System.out.println(s1.replace('e','E')); 

20 System.out.println(s1.startsWith("Weih")); 

21 System.out.println(s1.substring(3)); 

22 System.out.println(s1.substring(3,7)); 

23 System.out.println(s1.toLowerCase()); 

24 System.out.println(s1.toUpperCase()); 

25 System.out.println(String.valueOf(1.5e2)); 

26 } 

27 } 

Ergebnis der String-Methoden: 

Weihnachten 

n 

0 

1 

-1 

true 

false 

true 

4 

5 

11 

WEihnachtEn 

true 

hnachten 

hnac 

weihnachten 

WEIHNACHTEN 

150.0 



6. Parametereingabe 

Parameter.java 

public class Parameter 

{ 

// Aufruf: java Parameter Vorname Nachname 


{ 

System.out.println("Hallo, " + argv[0] + "!"); 

System.out.println(argv[1] + " ist ein schoener Name!"); 


}//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 



7. Inkrement / Dekrement 

Inkrement_Dekrement.java 

public class Inkrement_Dekrement 

{ 


{ 

//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"); 




//Präinkrement 

b = 7; 

a = 3 + ++b; 

System.out.println("Praeinkrement"); 




//Postdekrement 

b = 7; 

a = 3 + b--; 

System.out.println("Postdekrement"); 




//Prädekrement 

b = 7; 

a = 3 + --b; 

System.out.println("Praedekrement"); 





}//public class Inkrement_Dekrement 



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()); 

} 

//System.out.println(i); 

System.out.println("Programmende."); 

}//public static void main 

}//class 


Geben Sie die Anzahl 

for (int i=1; i





{ 


{ 


int anzahl; 



//********Anweisungen****************************************************** 




for (int k=1; k





{ 


{ 


int anzahl; 



//********Anweisungen****************************************************** 




for (int k=0; k





{ 


{ 


int anzahl; 



//********Anweisungen****************************************************** 




for (int k=0; k

Programmierung mit Java.pdf - von P. Merkelbach

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?