Java - Informatikunterricht

[1. Woche] Mit Java beginnen: NetBeans und der Structorizer

Struktogramme

Diese Unterrichtseinheit beschäftigt sich mit dem Umsetzen von Algorithmen in Programme. Für die Algorithmen verwenden wir die Darstellung in Struktogrammen, die wir mit dem Structorizer gestalten, einem Programm, das wir in der Schule schon installiert haben und das Du Dir hier selbst herunterladen kannst. Die Anleitung zur Installation steht hier. Die Installationsanweisungen sind für Deinen heimischen Rechner gedacht.

Außerdem werden wir unsere Programme in der Programmiersprache Java umsetzen, die von der schematischen Struktogramm-Darstellung in Quelltexte wechselt, die die meistverwendete Darstellungsform für Programme sind.

Wie Du mit dem Structorizer arbeitest, habe ich dir in diesem Video [Klick] erklärt. Es zeigt an der einfachen Umrechnung von Geschwindigkeiten von m/s in km/h das Funktionsprinzip.

Das Struktogramm, das in diesem Video entwickelt wird, enthält nur eine Abfolge von einfachen Anweisungen, eine Sequenz. Der Algorithmus wird von oben nach unten abgearbeitet.

Nun werden wir nach einem Struktogramm, das nur eine Sequenz beinhaltet, eine Entscheidung (genauer gesagt zwei) einbauen. Der Algorithmus soll in einem Geschäft Rabatte für Preise berechnen, die sich nach der Art des Käufers richten. Großhändler erhalten 15%, Einzelhändler 10%, alle anderen in dieser Woche immerhin 5%.

In dem Struktogramm werden mehrere Variablen verwendet. Bedenke, dass Variablennamen immer zusammenhängend geschrieben werden müssen. Aus der Art des Käufers wird artDesKaeufers. Den Umlaut ä schreiben wir ae.

Hier ist das Erklärvideo zu dem Rabattprogramm.

Aufgaben

Aufgabe 1: Starte den Structorizer und gib das Geschwindigkeitsprogramm aus dem 1. Video ein. Teste das Programm. Jede Angabe in m/s muss korrekt in km/h umgerechnet werden (also mal 3.6 gehen). Achtung:

3 Punkt 6, nicht 3 Komma 6, beim Programmieren sind die Zahlen englisch! Das gilt auch für eingegebene Zahlen. Speichere das Struktogramm als geschwindigkeit.nsd

Aufgabe 2: Setze das Struktogramm zur Rabattberechnung mit dem Structorizer um und teste es mit verschiedenen einfachen und schwierigeren Zahlen sowie mit allen Arten von Käufern. Was passiert, wenn Als Art des Käufers 4 eingegeben wird? Der Dateiname ist Rabatt.nsd

Java-Programme

Jetzt schreiben wir den Rabatt-Algorithmus als richtiges Java-Programm.

Die Anleitung zur Installation von Java und NetBeans steht hier.

Wenn du Java und NetBeans erfolgreich installiert hast (in der Schule ist es natürlich auf dem Rechner installiert), startest du das Programm NetBeans. Nun beginnst du ein neues Projekt (Menü Datei/Neues Projekt) und wählst aus den Vorlagen "Java-Anwendung (Java Application)" aus der Abteilung "Java" oder "Java (mit Ant)" aus (erstes Bild, Symbol ist die Kaffeetasse)

(Für Zuhause: Beim ersten Mal dauert es noch ein wenig, weil evtl. noch ein JavaFX-Plugin heruntergeladen wird (bitte Häkchen setzen) und JavaSE aktiviert wird.) Dann benennst du das Projekt mit dem Namen "Rabatt" (wir lösen die Rabatt-Aufgabe) und drückst "Fertigstellen".

Nun ist links eine Baumansicht des Projekts zu sehen, rechts der Quelltext des Programms, der im Augenblick noch nichts tut:

Drücke nun den Übersetzungsbutton (den grünen Play-Button). Das Programm wird nun in die Sprache, die der Computer versteht, übersetzt und gleich ausgeführt. Eine Erfolgsmeldung ziert nun das Ausgabefenster:

Der Play-Button.

Das Ausgabefenster.

Ersetze den kompletten Quelltext des leeren Projekts durch diesen Text:

////////////Anfang////////////

package rabatt;

import java.util.Scanner;

public class Rabatt

