2 - ProzeduraleElemente Informatik

2.
Prozedurale Elemente
Programmieren für startING

Joachim Orb
Foliensatz von Klaus Dorer
Klaus Dorer & Joachim Orb Prozedurale Elemente

Hochschule Offenburg University of Applied Sciences
Inhalt
 Datentypen, Konstanten und Variablen

 Operatoren und Ausdrücke
 Verzweigungen
 Schleifen
 Ziele
 Variablen deklarieren und verändern können
 Mit Operatoren und Ausdrücke umgehen können
 Programmabläufe bedingt ausführen können
 Programmteile wiederholt ausführen lassen

Datentypen in Java
Datentypen
Referenz Typen Primitive Typen
Classes Interfaces Arrays boolean Numerisch
Ganzzahl Kommazahl
char byte short int long float double

Einschub: EBNF
 Wir benötigen eine Schreibweise zur Darstellung der Grammatik

 Erweiterte Backus-Naur-Form
Verwendung Zeichen
Definition =
Aufzählung ,
Endezeichen ;
Alternative |
Option […]
Optionale Wiederholung {…}
Terminalsymbol "…"
 Beispiel: EBNF Syntax für eine e-mail Adresse
emailAdresse = Text "@" Adresse;
Adresse = Text "." Text;
Text = {"a".."z" | "A".."Z" | "0".."9" | "." | "-" | "_"};

boolean Datentyp
Typ Werte Speicher

boolean true, false 8 bit = 1 byte
EBNF Syntax für boolean Konstanten

booleanKonstante = “true“ | “false“;
 Beispiele
 true, false
 Gegenbeispiele
 1, True falsch!
 Wird verwendet, um Wahrheitswerte zu repräsentieren
 Ergebnis von ‚ist 5 > 7?‘ ->false

Ganzzahlige Datentypen
Typ maximal minimal Speicher

byte 127 -128 8 bit
short 32767 -32768 16 bit
int 2147483647 -2147483648 32 bit
long 9223372036854775807 -9223372036854775808 64 bit
Ganzzahl = [Präfix] [“+“|“-“] Ziffern [Suffix];

Ziffern = “1“..“9“ {“0“..“9“} (*“a“..“f“*);
Suffix = “l“ | “L“;
 Beispiele
 4, -15, 0, +12345L
 Gegenbeispiele
 +-3, 12 34, 12a4 falsch!
byte short int long

Gleitkommazahlen
Typ maximal kleinster positiver Wert Länge
float ~3.4E+038 ~1.4 E -045 32 bit
double ~1.8E308 ~4.9E-324 64 bit
FloatKonstante = [“+“|“-“] [Ziffern] [“.“] [Ziffern] [Exponent] [Suffix];

Ziffern = “1“..“9“ {“0“..“9“};
Exponent = (“e“|“E“) [“+“|“-“] Ziffern;
Suffix = “f“ | “F“ | “d“ | “D“;
 Beispiele
 3.14, .075, -20.0f, +1.527
 1.25e-8, .425e17
 Gegenbeispiele
 2.5e3.5, e17, 1.2e200f falsch!
float double
Zuweisungen von Zahlen
 Zuweisungen von unterschiedlichen Datentypen müssen

kompatibel sein
 Kein Bier im Rotweinglas!
 Umschenken von 0,3 nach 0,5 geht
 Umschenken von 0,5 nach 0,3 kann mit Verlusten verbunden sein...
 Also boolean b; float f; double d; int i; short s;
b = i; // verboten(kein Bier im Rotweinglas)
f = i; // ok (0,3 nach 0,5)
i = f; // verboten (0,5 nach 0,3)
i = (int)f; // ok (type cast, eventuell Verlust)
f = 2.3; // verboten (2.3 ist double)
d = 2.3; // ok
s = i; // verboten
 Es gilt
double  float  long  int  short  byte
char Datentyp
Typ Werte Speicher

char Einzelnes Zeichen 16 bit
charKonstante = “ ‘ “ Zeichen “ ‘ “;
Zeichen = ein Zeichen des Unicode-Zeichensatzes;
 Beispiele
 'a', '1', '%', '\t', '\'', '\u03C0'
 Gegenbeispiele
 'ab', “a“, ' ' ' falsch!
 Java verwendet Unicode, um Zeichen zu repräsentieren

Datentyp String
StringKonstante = “ " “ {Zeichen} “ " “;

