3. Anatomie eines imperativen Java- Programms

3. Anatomie eines imperativen JavaProgramms
3.1 Algorithmus und Pseudocode
3.2 Java-Implementierung
3.3 Organisation von Java-Programmen
3.4 Dokumentation und Konventionen
3.5 Ein Programm in PASCAL
Beispielalgorithmus Primzahlbestimmung
Aufgabe: Bestimme alle Primzahlen ≤ max
Algorithmus:
2 ist Primzahl.
( Prüfe alle [ungeraden] Zahlen i = 3,5,…max :
( Für alle Primzahlen j < i : prüfe
i ∈ N ⇒ n eindeutig
als Produkt von Primob i durch j < i teilbar,
zahlen darstellbar.
wenn ja dann ist i keine Primzahl
und mache mit nächstem i weiter )
wenn i durch kein j teilbar merke i als Primzahl. )
Gib alle gemerkten Primzahlen aus.
Wie "merkt" man sich die gefunden Primzahlen?
Details hängen (teilweise) von Programmiersprache ab.
hs / fub - alp2-03 2
Konkretisierung
"Pseudocode"-Sprache:
Befehle:
<variable> = <ausdruck>
for i=n..m mit n,m natürliche Zahlen
while (<condition> ) {P}
if (<condition>) {P1} else {P2}
output(<number>)
Datenstruktur "Feld": benannte endliche Folge gleichartiger
Variablen, z.B. für ganze Zahlen boolean:
boolean array [1..k] <name>
mit Adressierung der i-ten Variable durch <name> [i]
hs / fub - alp2-03 3
Algorithmus im Pseudocode
boolean array [1..max] isPrime; //Vereinbarung
isPrime[2] = true;
i=3;
while i < max { // pruefe ob i prim
for j = 3..(i DIV 2) {
if isPrime[j] &&(i MOD j) = 0
{isPrime[i]=false;
goto increment}
Prim-Test:
}
sobald ein
isPrime [i]=true;
Teiler von i
increment: i=i+2
gefunden, weiter
}
mit i+2
for i=2..max {
if isPrime[i]{output(i)};
}
hs / fub - alp2-03 4
Pseudocode
boolean array [1..max] isPrime;
isPrime[2] = true;
i=3;
while i < max {
for j = 3..(i DIV 2) {
if(isPrime[j]&&(i MOD j)) = 0
{isPrime[i]=false;
goto increment}
}
isPrime [i]=true;
increment: i=i+2
}
for i=2..max {
if isPrime[i]{output(i)};
}
int i, max;
boolean hasNoFactor
max = kbdInput.readInt();
boolean[] isPrime =
new boolean[max + 1];
isPrime[2]=true;
i = 3;
while (i <= max) {
hasNoFactor = true;
for (int j = 3; j <= i/2; j++)
if (isPrime[j] && (i % j) == 0){
hasNoFactor = false;
break;
}
if (hasNoFactor){
isPrime[i] = true;
}
i=i+2;
}
Java-Code
hs / fub - alp2-03 5
Codierung in Java
int i, max;
boolean hasNoFactor
max = kbdInput.readInt();
boolean[] isPrime =
new boolean[max + 1];
isPrime[2]=true;
i = 3;
while (i <= max) {
hasNoFactor = true;
for (int j = 3; j <= i/2; j++)
if (isPrime[j] && (i % j) == 0) {
hasNoFactor = false;
break;
}
if (hasNoFactor){
isPrime[i] = true;
}
i=i+2;
}
Beachte:
kein goto <marke>
Wesentliche Merkmale:
• Variablen müssen mit
Typ vereinbart werden
• Felder müssen entsprechend ihrer Größe
erzeugt werden.
• Anweisungen werden
mit ';' abgeschlossen.
• for-Schleife mit
Anfangswert, Maximalwert und Inkrement.
… und sonst
• MOD : %
• {…} kann entfallen,
wenn nur ein Befehl
hs / fub - alp2-03 6
Klassen (statisch)
Java-Klassen
enthalten Vereinbarungen von Variablen und Methoden,
vorläufig mit static Attribut.
class Myclass {
static int myVariable;
static int myMethod(int param1, int param2){
...
}
public static void main(string [] args ) {
…
}
hs / fub - alp2-03 7
Klassen und Methode main
z
z
Vorläufig dienen Klassen nur als syntaktische Klammer
für ein Programm
Ein (statisches) Java-Programm ist eine Klasse mit
als static gekennzeichneten Vereinbarungen von
Methoden und Daten (Variablen) und der
ausgezeichneten Methode
public static void main (<optionale
Eingabeparameter>){
... <Code>...}
static
Typ des Rückgabewertes der
~ muss nicht
Methode. Wenn keine Rückgabe: void
während Programmausführung (=dynamisch)
erzeugt werden.
hs / fub - alp2-03 8
class Primes {
public static void main(String[] args) {
int i, max, numberOfPrimes = 1;
max = kbdInput.readInt();
boolean[] isPrime = new boolean[max + 1];
isPrime[2]=true;
i = 3;
while (i <= max) {
public
...
~ darf von jedem
}
ausgeführt werden.
for (i = 2; i <= max; i++){
Ausgabe:
if (isPrime[i])
System.out.print(…)
{System.out.print(i + ", ");
}
}
}
}
Hier: nur eine Methode (main).
hs / fub - alp2-03 9
Java Programmorganisation
import java.util.*;
import SimpleIO.kbdInput;
class Primes{...}
z
z
z
Klassen können zu Paketen (package)
zusammengefasst werden
benötigte Pakete oder einzelne Klassen werden
importiert
Java besitzt eine äußerst reichhaltige
Klassenbibliothek (siehe
http://java.sun.com/j2se/1.5.0/docs/api/)
hs / fub - alp2-03 10
Ein einfaches Paket
package SimpleIO;
import java.io.BufferedReader;
...
public class kbdInput {...
Pakete sind
benannt
Importe aus der
Java-StandardBibliothek
Eine Klasse des
Pakets SimpleIO
public static int readInt(String prompt){
Eine Methode
... }
der Klasse
...
KeyboardInput
}
(kbdInput)
Das Paket SimpleIO steht auf der Webseite (Software) zur Verfügung.
hs / fub - alp2-03 11
Kommentare und Dokumentation
class Primes {
/**
* Imperative Programm in Java:
* Algorithmus zur Bestimmung der Primzahlen bis max.
* @author HS
* @version 0.1
*/
public static void main(String[] args) // hier beginnt es
{...}
}
Java kennt drei Arten von Kommentaren:
1. einzeiliger Kommentar: alles nach bis Zeilenende //
2. Mehrzeiliger Kommentar: zwischen /*
und */
3. Dokumentationskommentar zwischen /** und */
hs / fub - alp2-03 12
Dokumentation
z
z
z
Klassen und ihre Methoden werden mit den
Dokumentationskommentare in html-Seiten
umgewandelt (Werkzeugprogramm: javadoc)
Dokumentationskommentare stehen vor dem
Objekt, das sie beschreiben
@ leitet ein Dokumentationsmakro ein, das
von javadoc gesondert behandelt wird,
Beispiele:
@author
@version
@param: Beschreibung von Parametern
@return: Beschreibung des Ergebnis
… und viele mehr.
hs / fub - alp2-03 13
Beispiel
Dokumentationskommentar mit HTML-Code
/**
* This class represents an Internet Protocol (IP) address.
* <p>
* Applications should use the methods <code>getLocalHost</code>,
* <code>getByName</code>, or <code>getAllByName</code> to
* create a new <code>InetAddress</code> instance.
* @author Chris Warth
* @version 1.42, 02/23/97
* @see java.net.InetAddress#getAllByName(java.lang.String)
* @see java.net.InetAddress#getByName(java.lang.String)
* @see java.net.InetAddress#getLocalHost()
•
@since JDK1.0
*/
siehe auch http://java.sun.com/j2se/javadoc/
hs / fub - alp2-03 14
Kodierkonventionen
Zentrale Forderung: Übersichtlichkeit des Codes
Namensgebung
- Klassenbezeichner beginnt mit Großbuchstabe(*) Primes
eine Klasse pro Datei (im Allgem.), <Klassenname>.java
- Methodennamen mit Kleinbuchstaben pruefen
(Achtung: Java unterscheident Groß / Kleinschreibung)
- Variablenbezeichner: klein,
max
- Konstanten: nur Großbuchstaben. MAX
- Zusammengesetzte Bezeichner: Wortanfänge groß
isPrime
- Sprechende Namen verwenden! nicht: isP
- Englische / deutsche Bezeichner: Geschmacksache
(*) kbdInput und fileInput aus SimpleIO halten sich nicht an die Konventionen :(
hs / fub - alp2-03 15
Kodierkonventionen
Anweisungen, Ausdrücke
- pro Zeile eine Anweisung
arg1 = arg0++;
- Klammerung von Anweisungen etc:
<Schlüsselwort>… {
<eingerückte Anweisungen auf mehreren Zeilen> …
}
if (arg > max) {
arg--;
Log.error("arg=",
}
else {
arg = arg0;
}
arg);
Geschweifte Klammern in
Fallunterscheidungen, Schleifen etc
immer setzen, auch wenn nicht
zwingend
hs / fub - alp2-03 16
Kodierkonventionen
Entwicklungsumgebungen
Sind hilfreich bei der Einhaltung von Formatierkonventionen
In dieser Veranstaltung:
Undogmatische Codierung, stilvolle Anwendung von
Konventionen, aber unverzichtbar:
- Einrückungen
- Bezeichnerregeln
siehe auch
http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html
hs / fub - alp2-03 17
Zum Vergleich: die imperative Sprache PASCAL
program eratosthenes;
const max = 10000;
var a : array[1..max] of boolean;
procedure eratos;
var i,j : longint;
begin
a[1]:=false;
for i:=2 to max do
a[i]:=true;
for i:=2 to max div 2 do
if a[i] then
for j:=2 to max div i do
a[i*j]:=false;
writeln;
{Ausgabe ...}
end;
Kleinere syntaktische
Unterschiede (bei
imperativem Programmierstil)
• Variablen müssen vorab
vereinbart werden
• begin…end statt {…}
• Syntax for / while
unterscheidet sich
• Nicht objektorientiert
Kommentarbegrenzer
begin
write('Calculating the Prime Numbers from 1 to ',max,'...');
eratos;
end.
hs / fub - alp2-03 18
Warnung
Java ist eine objektorientierte Programmiersprache, in
der man auch imperative programmieren kann.
Programm für dieses Semester:
z Imperative Programmierung mit Java
z Programmiermethodik (imperativ)
z Einführung in die objektorientierte Programmierung
hs / fub - alp2-03 19