FreitagsrundenWiki - Benutzerbeiträge [de]

Informatik 4 (StuPO90)/Semaphoren

2006-05-22T10:35:53Z

192.168.23.194: /* 4. "Priority" */

= Eine "Pattern Language" für die Benutzung von Semaphoren =
::(Nach http://c2.com/cgi/wiki?PatternLanguage)

Dafür zu sorgen, dass mehrere nebenläufige Prozesse korrekt miteinander arbeiten, ist erstaunlich schwierig. Speziell Mehrseitige Synchronisation bereitete mir beim Verstehen und Erklären besondere Probleme. Um die dabei auftretenden Probleme übersichtlicher zu erklären, habe ich diese "Pattern Language" formuliert.

Ich würde mich sehr über Feedback (mhaecker at cs.tu-berlin.de) zu den Beispielen und Formulierungen freuen.

Folgende Probleme werden behandelt:
* Locking für kritische Sektionen
* Locking für beschränkten Zugriff (n clients)
* Locking zum gegenseitigen Ausschluss von zwei Gruppen
* Locking für Priorisierung einer von mehreren Gruppen
* Einseitige Synchronisation

Zu diesem Zweck werden hier in der Vorlesung Semaphoren eingesetzt, die eine P() (Passieren) und eine V() (Vreigeben) Operation haben. Außerdem können Semaphoren mit einem Wert initialisiert werden, der vorgibt, wie oft P() aufgerufen werden kann, bevor der Aufrufer blockiert wird. Für genauere Erklärungen siehe das Informatik 4 Skript.

== 1. "Critical Section" ==
Eine kritische Sektion ist ein Stück Code, in dem nur ein Prozess gleichzeitig sein darf. Eine Möglichkeit das durchzusetzen ist, diese Bereiche mit Semaphoren zu schützen.

Beispiel:
<nowiki>
criticalSection = Semaphore(1)

criticalSection.P()
... etwas in der kritischen Sektion tun ...
criticalSection.V()
</nowiki>

== 2. "Restricted Section" ==
Will man einer bestimmten Anzahl von Prozessen den Aufenthalt in einem Bereich gestatten, nennt man das eine beschränkte Sektion. Dies setzt man um, indem man diese Sektion in die P()- und V()-Operationen einer Semaphore fasst, die mit dem gewünschten Wert initialisiert ist. Streng genommen ist dies also eine Erweiterung der "Critical Section".

Beispiel:
<nowiki>
restrictedSection = Semaphore(n)

restrictedSection.P()
... etwas in der begrenzten Sektion tun ...
restrictedSection.V()
</nowiki>

Jetzt können maximal n Prozesse den kritischen Abschnitt gleichzeitig betreten.

== 3. "Mutual Exclusion" ==
Wenn ein Stück Code nur von jeweils einer Art von Prozessen betreten werden darf, dann verwendet man eine Semaphore, um gegenseitigen Ausschluss zu realisieren.

Beispiel:
<nowiki>
wenn ich der erste Prozess meiner Art bin der den kritischen Abschnitt betreten will:
hole ich mir die Semaphore

... etwas in dem kritischen Abschnitt erledigen,
in dem jetzt diese Prozesse unter sich sind ...

wenn ich der letzte Prozess meiner Art bin der den kritischen Abschnitt verlässt:
gebe ich die Semaphore frei
</nowiki>

Den Test, ob man der erste bzw. letzte seiner Art ist, macht man üblicherweise über einen Zähler, der nach dem Inkrementieren bzw. Dekrementieren abgefragt wird. Damit wird sowohl der Eingangs- als auch der Ausgangsbereich selbst eine Critical Section und muss entsprechend behandelt werden.

<nowiki>
criticalSection = Semaphore(1), mutualExclusion = Semaphore(1)

criticalSection.P()
howManyInCriticalSection++
if 1 == howManyInCriticalSection:
mutualExclusion.P()
criticalSection.V()

... etwas in dem kritischen Abschnitt erledigen,
in dem jetzt diese Prozesse unter sich sind ...

criticalSection.P()
howManyInCriticalSection--
if 0 == howManyInCriticalSection:
mutualExclusion.V()
criticalSection.V()
</nowiki>

Hier wird das Muster "Critical Section" zusätzlich gebraucht, damit der Zähler zwischen seiner Veränderung und dem Test, welchen Wert er hat, nicht von einem anderen Prozess verändert werden kann.

Kombiniert man "Critical Section" mit "Mutual Exclusion", dann kann man entweder die "Critical Section" direkt um den kritischen Abschnitt legen, oder sie um das Ganze außen herum "wickeln".

Alle weiteren Prozessgruppen verwenden die selbe Semaphore für den gegenseitigen Ausschluss, aber eigene Semaphoren und eigene Zähler für den kritischen Abschnitt.

== 4. "Priority" ==
Zwei ineinander verschachtelte Semaphoren können genutzt werden, um eine Art von Prozessen gegen andere zu priorisieren.

Beispiel:
<nowiki>
äußerer kritischer Abschnitt <- An dieser Semaphore bleiben alle Prozesse "hängen" bis auf einen
innerer kritischer Abschnitt <- an dieser Semaphore ist also immer nur maximal ein Prozess gleichzeitig

... kritischer Bereich ...

innerer Kritischer Abschnitt
äusserer kritischer Abschnitt
</nowiki>

Die Semaphore, die den inneren kritischen Abschnitt schützt, kann jetzt von einem anderen Prozess aus einer anderen Prozessgruppe gesperrt werden. Das funktioniert, da die anderen Prozesse ja gerade '''nicht''' auch an der äusseren Semaphore warten müssen. Damit muss der priorisierte Prozess maximal so lange warten, bis der Prozess, der die innere Semaphore gerade besitzt, sie wieder freigibt. Da nur maximal ein Prozess aus der niederprioren Gruppe an der Semaphore "hängen" kann, werden alle Prozesse überholt, die an der äußeren Semaphore warten.

Etwas formaler:
<nowiki>
outerCriticalSection = Semaphore(1), innerCriticalSection = Semaphore(1)

outerCriticalSection.P()
innerCriticalSection.P()

... kritischer Bereich ...

innerCriticalSection.V()
outerCriticalSection.V()
</nowiki>

Will man "Priority" mit "Mutual Exclusion" kombinieren, dann wird der erste Block der "Mutual Exclusion" in den kritischen Bereich der "Priority" verlegt. Die priorisierten Prozesse sperren dann zusätzlich zu der Ausschluss-Semaphore noch die Semaphore des inneren kritischen Abschnitts.

Die niederprioren Prozesse:
<nowiki>
outerCriticalSection = Semaphore(1), innerCriticalSection = Semaphore(1), lowPriorityCounterProtection = Semaphore(1), mutex = Semaphore(1)

outerCriticalSection.P()
innerCriticalSection.P()
lowPriorityCounterProtection.P()
lowPriorityCounter++
if 1 == lowPriorityCounter
mutex.P()
lowPriorityCounterProtection.V()
innerCriticalSection.V()
outerCriticalSection.V()

... kritischer Bereich ...

lowPriorityCounterProtection.P()
lowPriorityCounter--
if 0 == lowPriorityCounter
mutex.V()
lowPriorityCounterProtection.V()
</nowiki>

Die hochprioren Prozesse:
<nowiki>
highPriorityCounterProtection = Semaphore(1)
// "mutex" und "innerCriticalSection" sind global und werden hier mitbenutzt

highPriorityCounterProtection.P()
highPriorityCounter++
if 1 == highPriorityCounter
innerCriticalSection.P()
mutex.P()
highPriorityCounterProtection.V()

... kritischer Bereich ...

highPriorityCounterProtection.P()
highPriorityCounter--
if 0 == highPriorityCounter
mutex.V()
innerCriticalSection.V()
highPriorityCounterProtection.V()
</nowiki>

Will man "Priority" mit "Restricted Section" kombinieren, ist zu beachten, dass die begrenzte kritische Sektion der Gruppe, die überholt werden soll, natürlich den gesamten Code mit einschließt, der die Priorität sichert. Tut man das nicht, kann das Überholen nicht garantiert werden.

Auf der anderen Seite, bei den Prozessen, die überholen sollen, muss die begrenzte kritische Sektion innerhalb des Codes liegen, der die Priorität garantiert, da andernfalls in dem Spezialfall, in dem die Restriction auf eins liegt, das Überholen nicht funktioniert. (Vorsicht: Natürlich muss bei "Restricted Section" jede Prozessgruppe eine eigene Semaphore für die Beschränkung haben.)

Der dritte wichtige Punkt ist das Holen und Freigeben der ''innerCriticalSection'' im niederprioren Prozess. Das holen muss '''vor''' dem ''mutex'' und das Freigeben '''nach''' dem ''mutex'' passieren, da das System sonst ein Deadlock produzieren kann.

== 5. "Reduction" ==
Die Lösungen, die man aus der Kombination dieser Muster erhält, verwenden in Spezialfällen mehr Semaphoren als unbedingt nötig. Man kann daher manchmal einige der Semaphoren weglassen, da ihre Funktion schon von einer der anderen Semaphoren erfüllt werden.



[[Informatik 4|<- Zurück zur Informatik 4 Seite]]

Informatik 4 (StuPO90)/Semaphoren

2006-04-19T09:26:34Z

192.168.23.194:

A Pattern Language for the usage of Semaphores
----------------------------------------------
(Nach http://c2.com/cgi/wiki?PatternLanguage)

Dafür zu sorgen, dass mehrere nebenläufige Prozesse korrekt miteinander arbeiten, ist erstaunlich schwierig. Speziell Mehrseitige Synchronisation bereitete mir beim Verstehen und Erklären besondere Probleme. Um die dabei auftretenden Probleme übersichtlicher zu erklären habe ich diese "Pattern Language" formuliert.

Ich würde mich sehr über Feedback (mhaecker@cs.tu-berlin.de) zu den Beispielen und Formulierungen freuen.

Folgende Probleme werden behandelt:
- Locking für kritische Sektionen
- Locking für beschränkten Zugriff (n clients)
- Locking zum gegenseitigen Ausschluss von zwei Gruppen
- Locking für Priorisierung einer von mehreren Gruppen

1. "Critical Section"
---------------------
Eine kritische Sektionen ist ein Stück Code, in dem nur ein Prozess gleichzeitig sein darf. Diese Bereiche kann man schützen, indem man sie in Semaphoren "verpackt".

Beispiel:
--- snip ---
criticalSection = Semaphore(1)

criticalSection.P()
.. etwas in der kritischen Sektion tun ..
criticalSection.V()
--- snap ---

2. "Restricted Section"
-----------------------
Will man einer bestimmten Anzahl von Prozessen den Aufenthalt in einem Bereich gestatten, nennt man das eine beschränkte Sektion. Dies setzt man um, indem man diese Sektion in die P()- und V()-Operationen einer Semaphore fasst, die mit dem gewünschten Wert initialisiert ist. Streng genommen ist dies also eine Erweiterung der "Critical Section".

Beispiel:
--- snip ---
restrictedSection = Semaphore(n)

restrictedSection.P()
... etwas tun in der kritischen Sektion
restrictedSection.V()
--- snap ---

Jetzt können maximal n Prozesse den kritischen Abschnitt gleichzeitig betreten.

3. "Mutual Exclusion"
---------------------
Wenn ein Stück Code nur von jeweils einer Art von Prozessen betreten werden darf, dann verwendet man eine Semaphore um gegenseitigen Ausschluss zu realisieren.

Beispiel:
--- snip ---
wenn ich der erste Prozess meiner Art bin der den kritischen Abschnitt betreten will:
hole ich mir die Semaphore

.. etwas im kritischen Abschnitt tun ..

wenn ich der letzte Prozess meiner Art bin der den kritischen Abschnitt verlässt:
gebe ich die semaphore frei
--- snap ---

Sowohl der erste als auch der zweite Test, ob man der erste bzw. letzte ist, ist natürlich /*TODO: ist das echt so natürlich?Wenn man den Zähler dazu erwähnt schon*/ ein kritischer Abschnitt und muss entsprechend gelockt werden. Etwas formaler:

--- snip ---
criticalSection = Semaphore(1), mutualExclusion = Semaphore(1)

criticalSection.P()
howManyInRestrictedSection++
if 1 == howManyInCriticalSection:
mutualExclusion.P()
criticalSection.V()

.. etwas in dem kritischen Abschnitt erledigen,
in dem jetzt diese Prozesse unter sich sind ...

criticalSection.P()
howManyInRestrictedSection--
if 0 == howManyInCriticalSection:
mutualExclusion.V()
criticalSection.V()
--- snap ---

Hier wird das Muster "Critical Section" zusätzlich gebraucht, damit der Zähler zwischen seiner Veränderung und dem Test welchen Wert er hat nicht von einem anderen Prozess verändert werden kann.

Kombiniert man "Critical Section" mit "Mutual Exclusion" dann kann man entweder die "Critical Section" direkt um den kritischen Abschnitt legen, oder sie um das gesamte außen herum "wickeln".

4. "Priority"
-------------
Zwei ineinander verschachtelte Semaphoren können genutzt werden, um eine Art von Prozessen gegen andere zu priorisieren. Dies ist eine Ergänzung des vorhergehenden Musters.

Beispiel:
--- snip ---
äusserer kritischer Abschnitt <- An dieser Semaphore bleiben alle Prozesse
"hängen" bis auf einen
innerer Kritischer Abschnitt <- an dieser Semaphore ist also immer
nur maximal ein Prozess gleichzeitig

.. kritischer Bereich ..

innerer Kritischer Abschnitt
äusserer kritischer Abschnitt
--- snap ---

/*TODO: und die andere Prozessart?*/

Die Semaphore, die den inneren kritischen Abschnitt schützt, kann jetzt von einem anderen Prozess aus einer anderen Prozessgruppe gelockt werden. Wenn das passiert, dann muss er maximal so lange warten, bis sie der Prozess der sie gerade besitzt freigibt, da nur einer aus dieser Gruppe daran "hängen" kann. Er hat also alle anderen Prozesse die an der äusseren Semaphore warten überholt.

Etwas Formaler:
--- snip ---
outerCriticalSection = Semaphore(1), innerCriticalSection = Semaphore(1)

outerCriticalSection.P()
innerCriticalSection.P()

.. kritischer Bereich ..

innerCriticalSection.V()
outerCriticalSection.V()
--- snap ---

Um dieses Muster anzuwenden muss man es mit dem Muster "Mutual Exclusion" kombinieren, indem der erste einer anderen Gruppe sich die Semaphore des inneren kritischen Abschnitts "sichert".

Will man "Priority" mit "Restricted Section" kombinieren, ist zu beachten, das die begrenzte kritische Sektion der Gruppe die überholt werden soll natürlich den gesamten Code mit einschließt, der die Priorität sichert. Tut man das nicht, kann das Überholen nicht garantiert werden. Auf der anderen Seite, bei den Prozessen, die überholen sollen, muss die begrenzte kritische Sektion innerhalb des Codes liegen, der die Priorität garantiert, da andernfalls in dem Spezialfall, in dem die Begrenzung auf eins liegt, das Überholen nicht funktioniert.

/*TODO: hier einen Punkt einfügen, der einseitige Synchronisationabdeckt*/

5. "Reduction"
--------------
Die Lösungen, die man aus der Kombination dieser Muster erhält, verwenden in Spezialfällen mehr Semaphoren als unbedingt nötig. Man kann daher manchmal einige der Semaphoren weglassen, da ihre Funktion schon von einer der anderen Semaphoren erfüllt werden.

Javakurs2006/Uebungsaufgaben

2006-04-05T16:06:13Z

192.168.23.194: /* Selbst einige Methoden schreiben! */

= Variablen =
* Das gleiche Thema im Buch [http://www.galileocomputing.de/openbook/javainsel5/javainsel02_002.htm#Rxx747java02002040000A91F032100 Java ist auch eine Insel]
== Variablendeklaration und Initialisierung ==
<nowiki>
class Beispiel {
public static void main(String [] ignored) {
int aWholeNumber;
double notAWholeNumber;
String aString;

aWholeNumber = 0;
notAWholeNumber = 0.0;
aString = "";
System.out.println(aWholeNumber);
System.out.println(notAWholeNumber);
System.out.println(aString);

int anotherWholeNumber = 0;
double anotherNotSoWholeNumber = 0;
String anotherString = "";
System.out.println(anotherWholeNumber);
System.out.println(anotherNotSoWholeNumber);
System.out.println(anotherString);
}
}
</nowiki>
* An welcher Stelle im Programm wird die Variable ''aWholeNumber'' definiert?
* An welcher Stelle im Programm wird die Variable ''aWholeNumber'' initialisiert?
Beantworte diese Fragen auch für die Variablen: ''notAWholeNumber'', ''aString'', ''anotherWholeNumber'', ''anotherNotSoWholeNumber'', ''anotherString''

Erkläre deine Meinung einem Tutor.

== Selber Deklarationen und Definitionen durchführen ==
<nowiki>
class Beispiel {
public static void main(String [] ignored) {
// deklariere eine Variable "birnen" vom Typ int

// weise ihr den Wert drei zu

// System.out.println("3 erwartet: " + birnen);
// addiere fünf zu dem Wert

// System.out.println("8 erwartet: " + birnen);
// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu

// System.out.println("5 erwartet: " + aepfel);
// subtrahiere zwei von dem Wert

// System.out.println("3 erwartet: " + aepfel);

}
}
</nowiki>

== Zuweisung an Variablen ==
<nowiki>
class Beispiel {
public static void main(String [] ignored) {
System.out.println(0);
int zero = 0;
System.out.println(zero);
int one = 1;
int whatsThis = zero;
System.out.println(whatsThis);
whatsThis = one;
System.out.println(whatsThis);
}
}
</nowiki>

Überlege dir, was dieses Code-Fragment ausgeben würde.
Führe es aus und vergleiche die Resultate: Kopiere hierfür den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus.
* Was sind die Unterschiede?
* Warum?
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.

== Variablen ändern ihre Werte ==
<nowiki>
class Test {
public static void main(String [] ignored) {
int number = 1;
System.out.println(number);
number = 1;
System.out.println(number);
number = 2;
System.out.println(number);
number = 3;
System.out.println(number);
number = 1;
System.out.println(number);
number = 17;
System.out.println(number);
}
}
</nowiki>

Überlege dir, was dieser Code ausgeben würde.
Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.
* Was gibt er tatsächlich aus?
* Gibt es Unterschiede?

== Formatierung und Namen ==
Wieso haben wir die Code-Beispiele nach den geschweiften Klammern eingerückt und die Variablen so benannt, wie wir es taten und nicht so:
<nowiki>
class _{static long _
(long __,long ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ; }
static {int _=2 ,___
= 2;System.out.print(
"a("+_+’,’+___+ ")="+
_ (_, ___) ) ;System
.exit(1);}}//(C) Ulli
</nowiki>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Etwas weniger Extrem, wieso haben wir unser zweites Beispiel nicht so gestellt?
<nowiki>
class Beispiel {public static void main
(String [] ignored) {
System.out.println(0); int zero = 0;
System.out.println(zero);
int one = 1;
int whatsThis = zero;
System.out.
println(whatsThis);
whatsThis = one; System.out.println(whatsThis)
;}}
</nowiki>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Wieso haben wir unser zweites Beispiel nicht so gestellt?
<nowiki>
class b {
public static void main(String [] i) {
System.out.println(0);
int a = 0;
System.out.println(a);
int b = 1;
int c = a;
System.out.println(c);
c = b;
System.out.println(c);
}
}
</nowiki>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

== Variablen mit verschiedenen Typen zuweisen ==
<nowiki>
class Test {
public static void main(String [] ignored) {

}
}
</nowiki>

= if =
== Einfache if-Bedingung ==
Überlege dir, was das folgende Code-Fragment macht.
Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
* Was sind die Unterschiede?
* Warum?
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.
<nowiki>
public class If_Uebung1 {
/* Eure Aufgabe:
* Versucht nachzuvollziehen, was dieses Programm macht
* und schaut Euch den Code an.
*/

public static void main(String[] args) {

/*
* Wir erzeugen uns hier eine Zufallszahl im
* Bereich 1-6. Warum funktioniert das so?
* Math.random ist eine statische Funktion im
* Math-Paket, die uns eine double-Zahl kleiner
* als 1.0, aber groesser oder gleich 0 liefert.
* Mit 6 multipliziert und um Eins erhöht erhalten wir
* Zahlen von 1.0 bis 6.99999...
* Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
* und wir erhalten ein int von 1 bis 6.
*/
int wuerfelzahl = (int) (1 + (6 * Math.random()));

/*
* Zur Kontrolle geben wir das Ergebnis aus
*/
System.out.println("Der Würfel hat " + wuerfelzahl + " ergeben.");

/*
* Ist das Ergebnis groesser als 3 ?
*/
if (wuerfelzahl > 3) {
// Wenn ja gib diesen Text aus:
System.out.println("mehr als 3!");
}

}

}
</nowiki>

== if-else-Konstrukt ==
Überlege dir, was das folgende Code-Fragment macht.
Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)
* Was sind die Unterschiede?
* Warum?
Erkläre einem Tutor, zu welchem Schluss du gekommen bist und frage ihn, ob du Recht hast.

<nowiki>
public class If_Uebung2 {

public static void main (String[] args){

int x=10;
if (x>5) {
System.out.println("x ist groesser als 5");
} else {
System.out.println("x ist kleiner/gleich 5");
}

}
}
</nowiki>

== Mehrere if-Bedingungen ==
Überlege dir, was das folgende Code-Fragment macht.
Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

Was macht das Programm für verschiedene Werte von ''wert''?.

Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von bereits vorhandenen schreiben könnte?
<nowiki>
public class If_Uebung3 {
public static void main(String[] args) {

int wert;

wert = 5;

if (wert<5){
System.out.println("Der Wert ist echt kleiner 5.");
}

if (wert>5){
System.out.println("Der Wert ist echt groesser 5.");
}

if (wert==5){
System.out.println("Der Wert ist gleich 5");
}

if (wert>=5){
System.out.println("Der Wert ist groesser oder gleich 5");
}

if (wert<=5){
System.out.println("Der Wert ist kleiner oder gleich 5");
}

}

}
</nowiki>

= while =
== Einfache Schleife ==
Schreibe eine Schleife die unendlich oft "Hallo Welt!" ausgibt.

== Begrenzte Schleifen ==
* Schreibe eine for-Schleife, die 10 mal "Hallo Welt!!" ausgibt.
* Verändere diese Schleife, so dass sie abwechselnd "Hallo Welt!" und "Ich bin im Javakurs!" ausgibt
** Es gibt zwei Möglichkeiten das zu realisieren - finde die andere.

== einfache while-Schleife ==
Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben?
Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

<nowiki>
public class While_Uebung1 {

public static void main(String[] args) {

int x=10;
while (x>0){
System.out.println(" x=" + x); // Anhaengen von x an den String
x=x-1;
}
}
}
</nowiki>

= for =
== for-Schleifen zum Zählen ==
Überlege dir, was das folgende Code-Fragment macht. Welche Zahlen werden ausgegeben?
Führe es aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

<nowiki>
public class For_Uebung1 {
public static void main(String[] args) {

System.out.println("erste for Schleife:");
for (int i = 1; i <= 10; i = i + 1) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("zweite for Schleife:");
for (int i = 1; i <= 10; i = i + 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("dritte for Schleife:");
for (int i = 1; i <= 10; i = i * 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

}

}
</nowiki>

== for-Schleife und if-Bedingung ==
<nowiki>
public class ForIf_Uebung {

// Welche Zahlen gibt dieses Programm aus ?

public static void main(String[] args) {
for (int i=1;i<10;i++){
if ((i % 2)==0){ // % ist der Modulo-Operator
System.out.println("Die Zahl "+i+" ist gerade.");
}
}
}
}
</nowiki>

= Methoden =
== Argumente ==
<nowiki>
class Beispiel {
public static void main(String [] ignored) {
ausgabe(1, "Martin");
ausgabe("Arthur", 2);
ausgabe(3, "Florian");
ausgabe("Robert", 4);
}

static void ausgabe(int i, String string) {
System.out.println(i + ": " + string);
}
}
</nowiki>

* Überlege was dieses Beispiel ausgibt.
* Probiere es aus und erkläre den Unterschied. (Wenn Fehler auftreten, erkläre wieso)
* Erkläre das einem Tutor

== Was tut das? ==
Überlege dir, was das folgenden Code-Fragmente machen. Welche Zahlen werden ausgegeben?
Führe sie aus und vergleiche mit deinen Erwartungen.

(Kopiere den Beispiel-Code in eine Datei, kompiliere sie und führe sie aus)

<nowiki>
//file: Methoden1.java
class Methoden1 {
public static void main (String[] arguments) {
System.out.println( gibMirNeZahl() );
}

public static double gibMirNeZahl() {
return 15.3;
}
}

//file: Methoden2.java
class Methoden3 {
public static void main (String[] arguments) {
System.out.println( mathematik(1, 2) );
}

public static boolean mathematik(int argument1, int argument2) {
return (argument1 + 5) < (argument2 * 2);
}
}

//file: Methoden3.java
class Methoden3 {
public static void main (String[] arguments) {
System.out.println( mathematik(1, 2) );
System.out.println( mathematik(1, 5) );
System.out.println( mathematik(3, 4) );
}

public static boolean mathematik(int argument1, int argument2) {
return (argument1 + 5) < (argument2 * 2);
}
}

//file: Methoden4.java
class Methoden4 {
public static void main (String[] arguments) {
int eineZahl = 2;
System.out.println( mathematik(4, eineZahl) );
eineZahl = 5;
System.out.println( mathematik(2, eineZahl) );
System.out.println( mathematik(eineZahl, 4) );
}

public static boolean mathematik(int argument1, int argument2) {
return (argument1 + 5) < (argument2 * 2);
}
}
</nowiki>

== Selbst einige Methoden schreiben! ==
Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

* Lege eine neue Klasse "MatheAufgabe" an.
* Füge eine <code>public static void main(Strings[] arguments)</code> Methode hinzu.
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
* Belege diese Variable dem Wert <code>5/3</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
<nowiki>
System.out.println(" 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x) );
x = add ( x , 2.0);
System.out.println( x);
</nowiki>
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
** Teste deine Methode wie eben!
** Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
* Schreibe nun eine <code>mul</code>-Methode.
** Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
** Teste deine Methode wie eben!
* Schreibe nun eine <code>public static double pow ( double basis, int exponent)</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow(2,3)</code> wurde z.B. 2^3=8 zurückgeben.
** Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine ebend geschriebene mul-Methode.
** Teste deine Methode wie gehabt!
**: Was liefert deine Methode wenn der Exponent 0 ist?
**: Was liefert deine Methode wenn der Exponent negativ ist?

= Arrays (eindimensional und n-dimensional) =
== Eindimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[] meinArray1 = new int[5];
meinArray1[0] = 0;
meinArray1[1] = 1;
meinArray1[2] = 2;
meinArray1[3] = 3;
meinArray1[4] = 4;

int[] meinArray2 = new int[3];
meinArray2[0] = 0;
meinArray2[1] = 1;
meinArray2[2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

1.1.
System.out.println(meinArray1.length);

1.2.
System.out.println(meinArray2.length);

1.3.
System.out.println("Ergebnis:"+meinArray1[1]);

1.4.
System.out.println("Ergebnis:"+meinArray2[1]);

1.5.
System.out.println("Ergebnis:"+meinArray1[4]);

1.6.
System.out.println("Ergebnis:"+meinArray2[4]);

1.7.
System.out.println(meinArray1.length-1);

1.8.
System.out.println(meinArray2.length-1);

1.9.
System.out.println("Ergebnis:"+meinArray1[0]);

1.10.
System.out.println("Ergebnis:"+meinArray2[0]);

== Zweidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][] meinArray3 = new int[2][3];
meinArray3[0][0] = 1;
meinArray3[1][1] = 2;
meinArray3[0][2] = 1;
meinArray3[1][0] = 2;
meinArray3[0][1] = 1;
meinArray3[1][2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du Matrizen. Ihre Größe wird mit (n x m) angegeben.

System.out.println(meinArray3[0][0]+meinArray3[0][1]+meinArray3[0][2]);
System.out.println(meinArray3[1][0]+meinArray3[1][1]+meinArray3[1][2]);

== Dreidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][][] meinArray3D = new int[2][2][2];
meinArray3D[0][0][0] = 1;
meinArray3D[0][1][1] = 2;
meinArray3D[0][1][0] = 2;
meinArray3D[0][0][1] = 1;

meinArray3D[1][0][0] = 3;
meinArray3D[1][1][1] = 4;
meinArray3D[1][1][0] = 4;
meinArray3D[1][0][1] = 3;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du mehrdimensionale Obejekte.
<nowiki>
System.out.println(meinArray3D[0][0][0]+meinArray3D[0][0][1]);
System.out.println(meinArray3D[0][1][0]+meinArray3D[0][1][1]);
System.out.println(meinArray3D[1][0][0]+meinArray3D[1][0][1]);
System.out.println(meinArray3D[1][1][0]+meinArray3D[1][1][1]);
</nowiki>

= Klassen =
(todo)