Programmierung 1 Studiengang MI / WI

(1)

FB Automatisierung und Informatik: Programmierung 1, MI/WI 1

Programmierung 1 Studiengang MI / WI

Dipl.-Inf., Dipl.-Ing. (FH) Michael Wilhelm

Hochschule Harz

FB Automatisierung und Informatik

mwilhelm@hs-harz.de

http://mwilhelm.hs-harz.de

Raum 2.202

Tel. 03943 / 659 338

Inhalt der Vorlesung

Überblick:

• Erste Beispiele, Interaktion

• elementare Datentypen

• Variablen und Kontrollstrukturen

• Arrays und Funktionen

• Objekte und Methoden

• Algorithmen und Pseudocode

• Laufzeitverhalten

• Simulation

• Bibliotheken

• Folien basierend auf Daniel Schiffman “Learning Processing” und Donald W. Smith

• Folien basierend auf Vorlesung „Programmierung1“ von Prof. Singer Grundlegende Algorithmen und Methoden:

• Suchen und Sortieren

• Hashing

• Rekursion

• Graphen

• Dynamische Programmierung

Von Processing zu Java

(2)

Kapitel

Variablen

− Grundtypen

− Strings

Bedingungen

− if-Anweisungen

− else-Anweisungen

− geschachtelte Anweisungen

Schleifen

− while

− for

− for-each

Variable vs. Schublade

Eigenschaften einer Schublade:

− Eine Schublade hat einen Namen (Zettel klebt vorne)

