Problemstellung Berechne die Summe der Quadrate aller natürlichen Zahlen bis zu einer vorgegebenen Zahl (bspw. 100)! Oder mathematisch: Berechne Sz=1100 z2 = Sz=1100 z * z = 1*1 + 2*2 + 3*3 + 4*4 + … + 100*100 = …((((1*1) + 2*2) + 3*3) + 4*4) + … + 100*100)

Konzeption der Lösung Aufgabe: Berechne …((((1*1) + 2*2) + 3*3) + 4*4) + … + 100*100) 1. Algorithmus einer Lösung: (1) fange mit z = 1 an; (2) berechne das Quadrat von z; (3) bestimme die neue Zwischensumme: alte Zwischensumme + berechnetes Quadrat (4) erhöhe z um 1; (5) prüfe ob z > 100 ist, sonst gehe wieder zu (2) (6) gib die Zwischensumme aus

Konzeption der Lösung 2. Algorithmus einer Lösung: (1) fange mit z = 1 an; (neu) prüfe ob z <= 100 ist, sonst gehe zu (6) (vergleiche mit 5) (2) berechne das Quadrat von z; (3) bestimme die neue Zwischensumme alte Zwischensumme + berechnetes Quadrat (4) erhöhe z um 1; (neu) gehe zu (2) (6) gib die Zwischensumme aus