{

public static void main(String[] args)

{

Scanner eingabe = new Scanner(System.in);

double rabatt; //Variablen anlegen

double gezahlterBetrag;

int artDesKaeufers;

System.out.println("Wie hoch ist der gezahlte Betrag in Euro? ");

gezahlterBetrag = eingabe.nextDouble();

System.out.println("Art des Käufers: 1= Großhändler; 2= Einzelhändler; 3= sonstiges");

artDesKaeufers = eingabe.nextInt();

if (artDesKaeufers == 1)

{

rabatt = 0.15;

}

else

{

if (artDesKaeufers == 2)

{

rabatt = 0.1;

}

else

{

rabatt = 0.05;

}

double rechnung = gezahlterBetrag - gezahlterBetrag * rabatt;

System.out.println("Sie müssen " + rechnung + " Euro bezahlen");

}

}

///////////////////Ende//////////////////////

Wenn du den Quelltext kopiert hast, dann klicke mit der rechten Maustaste in das Quelltextfenster von NetBeans und wähle "Format", um den Text zu ordnen und besser lesbar zu machen.

Nun drücke den grünen Button und klicke ins Ausgabefenster. Gib als Betrag 300 ein und als Kundentyp 2. Als Ergebnis sollte ein um 10% verminderter Betrag von 270 Euro erscheinen.

Erläuterungen zu dem Rabatt-Quelltext

Das Programm gehört zur Aufgabe 4 des Algorithmen-Hefts (Download hier), dort sind ab Seite 6 die Aufgaben abgedruckt.

Der obige Quelltext setzt diesen Algorithmus um:

Was ist im Java-Programm neu?

Der Scanner. Das ist ein Programmteil, der an der Tastatur lauscht und Eingaben in Zahlen oder Texte umwandelt. Den Scanner nennen wir eingabe, wir brauchen im ganzen Programm nur einen.
Die Zeile Scanner eingabe = new Scanner(System.in); definiert den Scanner,
ganz oben wird mit import java.util.Scanner; ein Teil der Java-Bibliothek dafür importiert (funktioniert wie eine \usepackage-Anweisung in LaTeX). Eine Zahl lesen wir dann mit eingabe.nextDouble() für eine float-Zahl bzw. mit eingabe.nextInt() für eine ganze Zahl.
Variablen mit Typen. Jede Variable muss mit ihrem Typ deklariert (Namen festlegen, Speicher reservieren) werden, bevor sie verwendet wird. So muss rabatt vor der ersten Entscheidung bereitstehen, für rechnung genügt der Quelltext nach den Alternativen. int ist der Datentyp für Ganzzahlen, double für Fließpunktzahlen. Bitte nicht float verwenden, das gibt Probleme beim Compilieren.
Die Schreib-Anweisung ist System.out.print() - ohne Zeilenschaltung - oder System.out.println(). Es muss nichts importiert werden.
Nach jeder Anweisung steht ein Semikolon (;). Ausnahme: Nach den geschweiften Klammern einer if-Anweisung braucht man keins. - Häufigster Anfängerfehler, nicht verzweifeln. Auch Fortgeschrittenen passiert er.
Geschweifte Klammern {}. Jeder Ja- und Nein-Zweig der if-Anweisung wird in diesen Klammern geschrieben. Auch die main-Funktion und die gesamte Klasse (das Programm) steht in geschweiften Klammern. Zu jeder geöffneten Klammer gehört eine schließende. - Zweithäufigster Anfängerfehler, nicht verzweifeln Teil 2.
Zuweisung: In Java gilt das Gleichheitszeichen = (im Structorizer := oder <-)
Vergleich: In Java gilt das doppelte Gleichheitszeichen == (im Structorizer = )

Algorithmen in Java umsetzen

In diesem Abschnitt werden wir unsere mit dem Structorizer erarbeiteten Algorithmen in Java umsetzen. Dazu nutzen wir die Struktogramme aus dem vorhergehenden Unterrichtsblock.

Lege für jedes Programm ein neues NetBeans-Projekt an bzw. ein neues Codiva-Projekt. Wenn du nicht in Codiva angemeldet bist, dann kopiere die Quelltexte in einen Editor und speichere sie als Projektname.java.

Die NetBeans-Projekte sind standardmäßig im Ordner Dokumente/NetBeansProjects und enthalten verschiedene wichtige Dateien. Bitte nicht mit "Speichern unter" Texte herauskopieren, sondern immer den ganzen Ordner des Projekts kopieren.

Algorithmen mit Alternative (if-Anweisung)

Setze diese beiden Programme in Java um und teste die Programme:

Projekt "Bankgebuehren" (Aufgabe 2 auf Seite 6)

Anmerkungen:

Die if-Anweisung wird so formuliert: if(anzahlBuchungen <= 10){...}
Die Grundrechenoperationen sind + - * / mit runden Klammern.

Testfälle: 8/12/23 Buchungen ergeben 0, 60 bzw. 360 Cent.

Projekt "LineareGleichung"

(bitte keine Leerzeichen in den Projektnamen)

Projekt "LineareGleichung" (Aufgabe 3 auf Seite 6)

Anmerkungen:

Wenn m,n und x vom Typ double sind, reicht die Zuweisung x = -n/m
"Ungleich" ist in Java != und "Gleich" ist ==

Testfälle: m=2, n=5 ergibt eine Lösung -2.5, m=0 und n=0 ergibt L=R; m=0 und n=2 ergibt L={}

Aufgaben

In dieser Woche werden wir verstärkt in unser Algorithmen-Heftchen blicken (Download). Auf den Seiten 6-8 sind die Aufgaben.

Aufgabe: Fertige die beiden Projekte Bankgebuehren und LineareGleichung an und probiere die Programme aus. Lade die Quelltexte Bankgebuehren.java und LineareGleichung.java in den Abgabeordner der Sdui-Cloud hoch (sie befinden sich im src-Unterordner des NetBeans-Projekts; bei Codiva kopierst du den Quelltext in einen leeren Editor und benennst die Datei entsprechend). Du kannst die Dateien auch als E-Mail an e204info@gmail.com schicken, dann kannst du den Quelltext einfach in die E-Mail kopieren.
Viel Erfolg!

Wiederholung: Ein- und Ausgabe, Alternative (if-Anweisung)

Aufgabe 1: Fertige zur Aufgabe S. 6 Nr. 5 ein Struktogramm an (oder finde es in Deinem Hefter :-) und implementiere den Algorithmus in Java: Projekt quader. Nimm als Entscheidungsgrundlage ein Menü, das ganze Zahlen zur Auswahl anbietet. Benutze dazu eine Variable int antwort, die z. B. für den einen Fall den Wert 1 und für den anderen den Wert 2 annimmt. Denke bei den Quader-bezogenen Variablen daran, sie möglichst spät (=unten) zu deklarieren.

Aufgabe 2: Fertige zur Aufgabe S. 6 Nr. 6 ein Struktogramm an (oder finde es in Deinem Hefter :-) und implementiere den Algorithmus in Java: Projekt briefporto

[2. Woche]

Struktur eines Java-Programms

Den Quelltext eines Java-Programms kann man sich wie eine Zwiebel vorstellen.

Bild: Schichten einer Zwiebel (rechts hervorgehoben). Foto Mirko König

Die äußere Schicht bildet die Klassendefinition (den Klassennamen schreibt man groß), darin stecken einzelne Methoden (Unterprogramme). Die main()-Methode ist der Startpunkt des Programms (der sog. Einsprungspunkt für den Java-Interpreter). Sie beginnt immer mit der Zeile public static void main(String[] args) und wird - wie die Klasse selbst - von geschweiften Klammern umrahmt. Über der Klasse stehen noch die package- und die import-Anweisungen (ähnlich dem Vorspann in LaTeX).

Jede Anweisung wird mit einem Semikolon ; beendet.

In den Methoden können durch Schleifen oder Entscheidungen immer neue Schichten (Blöcke) entstehen, die durch geschweifte Klammern eingerahmt werden.

////////////Anfang////////////
package rabatt; // In NetBeans werden immer Pakete zurVerwaltung verwendet

// In Codiva baraucht man meist keine packages

import java.util.Scanner; // Die import-Anweisungen stehen vor der Klassendefinition

public class Rabatt // Jedes Programm ist eine Klasse mit main()-Methode

{ // Diese Klammer kann auch hinter "Rabatt" stehen
// In der Klasse können hier noch mehr Methoden stehen

public static void main(String[] args) // Jedes Programm hat genau eine main()-Methode

{ // Diese Klammer kann auch hinter args) stehen

System.out.println("Das Rabatt-Programm wird ausgeführt."); // Der eigentliche Quelltext für den Algorithmus

} // Schließende Klammer für die main()-Methode

} // Schließende Klammer für die Klasse, danach kommt nichts mehr

//////////////Ende////////////

Die Kunst des Quelltextschreibens besteht darin, den Algorithmus in einen fortlaufenden Text umzusetzen, der

- streng genommen - eine Zeichenkette ohne Formatierung ist:

package rabatt;import java.util.Scanner;public class Rabatt{public static void main(String[]args)System.out.println("Das Rabatt-Programm wird ausgeführt.");}}

Damit der Quelltext lesbar ist, werden untergeordnete Schichten des Programms nach rechts eingerückt. Der Editor von NetBeans unterstützt dich beim Einrücken. Falls das Programm sehr unübersichtlich wird, kannst du dem Chaos mit der rechten Maustaste und "Format" zu Leibe rücken. Dann wird jede untergeordnete Schicht weiter eingerückt.

Ein NetBeans-Projekt richtig speichern und kopieren

Ein NetBeans-Projekt besteht aus mehreren Ordnern, die in einem Ordner mit dem Projektnamen gespeichert sind. Standardmäßig legt NetBeans diese Ordner im Verzeichnis Dokumente/NetBeansProjects an.

Um ein Projekt auf einen anderen Datenträger zu kopieren, muss der gesamte Ordner (hier: der Ordner Rabatt) kopiert werden.

Speichere niemals einen Quelltext einzeln mit Datei/Speichern unter!

Für den Versand per E-Mail sollte der Ordner gezippt werden, achte aber darauf, den Ordner dist zu löschen! Darin befindet sich eine jar-Datei, die von vielen E-Mail-Anbietern nicht übertragen wird.

Umgang mit Fehlermeldungen