− Eine Schublade hat einen Inhalt (Schublade auf, Gegenstand in die Schublade legen

− Eine Schublade hat einen bestimmten Gültigkeitsbereich. Man muss in das Zimmer gehen, in dem der Schrank steht.

− Ist man in einem anderen Zimmer, kann man diese Schublade nicht öffnen, also auf die Variable nicht zugreifen

− In einer Schublade kann man unterschiedliche Sachen reinlegen.

− Man kann den Inhalt sich anschauen: Schublade auf, Gegenstand anschauen

Schublade "a"

(3)

Variable vs. Schublade

5 a

3 b 8

c

Gegeben zwei Schubladen

−

Schublade "a" hat den Inhalt "5"

−

Schublade "b" hat den Inhalt "3"

Programmzeilen

−

int a, b, c; // Deklaration

−

a = 5; // Die leere Schublade wird mit der Zahl 5 gefüllt

−

b = 3;

−

c = a + b;

•

Analogien: Variablen sind wie

−

Eimer, Schachteln, Schubladen

•

in welchen wir Informationen aufbewahren

•

Mathematik:

−

x = y * z

−

Name aus einzelnem Buchstaben der eine Zahl repräsentiert.

•

In der Programmierung:

−

Nutzen längere, aussagekräftige Namen.

Variable vs. Schublade

(4)

• Was sind Variablen ?

•

Es gibt vordefinierte Variable in Processing auch eingebaute Variable genannt

•

Eigene Deklaration und Initialisierung von Variablen

•

Zufallswerte für Variablen

•

Computer haben Speicher. Der Computer nutzt diesen um sich Dinge zu merken, die er benötigt.

Technische Erklärung für Variable:

•

eine Variable ist ein benannter Zeiger auf eine Stelle im Speicher des Computers (eine Speicheradresse) an der Daten abgelegt sind.

Computerspeicher:

•

Random Access Memory (RAM)

•

Speicherplatz hat eine zugeordnete Größe, je nach abzulegenden Daten

• Variablen und Speicher

(5)

Variablendeklaration

•

Variablen müssen deklariert werden:

•

Der Programmierer teilt dem Computer mit:

•

Datentyp der Variable

•

Name der Variable ⇒ Die Anzahl der Bytes im Speicher liegt fest

Was ist ein Datentyp?

•

Jeder Datentyp benötigt Speicher einer bestimmten Größe.

•

“Primitive” bzw. “atomare” Datentypen bestehen aus 4 Kategorien:

•

Logische Variable: (boolean)

•

Vorzeichenbehaftete ganze Zahlen (byte, int, long)

•

Fließkommazahlen (float, double)

•

Zeichen (char und String)

Integer-Zahlenformate in Java

Java Bereich Format

byte -128...127 8 Bit

short -32768..32767 16 Bit

int -2.147.483.648 .. 2.147.483.647 32 Bit long -9223372036854775809

...

+9223372036854775808

64 Bit

char 0..65535 16 Bit

−

^0..65535 ^{16 Bit}

−

0.. 4294967295 32 Bit

−

0..18446744073709551616 64 Bit

Weitere Angaben:

int i = 1234; // Standard

long l = 1234l; // Initialisierung als long-Zahl

long l=12345554545; // l fehlerhaft

(6)

Fließkomma-Zahlenformate in Java

Java Bereich Stellen Format

− ^2.9*10

^-39

.. 1.7*10

³⁸

11-12 6 Byte float 1.5*10

^-45

.. 3.4*10

³⁸

7-8 4 Byte double 5.0*10

^-324

.. 1.7*10

³⁰⁸

16-17 8 Byte

− ^3.4*10

^-4932

. . 1.1*10

⁴⁹³²

19-20 10 Byte

Weitere Angaben:

float f;

f = 234.55f; // Initialisierung mit einer float-Zahl sonst wäre es eine double-Zahl

Weitere Datentypen in Java

boolean

Speichert „true“ oder „false“

1 Byte Größe

char

Speichert ein Zeichen 2 Byte Größe, UniCode Zuweisung mittels 'a'

String (Klasse)

Speichert mehrere Zeichen

Zuweisung mittels "hier ist ein String"

x

(7)

Deklaration und Initialisierung von Variablen

•

Initialisierung einer Variable bedeutet der Variable einen ersten Wert zuzuweisen.

•

z.B. Pseudocode: setze spielerZahl auf 5

•

Pseudocode:

•

Schritt zur Formulierung der Problemlösung als Algorithmus,

•

jedoch vor dem Schreiben des Programms auf dem Computer!

•

Zwei Möglichkeiten:

•

Initialisierung und Deklaration mittels einer Zeile:

•

int start = 10;

•

Initialisierung nach der Deklaration auf seperater Zeile

•

int count;...

•

count = ende - start;

Deklaration und Initialisierung von Variablen

Diskutieren Sie kurz (1 Minute) mit Ihrem Nachbarn:

•

Was ist die Ausgabe des folgenden Programms?

char x = 'a';

char y = 'c';

println(x);

println(y);

println(x*y);

println(x+y);

Abstimmung: print(x*y) ergibt

•

Compilerfehler ?

•

Ausgabe einer Zahl ?

•

Ausgabe von 'ac' ?

•

Ausgabe des Strings "ac" ?

(8)

Deklaration und Initialisierung von Variablen

Beispiel Pong

•

Überlegen Sie sich:

•

Welche Variablen würden benötigt um Pong zu spielen?

Variablennamen

Es gibt Regeln und Konventionen zur Benennung von Variablen:

•

Regeln

• Buchstaben, Ziffern, Unterstrich (_) können genutzt werden.

• Keine Ziffern als erstes Zeichen (0, 1, ..., 9)

• Keine reservierten Worte wie

• mouseX, int, size, ....

•

Konventionen

•

beschreibende Namen nutzen

• int anzahlStudenten;

•

keine Umlaute etc., (ä, ö, ü, ß)

•

Kamelhöcker-Notation (camel case):

•

beginne mit Kleinbuchstaben

•

jedes neue Wort beginnt mit Großbuchstaben

•

int anzahlStudentenAI

(9)

Variablen-Initialisierung

Variable können nur mit Werten desselben oder eines kompatiblen Typs initialisiert werden?

Welche Initialisierungen sind kompatibel?

•

int count = 'a';

•

char letter = 0;

•

double deposit = "Fred";

•

boolean happy = 1;

•

float feet = 6;

•

int inches = feet * 12;

•

long giant = count * 3.0;

Wo werden Variable deklariert?

zur Erinnerung:

Der Code ist in Blöcke eingeteilt.

Die Deklarationen können sowohl innerhalb als außerhalb von Blöcken vorgenommen werden.

Zum jetzigen Zeitpunkt: außerhalb.

In diesem Fall kann auch innerhalb der Blöcke auf die Variablen zugegriffen werden.

int circleX = 100;

int circleY = 100;

void setup() { size(200, 200);

}

void draw() { background(100);

stroke(255);

fill(0);

ellipse(circleX, circleY, 50, 50);

}

Deklaration außerhalb

Zugriff auch innerhalb

(10)

Konstante „Variablen“: final

Für Abmessungen (Breite, Höhe) oder Fallunterscheidungen (AI,VW,W) sind Variablen nicht geeignet.

Sinnvoll wäre ein „Konstrukt“, dem man einen Wert nur einmal zuweisen kann.

Die Lösung ist die Benutzung einer Konstanten:

•

final int AI = 1;

•

final int VW;

•

VW = 2;

•

Konstanten sollten komplett großgeschrieben werden

•

Dürfen einmal zugewiesen werden

Sichtbarkeit und Gültigkeitsbereich

Beispiel:

int a=7;

int b=10;

char c = 'c';

char d = 'cd';

char e = "c";

void draw() {

println("a: "+a);

float b=1,57;

println("b: "+b);

{

char b = 'b';

println("b: "+b);

} }

(11)

Sichtbarkeit und Gültigkeitsbereich

int a=7;

int b=10;

char c = 'c';

char d = 'cd';

char e = "c";

void draw() {

println("a: "+a);

float b=1,57;

println("b: "+b);

{

char f = 'f';

println("f: "+f);

}

println("f: "+f);

}

Mathematische Operatoren

Einfache Grundrechenarten

•

Multiplikation * bindet stärker

•

Division / bindet stärker

•

Addition +

•

Subtraktion -

•

Modulo %

Bool‘sche Operatoren

•

Bitweise Negation ~ bindet stärker

•

Bitweise AND & bindet stärker

•

Bitweise OR | bindet stärker

•

Bitweise XOR ^ bindet stärker

•

logische Negation !

•

logische AND &&

•

logische OR ||

(12)

Zufallszahlen

erlauben Abwechslung in ein Programm zu bringen.

Alle höheren Programmiersprachen verfügen über die Fähigkeit (Pseudo-)Zufallszahlen zu erzeugen.

random() ist eine Funktion, die einen float-Wert zurück liefert.

Dieser Wert kann einer Variablen zugewiesen und dann benutzt werden.

float wf = random(1, 100);

rect(100, 100, wf, 50);

int wi = (int)random(1, 100);

rect(100, 100, wi, 50);

zufälliger float-Wert zwischen 1 und 100

(1 <= wert < 100)

“Casting” nach int zufälliger int-Wert zwischen 1 und 99

Zusammenfassung

Variable haben Namen und Typen

•

Es gibt Regeln und Konventionen für diese Namen Variablen müssen deklariert werden.

•

bestimmt den Datentyp, den Speicherbedarf, minimale und maximale Werte

Variable können auf mehrere Arten initialisiert werden.

•

Häufiger Programmierfehler:

•

Nutzung nicht initialisierter Variable.

•

Processing hat eine Reihe vordefinierter Variablen

•

Mit Zufallszahlen läuft ein Programm jedes mal unterschiedlich.

•

Variablen können „überdeckt“ werden

•

Variablen sind nicht „überall“ sichtbar

(13)

Bedingte Entscheidungen

Man benötigt Bool´sche Ausdrücke

Eine Bedingte Anweisungen

•

erlauben einem Programm, je nach variierenden Umständen, unterschiedliche Ergebnisse zu liefern.

Token

•

if

•

else

•

else if

Bool‘scher Ausdruck

Was ist ein Bool´scher Ausdruck?

Etwas, das entweder den Wert wahr oder falsch annimmt, nicht jedoch den Wert vielleicht,

Computer „denken“ in 0´en und 1´en.

Wahrheitstafeln

•

0 = AUS = FALSCH,

•

1 = EIN = WAHR

AND / UND

B

0 1

A

0 0 0

1 0 1

OR / ODER

B

0 1

A

0 0 1

1 1 1

(14)

Bool‘scher Ausdrücke

Bool´sche Ausdrücke basieren meist auf Vergleichen:

•

bist du 18 Jahre alt?

•

ist „changeCount“ kleiner als 5?

•

ist „meinePunkte“ zwischen 80 und 89?

•

ist „nachName“ gleich “Meier”?

Operator Bemerkung

> größer als

< kleiner als

>= größer oder gleich als

<= Kleiner oder gleich als

== Gleich

!= ungleich

Ähnlich zu Algebra

Anwendung Bool´scher Ausdrücke mit der if-Anweisung Nassi und Shneiderman-Diagramme

Block falsch

falsch Bedingung?

wahr

Block wahr

If-Anweisungen:

if (Bedingung) Anweisung;

if (Bedingung) { Anweisung1;

Anweisung2;

Anweisung3;

}

Programmfluss

(15)

Anwendung Bool´scher Ausdrücke mit der if-Anweisung Nassi und Shneiderman-Diagramme

Block falsch

falsch Bedingung?

wahr

Block wahr If-Anweisungen:

if (Bedingung) Anweisung;

else

Anweisung;

if (Bedingung) { Anweisung1;

Anweisung2;

} else{

Anweisung3;

Anweisung4;

}

Programmfluss

Anwendung Bool´scher Ausdrücke mit der if-Anweisung

Block falsch

falsch Bedingung?

Fall1

Block1

If-Anweisungen:

if (Bed1) { Anweisung1;

}

else if (Bed2) { Anweisung2;

}

else if (Bed3) { Anweisung3;

} else {

Anweisung4 }

Programmfluss

Fall2

Block1 Block n

(16)

Beispiel für Mehrweg-Verzweigung

Mausposition bestimmt Hintergrundfarbe

if (mouseX < width/3) { background(255);

}

if (mouseX < 2*width/3) { background(127);

}

if (mouseX >= 2*width/3) { background(0);

}

Beispiel für Mehrweg-Verzweigung

Mausposition bestimmt Hintergrundfarbe

if (mouseX < width/3) { background(255);

} else if (mouseX < 2*width/3) { background(127);

} else {

background(0);

}

(17)

Was soll bei Mehrwegverzweigungen zuerst getestet werden?

int x = 75;

if(x > 50) {

println(x + "ist größer als 50!");

}

else if(x > 25) {

} else {

println(x + "ist höchstens 25!");

}

int x = 75;

if(x > 25) {

}

else if(x > 50) {

} else {

println(x + "ist höchstens 25!");

}

Wie lautet die Ausgabe:

•

75 ist größer als 50 ✔

•

75 ist größer als 25 ✘

•

75 ist höchstens 25 ✘

Wie lautet die Ausgabe:

•

75 ist größer als 50 ✘

•

75 ist größer als 25 ✔

•

75 ist höchstens 25 ✘

Anwendung: Benotung

Bestimmen Sie die Note an Hand der Punkte

int punkte=(int) random(0,101);

int note;

if(________) { note = ....;

} else if(________) { note = ...;

...

}

println("Die Note ist " + note);

Punkte Note

90-100 1

90-89.99 2

70-79.99 3

60-69.99 4

<60 5

Wie würden Sie eine Lösung planen/programmieren?

•

Wofür würden Sie zuerst testen?

•

Wofür als Zweites?

•

Wie viele Tests werden benötigt?

(18)

Logische Operatoren: AND

35

Bestimmen Sie die Note an Hand der Punkte

int anzahlFuehrerschein = 1;

int alter = 20;

if(alter >= 18 && anzahlFuehrerschein > 0) { println(“Darf Auto fahren!”);

}

AND 0 1

0 0 0

1 0 1

Es kommt vor, dass mehrere Bedingungen wahr sein müssen, bevor etwas geschehen soll.

Falls alter >= 18 und anzahlFuehrerschein > 0, dann gib aus: Darf Auto fahren.

&& steht für das logische UND

Logische Operatoren: OR

Bestimmen Sie die Note an Hand der Punkte

float abiNote = 5.0 // Kein Abitur gemacht float fachabiNote = 1.1 // aber Fachabitur if(abiNote <= 4.0 || fachabiNote <= 4.0) {

println("Darf studieren.");

}