Zeichen = ein Zeichen des Unicode-Zeichensatzes;
 Oft werden Zeichenketten (Strings) benötigt z.B. Name einer Person

 Beispiele
 "Oskar", "a", "12"
 String Operationen
 "Oskar" + "Little" // "OskarLittle"
 short x = 12;
String text = "Ergebnis:" + x; // "Ergebnis:12"
 "12" + "12" // Ergebnis?
 text.length() -> Wie viele Zeichen hat der String
 Kein primitiver Typ!
 Mehr dazu in Kapitel "Klassen und Objekte"
Ausgabe
public static void main(String[] args)
{
int age = 48;
System.out.print("Alter: ");
System.out.println(age);
System.out.println("Alter: " + age);
float groesse = 1.872f;
System.out.printf("Alter: %d Groesse: %4.2f %n", age, groesse);
}
 print verursacht keinen Zeilenumbruch am Ende

 printf erlaubt die Angabe von Format-Spezifizierern
 %d Platzhalter für Dezimalzahl
 %5d: mindestens 5 Stellen ausgeben, mit führenden Leerzeichen gefüllt
 %02d: mit führenden Nullen gefüllt
 %f Fließkommazahlen
 %10.2f: Ausgabe ist 10 Zeichen lang mit zwei Nachkommastellen
 %,.2f: Ausgabe erfolgt im Format 12.345,68 (abhängig von
Ländereinstellung)
 %s Zeichenketten (Strings), %n neue Zeile, …
Bezeichner
Bezeichner = "a..Z,$,_" {"a..Z,$,_,0..9, Unicodezeichen über 00C0"};
 Variablen, Methoden, Klassen und Schnittstellen werden benannt

 Groß- und Kleinbuchstaben werden streng unterschieden
 Beispiele
 auto, numberOfIndividuumsInPopulation, _TEXT
 Gegenbeispiele
 2mal3ist9 (beginnt mit einer Ziffer)
 pipi langstrumpf (Leerzeichen nicht erlaubt)
 HerrNilsson! (viele Sonderzeichen nicht erlaubt, hier !)
 class (reservierte Java Wörter nicht erlaubt)
 Konvention
 Beginnen mit einem Kleinbuchstaben
 Jedes neue Wort beginnt mit Großbuchstaben (Camel Case)

Variablen
 Deklaration:
<Typ> <Bezeichner>;
// aktuelles Alter
int age;
// Geschlecht (f oder m)
char gender;
// Ist Präsident (true oder false)
boolean isPresident;
// Gehaltsbonus
double bonus;
 Deklaration und Zuweisung: <Typ> <Bezeichner> = <Ausdruck>;

int age = 28;
double income = 93000.50;
char gender = 'f';
boolean isPresident = true;
 Nur Zuweisung
bonus = income + 3000.0d; <Bezeichner> = <Ausdruck>;
 Der Variablen links vom Gleichheitszeichen wird der Wert rechts zugewiesen
 Der Wert von income ändert sich nicht
 Vor der Verwendung muss einer Variablen ein Wert zugewiesen sein
Konstanten
 Initialisierte Variable deren Wert nicht mehr verändert werden kann

 Deklaration erfolgt wie eine Variable + Zusatz final
final <Typ> <Bezeichner> = <Ausdruck>;
final int MAX = 99;

final double PI = 3.141;
 Vorteile?

Operatoren - Arithmetik
 Division /
System.out.println(1 / 3.0); // 0.3333333333333333
System.out.println(1 / 3); // 0
 Operanden werden in den größten gemeinsamen Typ konvertiert
 Ist der eine Ganzzahl, wird eine ganzzahlige Division durchgeführt
 Division durch 0 ist nicht erlaubt
 Modulo %
int ergebnis1 = 9 % 5;
double ergebnis2 = 12.0 % 2.5;
 Gibt den Rest einer Division zurück
 Addition +, Subtraktion –, Multiplikation *
 Vorzeichen – (+)
int ergebnis3 = -5 + 2 * (ergebnis1 – 1);
 Es gilt Punkt vor Strichrechnung
 Mit Klammerung kann die Reihenfolge festgelegt werden

 Zuweisung mit Operation („Verbundoperator“)

int a = 5;
a += 3; // entspricht a = a + 3
 Es gilt generell für numerische Operatoren: a = a # (b) -> a #= b

 Achtung!: a *= 3 + 4 entspricht a = a * (3 + 4)
 Rundungsfehler