Über den Umgang mit Fehlermeldungen habe ich dir ein Video gedreht (14 min).

Schleifen

FOR-Schleife (gezählte Schleife)

Es soll eine Tabelle der Quadratzahlen erstellt werden. Das Programm zählt die Variable zaehler hoch und berechnet in jedem Durchlauf die Variable quadrat. Beide werden in je einer Zeile angezeigt.

Hier ist das Programm:

Die Schleifenvariable zaehler wird erst in der for-Anweisung deklariert, nicht vorher. zaehler <= 10 heißt Schleifenbedingung, zaehler++ sorgt fürs Hochzählen um 1.

Probiere auch die Rückwärtsvariante for (int zaehler=10; zaehler >= 1; zaehler--) aus.

Hier siehst du die Ausgabe des Programms.

Die Grenzen der Laufvariable können selbst auch Variablen sein: Im Summieralgorithmus "Gauss" wird von a bis b (a<b) jede ganze Zahl addiert (das ist Aufgabe 13 im Algorithmenheft).

Hier ist Aufgabe 15, die Berechnung aller Teiler einer ganzen Zahl mit Abkürzung, in dem nur die Teiler bis zur Wurzel der Zahl berechnet werden und die Gegenteiler zahl/teiler gleich mit ausgegeben werden.

Für 12 sind dann die Teilerpaare (1,12), (2,6), (3,4), dann sind alle Teiler komplett:

Die Wurzel berechnet man mit der Anweisung double wurzel = Math.sqrt(n);

Aufgaben der 2. Woche:

Du kannst jederzeit Fragen zu den Aufgaben stellen.

Bitte notiere, wie lange du gebraucht hast. Die 4 Pflichtaufgaben sollten in 3x45min geschafft sein.