OR 0 1

0 0 1

1 1 1

Es kommt vor, dass von mehrern Bedingungen nur eine erfüllt sein müssen, bevor etwas geschehen kann.

Wer sein Abitur oder Fachabitur mit mindestens 4.0 bestanden hat, darf studieren.

Falls abiturNote <= 4 oder fachabiNote <= 4, dann gib aus: Darf studieren.

|| steht für das logische ODER

(19)

Bool´sche Variable

Wir möchten uns etwas merken, dass entweder wahr oder falsch ist.

boolean hatFuehrerschein = true;

float promille = 0.2;

if(promille < 0.5 && hatFuehrerschein) { println("Fahre mit dem Auto");

} else {

println("Nimm den Bus");

}

Rechteckfläche als Knopf

boolean knopfGedrueckt = false;

int obenLinksX = 50;

int obenLinksY = 50;

int breite = 100;

int hoehe = 75;

....

void draw() {

if(knopfGedrueckt) {

// Anweisungen falls Knopf gedrueckt }

rect(obenLinksX, obenLinksY, breite, hoehe);

}

void mousePressed() {

if( mouseX>obenLinksX && mouseY>obenLinksY &&

mouseX< obenLinksX+breite && mouseY<obenLinksY+hoehe ) { knopfGedrueckt = !knopfGedrueckt; // Knopf umschalten }

}

! steht für logisch nicht,

dreht logische Aussage um.

(20)

Beispiel: Springender Ball

int ballX = 0;

int v = 1;

void setup() { size(200, 200);

smooth();

}

void draw() { background(255);

ballX = ballX + v;

if(ballX > width || ballX < 0) { v = -v;

}

stroke(0);

fill(175);

ellipse(ballX, 100, 32, 32);

}

Geschwindigkeit umdrehen, wenn Ball Rand erreicht.

void mousePressed() { v = v + 1;

}

Aktion von mousePressed ?

Zusammenfassung

Konditionale erlauben den Programmfluss zu kontrollieren if, else if, else erlauben viele Möglichkeiten

Bool´sche Ausdrücke werden innerhalb von if( ... ) gebraucht. Sie ergeben true oder false.

Bool´sche Ausdrücke nutzen Vergleichsoperatoren

<, <=, ==, !=, >=, >

Bool´sche Variable haben true und false als mögliche Werte.

Sie können in Bool´schen Ausdrücken benutzt werden.

•

Bitweise Operatoren (&,|, ~) werden benutzt um Variablen zu verändern.

•

Logisches UND (&&), ODER (||) und NICHT(!) werden

benutzt um Bool´sche Ausdrücke zu kombinieren.

(21)

Schleifen

•

Das Konzept der Iteration

•

Zwei Schleifentypen:

•

while

•

for

•

foreach

•

Wann werden sie eingesetzt?

Zahl merken

Was ist eine Iteration?

etwas wird wiederholt:

•

Jede “iteration” kann etwas anders durchführen

•

Es gibt (fast) immer eine Bedingung zur Beendigung der Wiederholung

Schleifen wurden bereits eingesetzt:

•

Processing ruft draw() solange wiederholt auf, bis das

Programm beendet wird.

(22)

Weshalb nutzt man eine Iteration?

// nur mit Zahlen stroke(0);

line( 50,60, 50,80);

line( 60,60, 60,80);

line( 70,60, 70,80);

line( 80,60, 80,80);

line( 90,60, 90,80);

Mit Variable x int x = 50;

int spacing = 10;

int len = 20;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

Finde den wiederholten Code

Weshalb nutzt man eine Iteration?

// nur mit Zahlen stroke(0);

line( 50,60, 50,80);

line( 60,60, 60,80);

line( 70,60, 70,80);

line( 80,60, 80,80);

line( 90,60, 90,80);

Mit Variable x int x = 50;

int spacing = 10;

int len = 20;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

x = x + spacing;

line(x,60,x,80);

Untersuchen was sich ändert Die x-Werte erhöhen sich Was ist das Muster?

addiere jeweils 10 Wann wird dies beendet?

Letzte Zeile ist x = 150

Finde den wiederholten Code

(23)

While-Schleife

Aufbau:

1) Initialisierung

2) while ( Bedingung/en ) {

3) Schleifenrumpf / Anweisungen