System.out.println(0.3 + 0.6); // 0.8999999999999999
 Fließkommazahlen haben eine begrenzte Genauigkeit, es treten

Rundungsfehler auf
 Überläufe
int a = 1000000000;
int b = 2000000000;
System.out.println(a + b); // -1294967296
 Die Summe aus a und b ist größer, als in einem int Platz hat

 Inkrement ++
int i = 10;
System.out.println(i++); // 10
System.out.println(i); // 11
 Steht der Operator nach dem Operand wird erst nach der Auswertung
des Ausdrucks um eins erhöht
int i = 10;
System.out.println(++i); // 11
System.out.println(i); // 11
 Steht der Operator vor dem Operand wird vor der Auswertung des
Ausdrucks um eins erhöht
 Dekrement --
 Dasselbe gilt für Dekrement: i --; -> i = i – 1;
 Verwenden sie Inkrement und Dekrement nicht in Verbindung mit
anderen Operatoren
 i++; //ok
 int j = 5 + ++i; // fehleranfällig
 Unterschiedliche Operanden
 Typkonvertierungen des „kleineren“ Operanden in den „größeren“
 Sonderregel: byte und short werden immer nach int konvertiert
 Beispiele
float f; double d; int i; short s;
f + i; // float
s + s; // int!!!
d + s; // double
f = i/3; // i/3 ist int!, der gesamte Ausdruck ist float

Operatoren – Vergleich
 Vergleichsoperatoren
int x = 5;
int y = 5;
boolean a = x > y; // a ist false
 <, >, >=, <= mit den erwarteten Bedeutungen
 Gleichheitsoperatoren
boolean b = x == y; // true
boolean c = (x = y); // Compilerfehler
 == Gleichheit
 != Ungleichheit
 Wichtig!
 Das einfache Gleichheitszeichen = ist eine Zuweisung deren Wert vom Typ
der Operatoren abhängt.
 Das doppelte Gleichheitszeichen == ist für den Vergleich von Werten (und
Referenzen) und das Ergebnis ist immer vom Typ boolean
 == und != sollten nicht für Fließkommazahlen angewendet werden (siehe
Rundungsfehler)

Übung: Arithmetische Operatoren
 Schreiben sie in Java int i = 10;

 speichern sie das Ergebnis in einer Variablen float r = 4.5f;
Aufgabe Lösung
Eins mehr als i
Das doppelte von i
Ist i eine gerade Zahl?
Die Fläche eines Kreises

mit Radius r
Den Mittelwert von i und r
Ihr Beispiel

Operatoren – Logische Verknüpfung
 Logische Operatoren boolean a boolean b !a a && b a || b
int x = 26; true true false true true

boolean a = (x < 1) || (x > 31); true false false false true
false true true false true
 a ist true, wenn eine der
beiden Bedingungen gilt false false true false false
 Klammern sind hier

nicht nötig
 ! Negation, && und, || oder
boolean b = x > 28 && x < 31;
 && und || sind sogenannte Kurzschluss-Operatoren
 Beide werden von links nach rechts ausgewertet
 &&: sobald der erste Operand false ist, kann das Ergebnis nur noch false
sein, die weitere Auswertung wird abgebrochen
 ||: sobald der erste Operand true ist, kann das Ergebnis nur noch true sein,
die weitere Auswertung wird abgebrochen
 x < 31 wird also gar nicht mehr geprüft
 x > 28 && < 31 funktioniert nicht

Übung: Boolsche Operatoren
 a,b,c: true oder false? int x = (siehe Tabelle unten);

boolean a = x > 0 && x <= 20;
boolean b = x < 7 || x > 19;
boolean c = !(b || a);
x a b c
-2
20

Operatoren – Priorität (hoch  niedrig)
 Primary (Ausdruck), Call, Literal, Arrayzugriff, new, this

 Unäre Operatoren ++, --, +, - (als Vorzeichen)
 Pre / Postfix ~, !, (type cast)
 Punktoperatoren *, /, %
 Strichoperatoren +, - (auch Zusammenfügen von Strings)
 Shift Operatoren <<, >>, >>>
 Relationale Operatoren <, <=, >, >=, instanceof
 Gleichheit Operatoren ==, !=
 Und (bitweise/logisch) &
 XOR ^
 Oder (bitweise/logisch) |
 Conditional Und &&
 Conditional Oder ||
 Ternärer Operator ?:
 Zuweisung =, *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=