Berechne die Tabelle der ganzen Quadratzahlen von 1 bis 20 (vorwärts und rückwärts. Erweitere den Zahlenraum und beobachte, bis zu welcher Zahl sich sinnvoll Berechnungen durchführen lassen. Projekt: Tabelle
Setze den Gauß-Algorithmus um (man sagt "Implementiere den Gauß-Agorithmus"). Projekt: Gauss
Implementiere die Teilerberechnung gemäß dem obigen Struktogramm. Projekt: Teiler
Noch eine Aufgabe zu if-Anweisungen: Setze den Algorithmus zur Lösung der quadratischen Gleichung in Normalform 0=x²+px+q um. Falls Du den Algorithmus nicht aus der Schule parat hast, entwirf ihn auf dem Papier neu. Projekt: QuadratischeGleichung

Zusatzaufgabe: Setze die Suche nach der Quadratzahl, die gleichzeitig eine Dreieckzahl ist (Dagobert-Aufgabe 11) um. Du kannst Edwins Struktogramm nutzen (siehe unten). Die while-Anweisung geht so:

while(ausgabe < 1000000){

//Anweisungen

} //Ende der while-Anweisung

Edwins Dagobert-Struktogramm, das die magische Zahl findet.

[3. Woche]

Algorithmen in Java implementieren

In dieser Woche werden wir wieder in unser Algorithmen-Heftchen blicken (Download). Auf den Seiten 6-8 sind die Aufgaben.

Schleifen: Wahl der Schleifenart

Um einen Programmabschnitt mehrmals ablaufen zu lassen, gibt es drei Möglichkeiten. Es gibt die gezählte Schleife, die Solange-Schleife und die Wiederhole-bis-Schleife.

Die gezählte Schleife verwendet man, wenn man die Anzahl der Durchläufe kennt. Ihr habt sie bei der Gauß-Aufgabe verwendet, und sie wurde in der vorigen Woche besprochen.

Diesmal stehen die Solange- und die Wiederhole-bis-Schleife im Fokus.

Als Beispielaufgabe nehmen wir Nr. 8, hier werden Zahlen genannt, von denen die bisher kleinste bzw. größte genannt werden soll. Als Abbruch nehmen wir die Eingabe einer negativen Zahl.

Als Bedingung der Schleife gilt: Solange (die eingegebene Zahl nichtnegativ ist). Also geben wir einmal eine Zahl vor dem Start der Schleife ein und setzen die Variablen groesste und kleinste auf ihren Wert. Sodann begeben wir uns in die Schleife. Den Quelltext zeige ich Dir hier:

Hier ist ein Protokoll:

Diesen Algorithmus können wir auch mit der endgesteuerten Schleife, der Wiederhole-bis-Schleife, formulieren. Da es in Java keine Entsprechung dafür gibt, sondern die do {} while()-Schleife, muss die Endbedingung ins Gegenteil verkehrt werden. Aus "Wiederhole, bis eine negative Zahl eingegeben wird" wird so "Wiederhole, solange die Zahl nichtnegativ ist". Um abzuwehren, dass eine zu Beginn eingegebene Zahl negativ ist, baue ich noch eine if-Anweisung ein, die den Schleifenkörper umrahmt.

Du siehst, das Programm unterscheidet sich nicht sehr von dem oberen. Meistens lässt sich ein Algorithmus gleichwertig in beiden Varianten formulieren. Hier ist noch das Protokoll:

Aufgabe 1: Die Nr. 9 auf Seite 6 des Hefts ist ähnlich. Schreibe das Java-Programm mittel zu dieser Aufgabe.

Aufgabe 2: Die Nr. 10 haben wir im Unterricht besprochen. Schreibe das zugehörige Java-Programm im Projekt nEck.

Zusatzaufgabe: Wähle aus einer der Aufgaben 16 oder 18 auf Seite 7.

Nun wünsche ich Euch viel Erfolg beim Lösen. Wenn Ihr Fragen habt, schreibt mir bitte.

[4. Woche] Schleifen

Mit unseren Textausgaben können wir auch geometrische Formen (in gewissen Grenzen) gestalten und dabei unsere Fähigkeiten im Programmieren von Schleifen verbessern. Die Programme beruhen auf dem einzelnen Ausgeben des Sternchen-Symbols mit der Anweisung

System.out.print("*");

und dem Setzen einer Zeilenschaltung mit der Anweisung

System.out.println();

Weiterhin werden for-Schleifen der Form

for (int zeile=1; zeile <= 5; zeile++)

benutzt: Der Zähler der Schleife heißt hier zeile, er beginnt mit dem Wert 1. Die Bedingung zur Weiterführung ist, dass der Zähler kleiner oder gleich 5 ist (Schleifenbedingung). Nach jeder Ausführung des Schleifenkörpers wird der Zähler um 1 erhöht (zeile++), damit die Schleife auch enden kann.

Diese Schleife kann auch rückwärts ausgeführt werden:

for (int zeile=5; zeile >= 1; zeile--)

Hier ist das Programm mit seiner Ausgabe. Es wird ein 5 Zeilen hohes und 10 Spalten breites Rechteck ausgegeben.

Ausgabe des Programms

Aufgabe 1 Führe für die 5 die Variable zeilenzahl und für die 10 die Variable spaltenzahl ein. Lass einen Scanner die beiden Zahlen einlesen und gib ein Rechteck mit variabler Zeilen- und Spaltenzahl aus. Projekt: rechteckvariabel

In der nächsten Schleife geben wir nur so viele Sterne aus, wie die Nummer der jeweiligen Zeile ist. Damit läuft die innere Schleife bis zum Wert der Variable zeile:

Aufgabe 2 Ändere das Programm so ab, dass das Dreieck auf der Spitze steht (Hinweis: Lasse die äußere Schleife rückwärts ablaufen. Projekt: dreieckzurueck):

Aufgabe 3 Lass das Programm vor den Sternchen einige Leerzeichen ausgeben (" "). Dann sollen einige Sternchen folgen. Gestalte folgende Muster, wieder mit geschachtelten for-Schleifen:

parallelogramm

Aufgabe 4 Jetzt wird's schwieriger: Für diese Grafiken gibt es verschiedene Lösungsmöglichkeiten. Am besten verwendest Du zwei aufeinanderfolgende for-Schleifen innerhalb der äußeren for-Schleife (Projekt aufgabe4)

Aufgabe 5 Löse eine der beiden Aufgaben: S. 7 Nr. 18 (zahlenraten) oder S. 8 Nr. 19 (diophant) in einem Java-Programm.

[5. Woche] Der Zufall und der Computer

Wenn man ein wenig über Algorithmen nachdenkt, stellt man sicher fest, dass der Zufall im Computer offensichtlich keinen Platz hat, denn der Computer kann ja mittels seiner Programme nur Algorithmen ausführen, die bekanntlich deterministisch sind, d. h. unter gleichen Voraussetzungen gleiche Ergebnisse liefern.

Über dieses Problem haben die Programmierer nachgedacht und eine Lösung gefunden. Es gibt bestimmte Funktionen, die auf besondere Weise arbeiten: Rechnet man mit ihnen aus einem Argument x einen Funktionswert y aus, nimmt diesen wieder als neues Argument x und beginnt von vorn usw., dann entsteht eine Folge von Zahlen, die recht gut gleichverteilt sind, d. h. innerhalb eines Bereichs sind dann alle Werte etwa gleich oft vertreten.

Das Problem ist jetzt nur noch, nicht immer die gleiche Startzahl zu wählen, denn sonst entsteht immer die gleiche Zahlenfolge. Man löst dieses letzte Problem, indem man als Startzahl die augenblickliche Uhrzeit (bzw. eine davon abgeleitete Zahl) verwendet. So kann man immer in eine andere Stelle der der Pseudo-Zufallszahlenfolge einsteigen.

Wir wollen die Pseudozufallszahlen vereinfacht Zufallszahl nennen.

Wie geht der Zufall nun in Java?

Dieses kurze Programm erzeugt eine Zufallszahl und zeigt sie an:

Aufgabe 0: Gib das Programm ein und starte es mehrmals. Du wirst immer ein anderes Ergebnis erhalten. Für diese Aufgabe musst Du nichts einsenden.

Die Klasse Random arbeitet so ähnlich wie der Scanner: Man startet sie einmal und ruft dann mit nextInt() immer neue Zahlen ab (es geht auch nextDouble(), wir brauchen aber ganze Zahlen). Neu ist, dass wir das Ergebnis eingrenzen können: Mit einer ganzen Zahl in der Klammer (als "Parameter") gibt man die größte Zahl vor, die erreicht werden kann. Mit einer 6 erreicht man Zahlen von 0 bis 5, mit einer 100 Zahlen von 0 bis 99.

Probiere das mit der 6 aus (schreibe sie in die Klammer):

int zufallsZahl = zufall.nextInt(6);

Starte das Programm immer wieder, Du bekommst jetzt immer Zahlen von 0 bis 5 errechnet.

Um eine sechsseitigen Würfel zu simulieren, addieren wir noch 1:

int zufallsZahl = 1 + zufall.nextInt(6);

Um die Aufgabe 20 aus unserem Algorithmenheftchen lösen zu können, haben wir nun alle Voraussetzungen. Im einfachsten Fall führst Du jetzt einfach eine Strichliste.

Der Computer kann die Zählung aber auch selbst vornehmen. Dazu führst Du für jede Würfelzahl einen Zähler ein und zählst die Werte mit. Das Zählen und die Zufallszahlenermittlung gehört natürlich in eine Schleife, die wir z. B. 6000-mal ausführen. Damit müsste jede Zahl etwa 1000-mal vorkommen.

In meinem Versuch ist die 4 sogar genau 1000-mal gewürfelt worden!

Aufgabe 1: Löse die Aufgabe 20 im Heft, indem Du das obenstehende Programm mit Deiner Anzahl der Versuche ausprobierst und Deine Statistik erstellst. Sende Deine Tabelle ein.

Aufgabe 2: Wieso kann man nicht einfach zufall.nextInt(7) für den Würfel nehmen, dann wäre die größte Zahl doch auch 6?

Aufgabe 3: Löse die Aufgabe 21. Anleitung: Nimm einen Zähler, der immer um 1 hochgezählt wird, wenn keine 6 erscheint. Kommt eine 6, so wird er ausgegeben und wieder auf 0 gesetzt. Sammle die Zähler in einer Summe, zähle die Sechsen mit und bestimme nach einer Weile den Mittelwert (siehe Mittelwertprogramm).

Zusatzaufgabe: Löse Aufgabe 22.

[6. Woche] Übungen

Im Menüpunkt "Lösungen" werden Euch für die bisherigen Wochen besonders gute unter Euren Einsendungen angezeigt.

Übungen zum Zufall werden mit Deinen Kenntnissen aus den vorangegangenen Wochen kombiniert.

Wähle aus den 4 Aufgaben drei aus und sende die Programme bis Freitag, 8. Mai 2020 ein.

Aufgabe 1: Schreibe ein Programm, das eine ganze Zufallszahl im Bereich von 20 bis 50 ausgibt. aufgabe1.java

Aufgabe 2: Verändere Aufgabe 1 wie folgt: Das Programm soll 1000 Zufallszahlen im Bereich von 20 bis 50 ausgeben. Anschließend wird der Mittelwert der berechneten Zahlen ausgegeben. Entspricht der Mittelwert Deinen Erwartungen? erwartungswert.java

Aufgabe 3: Schreibe ein Programm, das eine zufällige gerade Zahl im Bereich von 1 bis 100 ausgibt. zufallgerade.java

Aufgabe 4: Zahlenraten , umgekehrt. Der Computer "denkt" sich eine ganze Zahl im Bereich von 1 bis 1000 (er ermittelt eine Zufallszahl, die er nicht anzeigt), die Nutzerin / der Nutzer muss sie erraten. Das Programm soll den Rateprozess bis zur richtig erratenen Zahl durchführen. zahlenratenUser.java

Zusatzaufgabe: Erweitere das Programm aus Aufgabe 4 mit einem Zähler. Lobe den User, wenn er nur wenige Zahlen tippen musste, tadle ihn, wenn es zu viele waren. Die Maximalzahl notwendiger Ratevorgänge errechnet sich übrigens aus der Anzahl der Teilungen von 1000, bis man auf 1 kommt (das ist der Logarithmus von 1000 zur Basis 2). zufallsraten.java

[7. Woche]

Compiler und Interpreter

Sieh Dir dieses Video über den Java-Interpreter an. In ihm werden die Begriffe Compiler und Interpreter erläutert. In Java werden beide - eigentlich gegensätzliche - Prinzipien verwendet.

Aufgabe 1: Wenn man Interpreter und Compiler mit den beiden Tätigkeiten "ein ganzes Buch übersetzen" und "ein Gespräch dolmetschen" vergleicht, welche Tätigkeit entspricht dann welchem Prinzip? Ordne Interpreter und Compiler den beiden Tätigkeiten zu und begründe Deine Wahl.

Aufgaben zur Teilbarkeit

In dieser Woche geht es um Teilbarkeit. Wir erinnern uns: für int-Zahlen drückt die Bedingung

(zahl % teiler == 0)

aus, dass zahl durch teiler teilbar ist. Das haben wir vor einigen Wochen schon in dem Programm genutzt, das die Teiler einer Zahl berechnete. Dieses Programm könnt Ihr zur Weiterentwicklung verwenden.

Diesmal berechnen wir Primzahlen. Sie zeichnen sich dadurch aus, dass sie genau 2 Teiler haben, die 1 und sich selbst.

Aufgabe 2: Das Programm primzahl.java soll eine natürliche Zahl einlesen und durch Zählung der Teiler bestimmen, ob es eine Primzahl war. Ausgegeben wird die Meldung "Primzahl" oder "keine Primzahl".

Aufgabe 3: Umgib das Programm aus Aufgabe 2 mit einer for-Schleife, die von einem Startwert bis zu einem Endwert (natürliche Zahlen) alle Primzahlen ausgibt. Alle Nicht-Primzahlen sollen nicht ausgegeben werden. Beispiel: Eingabe 10, 20. Ausgabe: 11, 13, 17, 19. Programm: primzahlfolge.java

Zusatzaufgabe: Ein Programm soll die Primfaktorzerlegung einer gegebenen natürlichen Zahl bestimmen. Anleitung: Teile zunächst so oft durch 2, wie das geht. Dann nimm 3 als möglichen Teiler, dann 4 usw.

Die Zusatzaufgabenleute der letzten Woche lösen nur Aufgabe 1, 3 und die Zusatzaufgabe.

[8. und 9. Woche]

Größter gemeinsamer Teiler

Zur Berechnung des größten gemeinsamen Teilers (ggT) zweier natürlicher Zahlen kann man einen Algorithmus mit einer Schleife programmieren. Er basiert auf folgender Idee:

Es machen mit: Die Zahlen a und b, der ggT und ein Rest r. Heute dürft Ihr einmal einbuchstabige Variablen nehmen! Ohne Beschränkung der Allgemeinheit sei a >= b.

Die Idee des Algorithmus ist: Der ggT passt vollständig mehrmals in a und in b hinein, sonst wäre es kein Teiler.

Nun berechnen wir den Rest r = a % b, der beim Teilen von a durch b entsteht.

Nun beobachten wir: Wenn der ggT in a und in b vollständig hineinpasst, dann auch in den Rest r.

Jetzt tauschen die Variablen die Rollen: b wird das neue a (Anweisung a = b;), der Rest r wird das neue b (Anweisung b = r;). Dann geht der Algorithmus wieder von vorn los.

Wieder berechnen wir den Rest r = a % b. Wieder bleibt etwas übrig (in diesem Beispiel sehen wir schon, der ggT. Aber das weiß der Algorithmus noch nicht.).

Erneuter Rollentausch, erneute Resteberechnung:

Nun ist der Rest gleich Null:

Damit hören wir auf (Ende der Schleife: Sie endet, wenn der Rest gleich Null ist).

Das Ergebnis steht fest: Das letzte b ist der gesuchte ggT.

Nicht erschrecken, die Aufgaben sind diesmal weniger komplex, und sie sollen für 2 Wochen reichen.

Aufgabe 1: Spiele den Algorithmus mit den Zahlenpaaren (21,15) (Ergebnis: 3), (7,7) (Ergebnis 7) und (19,12) (Ergebnis 1) durch. Schreibe an die Zahlen jeweils a, b oder r.

Aufgabe 2: Der Algorithmus soll zwei int-Zahlen zahl1 und zahl2 entgegennehmen und die beiden eingegebenen Zahlen zunächst so a und b zuordnen, dass a größer oder gleich b ist (in Java: a >= b). Entwirf diesen Abschnitt des Algorithmus als Struktogramm.

Aufgabe 3: Formuliere den gesamten Algorithmus für den ggT als Struktogramm. Im Klassenzimmer kannst Du den Structorizer nehmen oder ihn für daheim hier herunterladen. Papier geht auch.

Aufgabe 4: Schreibe das Programm ggTeiler.java, das dem Struktogramm entspricht. Teste das Programm mit verschiedenen Eingaben, wie in 1.

Aufgabe 5: Im Text stand folgender Satz:

Jetzt tauschen die Variablen die Rollen: b wird das neue a (Anweisung a = b;), der Rest r wird das neue b (Anweisung b = r;). Die beiden Zuweisungen dürfen nur in dieser Reihenfolge abgearbeitet werden. Warum?

Aufgabe 6: Zahlen unter 1 dürfen nicht eingegeben werden. Vervollständige das Programm, das dann solche Zahlen abwehrt.

Aufgaben ohne ggT

Aufgabe 7: Entwirf (Struktogramm) und implementiere (Java) ein Programm, das eine positive ganze Zahl einliest, die Summe der Ziffern der Zahl berechnet und die Summe ausgibt!

Beispiel: Eingabe 4132 -> Verarbeitung 4+1+3+2 -> Ausgabe 10. Programm: quersumme.java

Hinweis: Auch hier kannst Du wieder mit Resten und einer Schleife arbeiten. Keine Strings notwendig!

Zusatzaufgabe: Anja merkt sich zwei positive ganze Zahlen. Jede Zahl ist kleiner oder gleich 100. Anja addiert die beiden Zahlen und nennt Peter die Summe. Dann multipliziert Anja die beiden Zahlen und nennt Peter das Produkt. Nun soll Peter die beiden Zahlen ermitteln, die sich Anja gemerkt hat. summeprodukt.java

[9. Woche] Pixelgrafik

Überraschung! Mitten in der Woche kommt ein neues Thema. Weiter oben steht alles zur aktuellen 8./9. Woche.

Für alle, die schon die 8./9. Woche (ggT, Quersumme, Summe/Produkt) fertig gelöst haben, kommt hier das nächste Thema: Computergrafik, hier: Pixelgrafik.

Das Java-Programm für den Einstieg findet Ihr hier:

Wer mit NetBeans arbeitet, legt ein neues Projekt "Fenster" an und kopiert den Quelltext dorthin: Fenster.java

Wer online arbeitet, lädt sich Main.java und kopiert den Quelltext in die unten beschriebene Webseite.

Eine neue Sicht auf Programme

Bisher endeten die Programme gleich nach der Abarbeitung, es sei denn, eine Schleife lief ewig weiter. Nun aber wird ein Fenster geöffnet, das weiterexistiert, bis es vom Nutzer geschlossen wird, auch wenn die Zeichnung schon fertiggezeichnet ist. Solche Programme nennt man grafische Benutzeroberflächen (graphical user interface, GUI). Und wer jetzt denkt, da laufen wohl Schleifen weiter, geht nicht fehl: In den GUI-Programmen läuft eine sogenannte Ereignisschleife, die fortlaufend auf Ereignisse wartet. Das einzige, das bei den ersten Programmen erwartet wird, ist das Drücken des Schließknopfes (und das Verschieben des Fensters auch).

Ein GUI-Programm erschaffen

Mit NetBeans: Wie oben beschrieben, wird ein einfaches "Java Application"-Projekt wie üblich erzeugt und mit dem Quelltext versehen (Das Projekt heißt wie auch die Klasse "Fenster", der Name wird im Programm mehrmals genauso verwendet. Nach dem Start des Programmes (grüner Play-Button) zeigt sich ein neues Fenster mit der Zeichnung, das erst mit seinem Schließknopf oder mit dem Stop-Button von NetBeans geschlossen werden kann. Zum Weiterprogrammieren muss das Fenster wieder geschlossen werden!

Die Online-Variante: Noch ein Schock - wir müssen unsere schöne Codiva-Welt verlassen und eine andere Webseite benutzen - repl.it. Aber keine Sorge, repl.it arbeitet ähnlich wie Codiva, bietet aber die Möglichkeit, Grafiken mit Java zu erzeugen. Für eine Webseite ist das eine große Leistung.

Beim ersten Aufruf wählt man "Start coding"

und scrollt zu "Java Swing" (oder tippt "Swing" in die Suche). Dann klickt man "Create repl".

Ab dem 2. Mal bzw. nach der Anmeldung rufen wir wieder repl.it auf und öffnen das Menü (1), um die Programmiersprache (2) zu wählen. Wir nehmen - ziemlich weit unten - im Abschnitt GUI die Option Java Swing (3). ...

... Es öffnet sich ein viergeteiltes Fenster, in der Mitte ist der Editor, rechts oben die grafische Ausgabe. Textausgaben mit System.out.println() könnt Ihr in die Konsole rechts unten machen. Kopiert also Main.java in den Editor und startet das Programm (run).

Auch hier läuft das Fenster, solange der stop-Button nicht gedrückt wird, in den sich der run-Button verwandelt hat. Wenn Ihr Euer Programm weiterentwickeln wollt, müsst Ihr es mit diesem Button anhalten.

Die erzeugte Computergrafik (jetzt wieder NetBeans und repl.it)

Die nächste Überraschung bringt das Koordinatensystem: Zwar geht die x-Achse nach rechts, aber der Ursprung ist in der linken oberen Ecke, und die y-Achse geht nach unten. Die Anweisung

g.drawLine(100,50,300,200);

zeichnet also eine Strecke von einem Punkt, der 100 Pixel vom linken Rand und 50 Pixel vom oberen Rand entfernt ist, nach (300,200).

Aufgabe 0: Richte Deinen Computer mit dem Beispielprogramm oben ein und probiere es aus. Für die Arbeit mit repl.it macht sich eine Anmeldung nicht schlecht, es geht aber auch ohne. Ohne Anmeldung musst Du die Programme zum Aufheben kopieren und auf dem Rechner in Textdateien speichern (bitte kein Word, btw).

Was wir an import-Anweisungen brauchen

Zusätzlich zu den unteren drei, die schon im obigen Programm standen, nehmen wir noch import-Anweisungen für den Zufall (kennen wir schon) und - neu - für die Farbe ins Programm.

Grafik und Zufall

Im Bild sind 200 zufällig ermittelte Strecken dargestellt, die vollständig in ein Rechteck vorgegebener Größe passen. In der Übung nehmen wir das 600x400 Pixel große Fenster zum Maßstab und richten danach die Zufallszahlenermittlung aus. Das können wir für den x-Wert mit zufall.nextInt(600) und für die Ordinate mit zufall.nextInt(400) gewährleisten.

Die 200 Strecken lassen wir in einer Schleife zeichnen, da jede Strecke im Prinzip auf die gleiche Weise erzeugt wird.

Damit werden der Startpunkt (x1,y1) und der Endpunkt (x2,y2) der Strecken jeweils im vorgesehenen Bereich ermittelt. Den Zufallsgenerator initialisieren wir außerhalb der Methoden paint() und main() (rechtes Bild).

Die Strecken färben wir noch ein. Dazu gibt es die Anweisung g.setColor(rot,gruen,blau) mit Werten von 0 bis 255 für die Grundfarben (0=dunkel, 255=hell). Das Ergebnis mit 500 Strecken ist neben der vollständigen paint()-Methode zu sehen:

Hier ist noch einmal das gesamte Programm zum Vergleich. Links: für NetBeans, rechts: für repl.it

Die beiden Programme unterscheiden sich nur im Klassennamen (Fenster/Main) und in der package-Klausel.

Aufgabe 1: Setze die paint()-Methode in der angegebenen Weise um. Achte darauf, dass die Farbwerte immer im Bereich 0 bis 255 bleiben, sonst gibt es eine Fehlermeldung. Sende nur den Quelltext der paint-Methode und sende einen Screenshot des Fensters ein. Den Quelltext kannst Du in die E-Mail kopieren. Bilddatei: strecken.png (oder jpg)

Aufgabe 2: Eine Ellipse wird mit der Anweisung g.drawOval(x,y,breite,hoehe) gezeichnet (ausgefüllte Ellipsen mit g.fillOval(x,y,breite,hoehe)). Erzeuge ein Bild der oben gezeigten Art. Achte darauf, dass Breite und Höhe der Ellipsen wesentlich kleiner sein müssen als die Position (x,y), weil die Ellipsen auf das Bild passen müssen. Sende den Quelltext und das Bild ellipsen.png ein.

Aufgabe 3: Zeichne mit g.fillRect(x,y,breite,hoehe) Rechtecke ähnlich wie oben, die nur Rottöne enthalten. Sende den Quelltext und das Bild roterechtecke.png ein.

[10. Woche] Fadengrafiken

Fotos Mirko König

Auf den Bildern seht Ihr drei Arbeiten, die in der Freien Fröbelschule Keilhau bei Rudolstadt angefertigt worden sind. Das mittlere Motiv symbolisiert die drei Spielgaben Friedrich Fröbels für Kinder - die Kugel auf der Walze, die auf dem Würfel steht. Was hier mit gespannten Fäden durch Löcher im Papier hergestellt wird, können wir mit unseren drawLine-Anweisungen in einem Javaprogramm auch zeichnen. Für unsere Programmierung ist es reizvoll, dass viele Regelmäßigkeiten in kurz formulierten Algorithmen darstellbar sind.

Wie entsteht so eine Grafik? Sehen wir uns das linke Quadrat an. Offensichtlich gibt es nur (gerade) Strecken, die interessanterweise eine gebogene Hüllkurve haben. Überdies ist das Quadrat aus vier rechten Winkeln zusammengesetzt, die mit Strecken ausgekleidet sind und ihren Scheitel in den Ecken des Quadrats haben. Einen der rechten Winkel habe ich hervorgehoben.

Wir verschaffen uns zunächst einen Überblick über die Koordinaten, in denen die Zeichnung liegen soll. Wir nehmen 50 Pixel Entfernung vom Rand links und oben, und da das Fenster 400 Pixel hoch ist, wird das umgebende Quadrat 300 Pixel hoch und breit sein. Somit wird die Zeichnung auch 50 Pixel über dem unteren Rand enden.

In der vereinfachten Ansicht seht Ihr 6 Strecken, deren Startpunkte links übereinander und deren Endpunkte unten nebeneinander aufgereiht sind, immer im Abstand von 60 Pixeln. Hier sind die zugehörigen Grafikanweisungen:

So könnte man das Programm natürlich schon schreiben. Jedoch wäre ein Abstand von 60 Pixeln ziemlich grob, 20 oder 10 wären ansehnlicher, wie in dem Bild oben. Dann aber artet das Vorhaben in Schreibarbeit aus, was wir als Programmierer überhaupt nicht schätzen. Was man automatisieren kann, sollte man auch vom Computer erledigen lassen!

Sehen wir uns also die Zahlen etwas genauer an:

Die Abszisse x der Startpunkte ist immer 50, ihre Ordinate y steigt ab 50 in 60er-Schritten.

Die Abszisse der Endpunkte steigt ab 50 in 60er-Schritten, ihre Ordinate ist konstant 350.

Die Variable steigt also in diesem Bild immer von 50 bis 350 . Dies lässt sich mit einer for-Schleife realisieren, die die Schleifenvariable i immer in 60er-Schritten wachsen lässt. Den Basiswert 50 nehmen wir als Summanden für i:

Nun fällt uns die Vervielfachung der Strecken leicht: Die Erhöhung geht in 20er- oder 10er-Schritten.

Damit haben wir das Programm für einen Winkel fertig.

Und so plant Ihr Eure Fadengrafik (ein Winkel):

Legt die Koordinaten der Eckpunkte fest.
Welches sind die Startpunkte, welches die Endpunkte der Strecken (sie liegen jeweils auf einer Geraden)?
Schreibt die drawLine()-Anweisung für die erste Strecke auf, dann die für die letzte Strecke.
Welche Koordinaten sind konstant, welche sind variabel? In welchen Schritten steigen/fallen die Werte?
Führt eine Schleifenvariable (hier: i) für die for-Schleife ein. Achtung: Für einen Winkel braucht Ihr nur eine Schleifenvariable, so kompliziert die Zeichnung auch scheinen mag!

Die 4 Teilwinkel "Links oben", "Links unten", "Rechts oben" und "Rechts unten" - LO, LU, RO, RU

Aufgabe 1: Entwickle die for-Schleifen für diese 4 Teilwinkel. Probiere sie im Programm (in der paint()-Methode) aus. Für diese Aufgabe ist nichts einzusenden.

Aufgabe 2: Schreibe die vier for-Schleifen nacheinander in die paint()-Methode, um das komplette Quadrat in einem Programm zu zeichnen. Rechts neben dem fertigen Quadrat siehst Du, wie man zwei for-Schleifen nacheinander schreiben kann, nämlich ohne Semikolon vor dem 2. for (es geht auch mit). Die RU-Schleife gibts als Geschenk :-) Sende die Datei quadrat.jpg und den Quelltext der paint()-Methode ein.

Links: Die beiden for-Schleifen nacheinander. Rechts: So geht's auch!

Für die nächste Aufgabe ändern wir die LU-Schleife leicht ab. Die Startpunkte liegen jetzt auf der Diagonalen des Quadrats. Dafür ist die Abszisse des Startpunkts variabel, nämlich 350-i (der Wert fällt). Vielleicht überrascht es, dass wir nach wie vor nur mit der Variable i auskommen (das habe ich ja oben schon geschrieben).

Man kann auch die Veränderung in x-Richtung verlangsamen und halb so schnell fallen lassen: 200-i/2

Dreieck

Zelt

Aufgabe 3: Realisiere dieses Dreieck als Programm und schicke dreieck.jpg sowie den Quelltext von paint().

Aufgabe 4: Schicke zelt.jpg und den entsprechenden Quelltext.

Zusatzaufgabe: Realisiere die untenstehende Grafik komplex.jpg. Achte auf Symmetrien, mit denen Du die Programmierung erleichtern kannst. Sende auch den Quelltext ein. Für die Zusatzaufgabe können 2 andere Aufgaben gestrichen werden.

komplex

[11. Woche] Mehr Fadengrafiken

In dieser Arbeit der Keilhauer Fröbel-Schüler scheint eine Reihe Würfel dargestelt zu sein. Die uns zugewandten Seiten sind gelb, die Oberseiten orange, die linken und rechten Seitenflächen schwarz - scheinbar. Das gesamte Bild reizt vielleicht zum Nachprogrammieren, aber: Die extrem vielen Teilfiguren schafft man in drei Stunden gar nicht.

Wirklich nicht?

Im Bild sind jede Menge Quadrate und Parallelogramme dargestellt, die ihrerseits aus je 4 Winkeln bestehen, die wir als rechten Winkel in der 10. Woche ausführlich besprochen haben. Störend ist jetzt nicht mehr viel, außer der Vielzahl und der unterschiedlichen Position der Eckpunkte. Diese letzte Komplexität bewältigen wir mit - Variablen!

Wir verallgemeinern das Problem so: Gegeben sind drei nicht auf einer Geraden liegende und voneinander verschiedene Punkte A, S und B, wobei S den Scheitel des Winkels ASB bildet, und AS sowie BS die Schenkel des Winkels sind. Als Variablen im Programm dienen die Koordinaten der drei Punkte vom Typ int:

Punkt A: Abszisse ax, Ordinate ay

Punkt S: sx, sy

Punkt B: bx, by

Deklaration: int ax,ay,sx,sy,bx,by;

Initialisierung: ax=150; ay=30; // usw.

Damit können wir ein Programmstück schreiben, das aus gegebenen 6 Koordinaten eine Fadengrafik ausrechnet.

Die erste Strecke würde mit

g.drawLine(ax,ay,sx,sy);

gezeichnet, die letzte mit

g.drawLine(sx,sy,bx,by);

Die Reihe der Startpunkte der Strecken würde also in gleichmäßigen Schritten von A bis S laufen, die Endpunkte gehen von S bis B.

Angenommen, es gibt 6 Strecken (wie oben im Bild), dann müssen in x- und y-Richtung 6 gleichmäßig auf einer Linie verteilte Startpunkte gezeichnet werden. Dann gibt es übrigens 5 Zwischenräume.

Nach den Strahlensätzen sollte klar sein, dass die x- und y-Werte wie die Punkte selbst in gleichen Abständen wachsen bzw. fallen. Es sind also gleiche Bruchteile der Differenzen ax-sx sowie ay-sy, um die die Koordinaten der Startpunkte wachsen oder fallen. Nun ans Werk:

Aufgabe 1: Errechne die Koordinaten der 6 Start- und Endpunkte allgemein aus den Koordinaten ax, ay, sx, sy, bx, by. Punkt A muss also schrittweise in S übergehen, S schrittweise in B.

Aufgabe 2: Lege drei Punkte A, S, B mit ihren je 2 Koordinaten im Fenster fest. Formuliere die Reihe der Koordinaten in drawLine-Anweisungen. Beachte die Tücken der ganzzahligen Division. Probiere die 6 Anweisungen im Programm aus und überzeuge Dich davon, dass die gewünschten 6 Strecken angezeigt werden. (Anweisungen bitte einsenden, Bild 6strecken.jpg einsenden).

Aufgabe 3: Mach aus den 6 einzelnen Anweisungen eine for-Schleife, die die 6 Strecken selbständig zeichnet. Ändere die Schleife so ab, dass 11 oder 21 Strecken gezeichnet werden (10 bzw. 20 Zwischenräume). (Sende die Schleife ein und das Bild for10.jpg)

Aufgabe 4: Es soll ein "Würfel" wie im Bild gezeichnet werden. Dazu sind 12 Winkel zu zeichnen. Anleitung: Lege für jeden Winkel zunächst die 6 Koordinaten ax, ay, sx, sy, bx, by fest und kopiere die Schelife aus Aufgabe 3 dahinter. Sende die Anweisungen und das Bild wuerfel.jpg ein.

Löse die Zusatzaufgaben als Ersatz für die Aufgaben 1-4.

Zusatzaufgabe 1: Gestalte einen größeren Ausschnitt aus dem Bild ganz oben (mehrere Würfel). Anleitung: Für 4 Eckpunkte eines Quadrats muss immer die gleiche Folge von 4 for-Schleifen ausgeführt werden. Versuche, aus gegebenen 4 Eckpunkten eines Quadrats / Parallelogramms die Anweisungsfolge möglichst allgemein zu formulieren. Sende den Quelltext und das Bild wuerfellandschaft.jpg ein.

Zusatzaufgabe 2: Ändere die Fadengrafik wie im Bild ab und finde eine allgemeine Lösung für 4 Punkte A,B,C und D. Sende den Quelltext und das Bild sattelkurve.jpg ein.

Repl.it-News

Beim Einloggen in repl.it kann es passieren, dass die Meldung "program is already running" erscheint, und nichts lässt sich übersetzen. Lösung: Klicke ins schwarze Textausgabefenster rechts unten und drücke Strg-C (Programm abbrechen in Unix). Dann kannst Du das Programm starten oder weiterentwickeln.

[12. Woche] Übungen zur Grafik

Diesmal soll die Grafik Zahlen in einem Diagramm darstellen. Die Zahlen stellen wir vor der Erstellung der Grafik (vor den frame-Anweisungen) als Zufallszahlen bereit. Damit sie von main() und von paint() aus zu sehen sind, werden sie - mit dem Qualifizierer static - außerhalb der beiden Methoden deklariert.

Die paint()-Methode sollt Ihr selbst ausfüllen.

Zum Vergleich mit der grafischen Darstellung geben wir die Zahlen auf der Konsole aus. So könnte die Darstellung aussehen:

In diesem Beispiel habe ich Zufallszahlen bis 300 gebildet, damit die Linien so lang wie die entsprechenden Zahlen sind.

Aufgaben

Von den insgesamt 6 Aufgaben löse drei und sende den Quelltext der paint()-Methode und einen Screenshot ein.

Aufgabe 1: Setze das Programm um und lasse in der paint()-Methode das oben gezeigte Diagramm entstehen (drawLine-Anweisung).

Aufgabe 2: Ergänze Anweisungen, die an das Diagramm zwei Achsen mit Beschriftung zeichnen. Dazu kannst Du die Anweisung g.drawString("100", X, Y); verwenden (an die Stelle (X,Y) wird eine 100 geschrieben). Wenn Du eine Variable ausgeben möchtest, dann nimm g.drawString(""+ein1, X, Y); weil keine Zahlen auf die Grafik geschrieben werden können, sondern Texte. Genauigkeit und Gestaltung sind Dir überlassen.

Aufgabe 3: Ersetze die Strecken durch Rechtecke (Säulendiagramm (links), Balkendiagramm (Mitte)).

Aufgabe 4: Zu guter Letzt soll ein Liniendiagramm entstehen (rechts).

Steuerung mit der Maus

Wir können die Grafik auch mit der Maus beeinflussen. Dazu geben wir der Zeichenfläche (dem JPanel) einen MouseListener mit, der laufend (in der Ereignisschleife nämlich (siehe 9. Woche)) die Mauskoordinaten abfragt und beim Klick reagieren kann. Im Beispielprogramm wird das Ereignis mousePressed() verwendet. Es zählt immer die Mausklicks mit. Sind es drei, dann wird aus den drei angeklickten Punkten ein beschrifteter Winkel oder ein Dreieck. Anschließend fängt die Zählung wieder bei 1 an.

Lade den Quelltext herunter (NetBeans: Lege ein Projekt Mausinteraktion an und kopiere den Quelltext Mausinteraktion.java hinein. repl.it: Lege ein neues Swing-Projekt (oder kopiere eines mit fork) und kopiere den Quelltext Main.java hinein). Probiere das Programm aus. Nach 6 Klicks sollte das Ergebnis etwa so aussehen:

Mausaufgabe 5: Ändere das Programm so ab, dass statt einem einfachen Winkel ein Fadengrafik-Winkel mit den Punkten A, S und B entsteht. Wenn Du die Buchstaben bei der Zeichnung weglässt, kannst Du sogar die Würfelaufgabe aus der letzten Woche leicht mit der Maus lösen :-). Quelltext und mausfadenwinkel.png bitte an mich. (linkes Bild)