4) }

Bedingung zeigt an, wie oft die Schleife durchlaufen wird

Planung der Iteration: Abbruchbedingung

Wann soll das Zeichnen der Linien beendet werden?

x == 150?

x > 150?

x < 150?

x <= 150?

x >= 150?

Nutze dieselbe “initialiserung”.

Der zu wiederholende Code kommt in den Schleifenkörper

Die Abbruchbedingung kommt in den “Test”.

(24)

Planung der Iteration: Abbruchbedingung

// Schleifenversion int x = 50;

int spacing = 10;

int endLegs = 150;

while(x < endLegs) { line(x, 60, x, 80);

x = x + spacing;

}

Wann soll das Zeichnen der Linien beendet werden?

line( 50,60, 50,80);

line( 60,60, 60,80);

line( 70,60, 70,80);

line( 80,60, 80,80);

line( 90,60, 90,80);

Wie man eine Schleife plant (Nassi-Shneiderman)

Jede Schleife hat drei Teile:

•

Vorbereitung der Variablen (initialisierung)

•

Testen der Schleifenabbruchbedingung

•

Anpassen der Testvariablen

Es muss immer sicher gestellt werden, dass die Schleife tatsächlich beendet wird.

Die Bedingung muss false werden

boolean bedingung = true; // initialisierung while(bedingung) {