Datentypen, Variablen, Operatoren
Typische Fehler
 Zuweisung falsch
= ist kein mathematisches Gleichheitszeichen.
Es macht einen Unterschied, was rechts und was
int laenge;
links steht. Links muss eine Variable stehen, der
5 = laenge;
der Wert rechts zugewiesen wird.
 Vergleich von Fließkommazahlen
float wert = 0.3f + 0.6f;
Kein Vergleich von
boolean ergebnis;
Fließkommazahlen mit == oder !=
ergebnis = (wert == 0.9f);
wegen Rundungsfehlern
// false (Rundungsfehler!)
 Überlauf
int zahl = 1234567890;
int zahl2 = 10 * zahl; Die Zahl wird zu groß und passt
// -539222988 (falsch) nicht in eine int Variable
 Priorität/Reihenfolge nicht beachtet
int a = 5; Das erste Plus fügt die Strings
int b = 3; „a+b=„ und „5“ zusammen.
String s = "a+b=" + a + b; Klammern nutzen, um die
// a+b=53 (unerwartet) Reihenfolge zu beeinflussen!
Kontrollfluss
 Block  Verschachtelung
// Blockanfang {
{ int var = 1;
... {
// Lokale Variable var // Fehler!
int var = 1; long value = number +1;
var++; long number = 5;
... double var; // Fehler!
} }
// Blockende value = 10L; // Fehler!
}
// Variable var nicht mehr
 Blöcke können beliebig tief
zugreifbar
geschachtelt werden
 Variablen sind erst ab ihrer
 Ein Block kann eine beliebige Deklaration verfügbar
Anzahl Statements beinhalten
 Zwei Variablen dürfen nicht
und ist selbst ein Statement
denselben Namen haben
 Blöcke sind Gültigkeitsbereiche
 Variablen sind nur innerhalb
für Variablen
eines Blocks und seiner einge-
schachtelten Blöcke sichtbar
Verzweigungen
if – Formale Beschreibung
 if führt Anweisungen bedingt aus

 <Ausdruck> muss immer vom Typ boolean sein (true oder false)
 <Anweisung> sollte immer ein Block sein (also mit { })
 else if kann beliebig oft vorkommen
 else kann, muss aber nicht vorkommen
Syntax
int x = 5;
int y = 10; if ( <Ausdruck1>) {
int ergebnis; <Anweisung1>
if (x == y) {
ergebnis = 0;
} [ else if (<Ausdruck2>) {
} else if (x < y) { <Anweisung2>
ergebnis = -1; } ]* [ else {
} else {
ergebnis = 1;
<Anweisung3>
} }]

Verzweigungen
Visual Paradigm for UML Standard Edition(Hochschule Offenburg)
if - Diagramme x--
 PAP Aktivitätsdiagramme (UML)
x=5; y=10;
x=5, y=10 ...
[else]
[x==y]
nein
x == y?
ja Aktion
Prozedural
y++;
[x==y]
y++
…
[x<y]
x=5, y=10 x++ ...
[else]
x--
[else]

Verzweigungen
if - Beispiele
 Die größere von zwei Zahlen in maximum schreiben

int a;
int b;
int maximum;
 Erweiterung
 Es soll die betragsmäßig größere Zahl ermittelt werden
 Zeichnen sie davon das Aktivitätsdiagramm bzw. den
Programmablaufplan

Verzweigungen
if – Typische Fehler
 Strichpunkt nach if
Beendet das if!
if (laenge == breite);
{ ergebnis = true wird immer ausgeführt.
ergebnis = true;
}
 Zuweisung statt Vergleich

Zuweisung!
heiss1 wird der Wert von heiss2
boolean heiss1 = false; zugewiesen. Das Ergebnis ist, was
boolean heiss2 = true; jetzt in heiss1 steht.
if (heiss1 = heiss2) {
System.out.println("heiss1 und heiss2 sind gleich");
}
Ohne Klammern gehört nur die erste
 Keine Block-Klammern Anweisung zum if!
if (laenge == breite) ergebnis = true wird immer ausgeführt.
System.out.println("lang wie breit");
ergebnis = true;

Verzweigungen
if - Übungen
 Prüfen, ob ein Rechteck ein Quadrat ist.

int laenge;
int breite;
boolean istQuadrat;
 Erweiterungen
 Prüfen sie auch, ob laenge und breite gültige Werte enthalten
 Was passiert, wenn die Parameter float sind?