Mausaufgabe 6: Ändere das Programm so ab, dass aus vier angeklickten Punkten A, B, C, D jeweils eine Sattelkurve wird (rechtes Bild). Quelltext und maussattel.png bitte an mich.

Knobelaufgabe: Auf dieser Seite findest Du eine Knobelaufgabe. Es kommen mehr solche Aufgaben hinzu.

[13. Woche] Anwenden, üben, knobeln

Die letzte Woche haben wir alte Aufgaben aufgearbeitet. In dieser Woche gibt es neue, die Ihr mit Euren Kenntnissen sicher wieder gut lösen werdet. Löse 2 der vier Aufgaben (freie Auswahl)

Aufgabe 1: Es heißt, dass zwischen einer gegebenen natürlichen Zahl n und ihrem Doppelten 2n (n>1) mindestens eine Primzahl existiert. Das Programm primzahldoppelt.java soll zu einer gegebenen natürlichen Zahl n die kleinste Primzahl zwischen n und 2n bestimmen, sofern sie existiert. Falls nicht, soll eine Meldung "keine Primzahl" ausgegeben werden. (ohne Grafik lösbar)

Aufgabe 2: In Woche 12 haben wir Diagramme für Zufallszahlen von 0 bis 299 gezeichnet. Diesmal soll der Bereich zunächst aus zwei natürlichen Zahlen unten und oben (unten < oben) ermittelt werden. Diese beiden Zahlen sollen mit dem Zufallsgenarator ermittelt werden und müssen selbstverständlich unterschiedlich sein. Anschließend sollen 5 Zufallszahlen im Bereich von unten bis oben ermittelt werden und in einem Diagramm Deiner Wahl (Linie, Säule, Balken) dargestellt werden. Die Achsen sollen beschriftet werden, und der Platz auf dem Fenster soll ausgenutzt werden (z. B. 600x450 wie in Woche 12, oder größer). (Grafik notwendig, ein Programm der 12. Woche kann umgebaut werden) Einzusenden ist das Programm und der Screenshot diagrammuntenoben.jpg

Mausaufgabe 3: Kaleidoskop. Beim Klicken auf einen Punkt im Fenster soll ein kleiner Kreis an dem Punkt gezeichnet werden. Durch die Mitte des Fensters - senkrecht und waagerecht - sollen Spiegelachsen verlaufen, die nicht gezeichnet werden. Nun soll sich der gezeichnete Punkt vervielfältigen - seine beiden Spiegelbilder bezüglich der Achsen sowie das Spiegelbild an der Senkrechten, das an der Waagerechten gespiegelt wird, sollen ebenfalls gezeichnet werden. Beziehe Farben mit ein. Sende das Programm und einen schönen Screenshot kaleidoskop.jpg ein.

Knobelaufgabe 4: Löse eine der Aufgaben der Knobelaufgabenseite, die du noch nicht gelöst hast.