// Fuehre Arbeiten durch // Berechne Bedingung neu Testvariablen anpassen;

}

(25)

Wie man eine Schleife plant (Nassi-Shneiderman)

boolean bedingung = true;

while(bedingung) {

// Fuehre Arbeiten durch // Berechne Bedingung neu Testvariablen anpassen;

}

Vorbereitung der Variablen

solange Bedingung erfüllt

Anweisungen im Schleifenkörper

•ausführen Testvariablen anpassen

Planung einer Schleife

Was ändert sich mit jedem Balken?

•

Setup (Anfangsbedingungen):

•

Anfangswert y =

•

Endwert y =

Abbruchbedingung:

Anpassung:

•

Wie weit sind Balken

auseinander? Breite:

•

Wie breit sind die Balken?

•

Wo starten Sie? x =

•

Anmerkung: x ist unverändert

(26)

Planung einer Schleife

void setup() { size(200, 200);

background(255);

fill(125);

}

void draw() {

int last = height;

int y = 5;

while(y < last) {

rect(50, y, 100, 10);

y = y + 20;

} }

Planung einer Schleife: Linienmuster

final int width = 300;

final int step = 20;

void setup() { size(200, 200);

background(255);

}

void draw() { int y = 0;

while(_______) { stroke(0);

line(____, ____, ____, _____);

y = _______;

} }