Verzweigungen
switch – Formale Beschreibung
 switch erlaubt Mehrfachverzweigung

 <Ausdruck> muss vom Typ char, byte, short, int oder String sein
 Es können beliebig viele case Blöcke vorkommen
 default kann, muss aber nicht verwendet werden
 jedes switch kann auch als if-else dargestellt werden
Syntax
char x = 'b';
switch (x) {
case 'a': switch (<Ausdruck>) {
System.out.println("a"); [ case <Konstante>:
break; [<Anweisung>]*
case 'b':
System.out.println("b"); [break;] ]*
break; [ default:
default: [<AnweisungN>] ]
// Anything else
} }

Hochschule Offenburg
Aktion University of Applied Sciences
Verzweigungen
switch - Diagramme
"It is a"
[a]
[b] "It is b"
… ... ...
"It is c or
PAP d"
[c or d]
nein
a? "Anything
[else] else"
ja
Aktivitätsdiagramm
b? „It is a“
…? …

Verzweigungen
switch - Beispiele
 Steuerung eines Computerspiels mit der Tastatur

char taste;
switch (taste) {
case 'a': System.out.println("links"); break;
case 'd': System.out.println("rechts"); break;
case 'w': System.out.println("vor"); break;
case 's': System.out.println("zurueck"); break;
case 'f': System.out.println("feuern"); break;
default: System.out.println("unerlaubte Taste");
}
 Erweiterung
 Auch die Leertaste soll feuern
 Wie würde dasselbe mit einem if aussehen?

Verzweigungen
switch – Typische Fehler
 Break vergessen
switch (taste) {
case 'a':
System.out.println("links");
case 'd':
System.out.println("rechts");
}
Break fehlt!
Bei a wird links und rechts gefahren.

Schleifen
 Häufig müssen Dinge mehrfach durchgeführt werden

 Alle Konten eines Kunden anzeigen
 Musik abspielen, so lange das Ende des mp3 nicht erreicht ist
 Berechnung 10 mal wiederholen
 Drei Typen in Java
 Zählschleife: for
 Abweisungsschleife: while
 Durchlaufschleife: do while

Schleifen
for – Formale Beschreibung
 for Schleifen werden verwendet, wenn die Anzahl der Durchläufe

mitgezählt werden soll
 for wird ausgeführt, solange Ausdruck true ist
 <Ausdruck> wird vor jedem Durchlauf geprüft, muss vom Typ boolean sein
 <Initialisierung> wird nur einmal am Anfang durchgeführt
 <Updateliste> wird am Ende jedes Durchlaufs ausgewertet
int sum = 0;
for (int i = 1; i <= 4; i++) {
sum = sum + i;
}
Syntax
for ( [<Initialisierung>]; <Ausdruck>; [<Updateliste>]) {

[<Anweisung>]*
}

Schleifen
while – Formale Beschreibung
 while führt die Schleife so lange aus, wie Ausdruck true ist
 <Ausdruck> muss vom Typ boolean sein
 Auch wenn nur eine Anweisung wiederholt wird, sollte trotzdem ein
Block verwendet werden
 eine while Schleife kann auch gar nicht ausgeführt werden
Syntax
int sum = 0; while (<Ausdruck>) {
int i = 1;
while (i <= 4) { [<Anweisung>]*
sum = sum + i; }
i++;
}

Schleifen
do..while – Formale Beschreibung
 do..while führt die Schleife so lange aus, wie Ausdruck true ist
 Die Bedingung wird aber erst am Ende der Schleife geprüft
 <Ausdruck> muss vom Typ boolean sein
 Auch wenn nur eine Anweisung wiederholt wird, sollte trotzdem ein
Block verwendet werden
 eine do..while Schleife wird mindestens einmal ausgeführt
Syntax
int sum = 0; do {
int i = 1;
do { [<Anweisung>]*
sum = sum + i; } while (<Ausdruck>);
i++;
} while (i <= 4);

Schleifen
Schachtelung
 Schleifen sind Anweisungen und können geschachtelt werden

 Bei zwei Schleifen spricht man von der äußeren und der inneren Schleife
 Achtung Laufzeit!