Lösung mit JAVA Ausgabe: public class summeQuads { public static void main(String[] args) { int z = 1; // (1) int summe = 0; while(z <= 100) { // (neu) summe = summe + z * z; // (2) und (3) z = z + 1; // (4) } // (neu) System.out.println ("Summe Quadratzahlen: " + summe); //(6) } Ausgabe: Summe Quadratzahlen: 338350

While-Anweisung Syntaktischer Aufbau: while(Bedingung) Anweisung; Semantik (Bedeutung): Wiederhole Anweisung solange, bis Bedingung falsch ergibt. Bedingungen müssen wahr (true) oder falsch (false) liefern.

Alternative Lösung mit JAVA public class summeQuadsMitFor { public static void main(String[] args) { int summe = 0; for(int z=1; z<=100; z=z+1) { // (1, neu, 4) summe = summe + z * z; // (2) und (3) } // (neu) System.out.println ("Summe Quadratzahlen: " + summe); //(6) } Ausgabe: Summe Quadratzahlen: 338350

for-Schleife summe = summe + z * z; } for (int z=1; z<=100; z=z+1) { summe = summe + z * z; } 3 Bestandteile Initialisierung: Wird genau ein Mal und am Anfang ausgeführt! (auch mit Vereinbarung, auch mehrere Variable) Bedingung (wie bei while-Schleife) Anweisungsteil: Wird immer am Ende eines Schleifendurchlaufs ausgeführt! (auch mit mehreren Anweisungen)

Aufbewahren vieler Zahlen Benötigt wird: Eine Variable, die für viele Werte des gleichen Typs steht. Passendes Konstrukt in JAVA: Variable, die Feld (Array) von Werten speichert Nun für Felder betrachten: Vereinbarung, Initialisierung, Zuweisung, Wertabfrage

Vereinbarung von Feldern Erinnerung: int i; vereinbart einen Bezeichner i, der für genau eine Zahl stehen kann. Felder: int f[]; vereinbart einen Bezeichner f, der eine Anzahl von Zahlen beinhaltet. Neue Sonderzeichen: [] Die Anzahl gehört nicht zur Vereinbarung!

Initialisierung von Feldern Initialisierung eines Feldes umfasst: Festlegen der Anzahl der Elemente (Größe des Feldes) Festlegen der Werte für die Elemente Beide Varianten sind möglich: int[] f = new int[5]; Initialisiert die Größe des Feldes auf 5 Elemente. int[] g = {17,2,4,122,0,-3} Initialisiert die Größe des Feldes auf 6 Elemente.

Zuweisung an felder Zuweisung ist möglich für Größe des Feldes int[] f; f = new int[7]; wie bei Initialisierung Einzelne Elemente des Feldes f[0] = 22; erstes Element auf den Wert 22 f[1] = -3; zweites Element auf den Wert -3 int elem = 3; f[elem] = 0; viertes Element auf den Wert 0 f[elem+1] = 34; fünftes Element auf den Wert 34

Zuweisung an Felder Anmerkungen: Vorsicht: Die Nummer eines Elements heißt Index. f[1] bezeichnet das zweite Element von f mit dem Index 1. Der Index muss immer zwischen 0 und der Größe-1 des Feldes liegen. int[] g={3}; g[1]=5; führt zu Fehler! Neue Verwendung von […]: ermöglicht die Zuweisung an Elemente. Vorsicht: Erneutes Zuweisen der Größe führt zu Verlust der alten Elemente. Zuweisung von ganzen Feldern führt zu (noch) unerklärbaren Seiteneffekten. int[] f, g={3}; f=g; Nicht verwenden! Statt dessen elementweises Kopieren durch f[0]=g[0];

Wertabfrage bei Feldern Abfrage ist möglich für Größe des Feldes über length-Abfrage: int[] f = {5,6,7,8}; System.out.println(f.length); druckt 4 aus! Werte der einzelnen Elemente des Feldes int[] f = {5,6,7,8}; System.out.println(f[1]); druckt 6 aus! System.out.println(f[1]+f[3]); druckt 14 aus! Noch eine Verwendung von […]: ermöglicht die Abfrage der Elemente.

Beispiele mit Feldern Aufgabe: Lege Liste mit den natürlichen Zahlen>1 bis zu einer vorgegebenen Obergrenze an! Erste Lösung mit Initialisierung eines int-Feldes: int[] f={2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; Viel Schreibarbeit bei großer Grenze Wenig flexibel, wenn Grenze geändert wird unbrauchbar

Beispiele mit Feldern Zweite Lösung mit Zuweisung in einer Schleife: int obergrenze = 64; int[] f = new int[obergrenze-1]; int zähler = 0; while (zähler < f.length) { f[zähler] = zähler+2; zähler = zähler+1; } zähler = 0; while (zähler < f.length) { System.out.print(f[zähler] + " ");

Vergleichsoperator == == vergleicht nicht Felder, d.h. dort Vergleich der Elemente notwendig: boolean gleich = true; int[] f1 = {1,2,3}; int[] f2 = {2,3,4}; gleich = f1.length == f2.length; if (gleich) { int z = 0; while (gleich && z < f1.length) { gleich = f1[z] == f2[z]; z = z+1; }

for-Schleife Wiederkehrendes Problem: Durchlaufen eines Feldes zähler = 0; while (zähler < f.length) { System.out.print(f[zähler] + “ “); zähler = zähler+1; } Einfacher mit for-Schleife: for (zähler=0; zähler<f.length; zähler=zähler+1) {

for-Schleife Und seit JAVA 5 auch möglich! Statt for (z=0; zähler<f.length; z++) { System.out.print(f[z] + “ “); } Jetzt auch möglich: for (int element : f) { System.out.print(element + “ “);

Zuweisungsoperatoren Kurzformen für häufige Zuweisungen statt kurz summe = summe + zähler; summe += zähler; produkt = produkt * zähler; produkt *= zähler; zähler = zähler + 1; zähler++; oder ++zähler; aber: zähler++ und ++zähler liefern unterschiedliche Ergebnisse

Zuweisungsoperatoren Beispiel: int i=1, j=1; System.out.println(1 + i++); druckt 2 System.out.println(1 + ++j); druckt 3 System.out.println(i+“ “+j); druckt 2 2 i++ erhöht i um 1 und liefert den Wert von i vor der Erhöhung ++i erhöht i um 1 und liefert den Wert von i nach der Erhöhung