(27)

Planung einer Schleife: Kornkreise

final int x0 = 150;

final int y0 = 150;

final int step=20;

void setup() { size(200, 200);

background(255);

ellipseMode(CENTER);

stroke(0);

noFill();

}

void draw() { int r = ??;

while(_______) {

ellipse(____, ____, ____, _____);

r = _______;

} }

For-Schleife mit Nassi-Shneidermann

Vorbereitung der Variablen im „for-Code“

solange Bedingung erfüllt, im „For-Code“

Anweisungen im Schleifenkörper

•ausführen

Testvariablen anpassen, im „For-Code“

Eine for-Schleife wird benutzt, wenn

•

die “Testvariable” eine Zahl ist

•

die Abbruchbedingung vor dem Start

bekannt ist.

(28)

For-Schleife

for ( Init; Bedingung; Testvariablen anpassen ) { // Fuehre Arbeiten durch

// Berechne Bedingung neu }

for ( int iy=0; iy<10; iy=iy+1 ) { line( 10, iy, 300, iy);

}

2. Variante ??

for ( int iy=0; iy<10; iy=iy-1 ) { line( 10, iy, 300, iy);

}

For-Schleife

for ( Init; Bedingung; Testvariablen anpassen ) { // Fuehre Arbeiten durch

// Berechne Bedingung neu }

for ( int iy=0; iy<10; iy=iy+1 ) { line( 10, iy, 300, iy);

}

2. Variante

for ( int iy=10; iy>=0; iy=iy-1 ) { line( 10, iy, 300, iy);

}

(29)

Planung einer Schleife: Linienmuster

final int step = 20;

void setup() { size(200, 200);

background(255);

}

void draw() {

for(int y=0; y<width; y=y+step) { stroke(0);

line(2, y, width-4, y);

} }

Planung einer Schleife: Kornkreise

final int width = 300;

final int x0 = 150;

final int y0 = 150;

final int step=20;

void setup() {

size(width, width);

background(255);

ellipseMode(CENTER);

noFill();

stroke(0);

}

void draw() {

for (int r = 0; r < width/2; r = r + step) { ellipse(x0,y0, r+r,r+r);

println(r);

} }

(30)

Abkürzungen der Zuweisungsoperatoren

x += k; entspricht x = x + k;

x *= k; entspricht x = x * k;

x -= k; entspricht x = x - k;

x /= k; entspricht x = x / k;

x++ entspricht x = x + 1;

x-- entspricht x = x - 1;

++x --x

hier wird x verändert, bevor es benutzt wird, in den

x++ x--

x erst verändert, nachdem es benutzt wurde

Abkürzungen der Zuweisungsoperatoren

int x = 0;

int y = ++x;

// x hat Wert 1, ebenso y

int x = 0;

int y = x++;

// x hat Wert 1, aber y ist 0

(31)

Welches Bild gehört zu welchem Codeausschnitt?

Ausschnitt 1

Ausschnitt 2

Ausschnitt 3

Ausschnitt 4 for (int i=0; i<10; i++) {

rect(i*20,height/2, 5, 5);

}

int i = 0;

while (i < 10) {

ellipse(width/2,height/2, i*10, i*20);

i++;

}

for (float i = 1.0; i < width; i *= 1.1) { rect(0,i,i,i*2);

}

int x = 0;

for (int c = 255; c > 0; c –= 15) { fill(c);

rect(x,height/2,10,10);

x = x + 10;

}

dabc

boolean bedingung;

do {

// Anweisungen

// Testvariable anpassen Anweisung = ....

} while(bedingung);

Weitere Schleifenformen

boolean bedingung;

while(true) { // Anweisungen

Anweisungsbedingung = ....

if(! Anweisungsbedingung) break;

}

(32)

Weitere Schleifenformen: continue

int summe=0;

int i=0;

while(i<10) { if ( (i%3)!= 0){

summe+=i;

i++;

} }

int summe=0;

int i=0;

while(i<10) { if ( (i%3)!= 0){

summe+=i;

} i++;

}

int summe=0;

int i=0;

while(i<10) {

if ( (i%3)== 0) continue;

summe+=i; // übersprungen i++; // wird ausgeführt }

3 Varianten

Zusammenfassung

•

Iteration (Schleifen) ist ein weiterer Weg den Programmfluss zu steuern.

•

Schleifen haben drei Elemente:

•

1) Initialisierung: Vorbereitung der Variablen

•

2) Testen, ob wir fertig sind

•

3) Anpassen der Testvariable

•

Mit der while-Schleife lässt sich alles erforderliche Erledigen

•

Die for-Schleife bringt alle drei Elemente auf eine Zeile

•

Es gibt hilfreiche Abkürzungen für die Zuweisungsoperatoren in

•

Verbindung mit einer arithmetischen Operation.

•

Programmierung 1 Studiengang MI / WI