for (int i = 0; i < 5; i++) {
for (int j = 0; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
 Jede for Schleife kann in eine while Schleife umgewandelt werden und
umgekehrt

Schleifen
Diagramme
 PAP
for und while do..while
… …
nein r=r+i
i<=4?
...
ja i++ ja
r=r+i
…
i++ "Anything
i<=4?
else"
 Aktivitätsdiagramm
…
nein
[else]
...
...
... r=r+i i++ ...
[else]
[i<=4]
[i<=4]
r=r+i i++

Schleifen
Typische Fehler
Die Schleife wird nie beendet, weil i

 Endlosschleifen nicht verändert wird (i++ fehlt hier)
while (i <= 4) {
oder die Bedingung falsch ist.
sum = sum + i;
}
 Falsche Anzahl Durchläufe

Die Schleife macht 11
for (int i = 0; i <= 10; i++) {
System.out.println(i); Durchläufe!
}

Schleifen
Übung
 Ausgabe aller Quadratzahlen von 0 bis 100.
 Ausgabe aller Teiler aller Zahlen von 1 bis 29

Methoden („Funktionen“)
 Programme werden schnell groß

 Aus verschiedenen Gründen unterteilt man Programme in kleinere
Einheiten
 Bessere Übersicht, geringere Komplexität
 Wiederverwendung
 Einfachere Wartbarkeit
 In prozeduralen Programmen sind die Mittel der Unterteilung
 Funktionen
 Module
 In objektorientierten Programmen
 Methoden (wie Funktionen, aber mit Kontext)
 Klassen (später)
 Pakete (später)
Methoden (statisch)
 Bestehen aus einem Methodenkopf und Methodenrumpf

 Kopf definiert Rückgabetyp, Name und optional Parameter
 Rumpf enthält Programmteil
Syntax
[static] <Rückgabetyp> <MethodenName>([<Parameterliste>])
{
<Methodenrumpf>
}
static int getMax(int x, int y)

{ Parameterliste
if (x > y) {
return x;
}
return y;
}
 x und y sind neue Variablen, die nur im Rumpf gelten
Methoden (statisch)
 Methodenkopf = „Signatur“ der Methode

 static (Bedeutung von statisch kommt später bei Objektorientierung)
 <Rückgabetyp>
 Typ des Rückgabewertes der Methode
 „void“ (=nichts) bei Methoden ohne Ergebnis
 <Methodenname>
 Dieser Name muss beim Aufruf der Methode verwendet werden
 <Parameterliste>
 Übergabe von Werten an Methode (optional)
 Jeweils Typ und Name, getrennt durch Komma, falls mehr als einer
 Jeder Parameter ist eine neue Variable, die innerhalb des Rumpfs verfügbar ist
 <Methodenrumpf>
 Codeblock, der beim Aufruf der Methode abgearbeitet wird
 mit return wird die Methode sofort verlassen, und das Ergebnis zurück
gegeben

Methoden (statisch)
 Aufruf (Verwendung)
 x in getMax(int x, int y) wird eine Kopie von a, y eine Kopie von b
Syntax
[<Ergebnis> = ] <Methodenname>([<Argumentliste>]);
public static void main(String[] args)

{
int a = 5;
int b = 10;
int result = getMax(a, b); Argumente
}
 Aufruf aus einer anderen Klasse

 (geht nur mit sog. public Methoden)
Syntax
[<Ergebnis> = ] <Klassenname>.<Methodenname>([<Argumentliste>]);
double result = Math.sin(x);

Methoden (statisch)
 Methodenüberladung
 Es kann mehrere Methoden mit dem gleichen Namen geben, wenn die
Parameterliste unterschiedlich ist
static int getMax(int x, int y, int z)
{
…
}
 auch ein unterschiedlicher Typ reicht
static String getMax(String s1, String s2)
{
… // alphabetischer Vergleich
}
 beim Aufruf ist klar, welche aufgerufen wird

int result = getMax(4 + 2, 5, 7);
String result = getMax("abc", "xyz");

Methoden
Diagramm
 Programmablaufplan
getMax
r=r+i i++
 Aktivitätsdiagramm
x=5, y=10 getMax

Methoden
Typische Fehler
 Parameter sind Kopien!

static int getMax(int x, int y)
{ Die Zuweisung ist möglich (sollte aber
x = 7; vermieden werden). Sie verändert aber
}
nicht den Wert von a des Aufrufers
…
int result = getMax(a, b);

Methoden
Übung
 Eine Methode, die „Bildschirm“ auf den Bildschirm ausgibt.
 Ein Aufruf dieser Methode
 …, die eine übergebene Zahl an den übergebenen String anhängt

und zurück gibt
 Ein Aufruf dieser Methode

Zusammenfassung
 Schlüsselwörter
 boolean, byte, short, int, long, char, float, double
 final
 if, else, switch, case, default, break
 for, while, do
 return, void
 Literale
 true, false
 Übungen
 Schreiben Sie ein Programm, das die Zahlen von 0 bis 10 ausgibt
 .. Programm, das alle Rest-frei durch 7 teilbaren Zahlen von 0 bis 100 ausgibt
 .. Programm, das prüft ob ein Jahr ein Schaltjahr ist
 .. Programm, das Zeichen als Vokal oder Konsonant klassifiziert (switch-case)
 ..(effizientes) Programm, das die ersten n Primzahlen berechnet

2 - ProzeduraleElemente Informatik

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

2 - ProzeduraleElemente Informatik

Hochgeladen von

Copyright:

Verfügbare Formate

2.

Programmieren für startING

Klaus Dorer & Joachim Orb Prozedurale Elemente

 Datentypen, Konstanten und Variablen

Klaus Dorer & Joachim Orb Prozedurale Elemente

Referenz Typen Primitive Typen

Classes Interfaces Arrays boolean Numerisch

char byte short int long float double

Klaus Dorer & Joachim Orb Prozedurale Elemente

 Wir benötigen eine Schreibweise zur Darstellung der Grammatik

Klaus Dorer & Joachim Orb Prozedurale Elemente

Typ Werte Speicher

EBNF Syntax für boolean Konstanten

Klaus Dorer & Joachim Orb Prozedurale Elemente

Typ maximal minimal Speicher

Ganzzahl = [Präfix] [“+“|“-“] Ziffern [Suffix];

byte short int long

Typ maximal kleinster positiver Wert Länge

float ~3.4E+038 ~1.4 E -045 32 bit

double ~1.8E308 ~4.9E-324 64 bit

FloatKonstante = [“+“|“-“] [Ziffern] [“.“] [Ziffern] [Exponent] [Suffix];

Zuweisungen von Zahlen

 Zuweisungen von unterschiedlichen Datentypen müssen

Typ Werte Speicher

Klaus Dorer & Joachim Orb Prozedurale Elemente

StringKonstante = “ " “ {Zeichen} “ " “;

 Oft werden Zeichenketten (Strings) benötigt z.B. Name einer Person

 print verursacht keinen Zeilenumbruch am Ende

Bezeichner = "a..Z,$,_" {"a..Z,$,_,0..9, Unicodezeichen über 00C0"};

 Variablen, Methoden, Klassen und Schnittstellen werden benannt

Klaus Dorer & Joachim Orb Prozedurale Elemente

 Deklaration und Zuweisung: <Typ> <Bezeichner> = <Ausdruck>;

 Initialisierte Variable deren Wert nicht mehr verändert werden kann

final <Typ> <Bezeichner> = <Ausdruck>;

final int MAX = 99;

Klaus Dorer & Joachim Orb Prozedurale Elemente

Klaus Dorer & Joachim Orb Prozedurale Elemente

 Zuweisung mit Operation („Verbundoperator“)

 Es gilt generell für numerische Operatoren: a = a # (b) -> a #= b

 Fließkommazahlen haben eine begrenzte Genauigkeit, es treten

Klaus Dorer & Joachim Orb Prozedurale Elemente

Klaus Dorer & Joachim Orb Prozedurale Elemente

Klaus Dorer & Joachim Orb Prozedurale Elemente

Übung: Arithmetische Operatoren

 Schreiben sie in Java int i = 10;

Eins mehr als i

Das doppelte von i

Ist i eine gerade Zahl?

Die Fläche eines Kreises

Den Mittelwert von i und r

Klaus Dorer & Joachim Orb Prozedurale Elemente

Operatoren – Logische Verknüpfung

 Logische Operatoren boolean a boolean b !a a && b a || b

int x = 26; true true false true true

 Klammern sind hier

Klaus Dorer & Joachim Orb Prozedurale Elemente

Übung: Boolsche Operatoren

 a,b,c: true oder false? int x = (siehe Tabelle unten);

Klaus Dorer & Joachim Orb Prozedurale Elemente

Operatoren – Priorität (hoch  niedrig)

 Primary (Ausdruck), Call, Literal, Arrayzugriff, new, this

Klaus Dorer & Joachim Orb Prozedurale Elemente

 if führt Anweisungen bedingt aus