Unterrichtseinsichten - Schuljahr 2011/2012 - Informatik-AG
Programmieren mit Java
- Wir arbeiten mit der Entwicklungsumgebung Netbeans IDE 7.0.1
Das Programm kann man zusammen mit der Java-Programmiersprache (Java
JDK 7) aus dem Internet legal und kostenlos z.B. unter folgender
Adresse herunterladen:
http://www.oracle.com/technetwork/java/javase/downloads/jdk-7-netbeans-download-432126.html
- Zunächst lernen wir die Sprache Java etwas kennen und geben
Ergebnisse nur auf dem Konsolen-Bildschirm aus.
Später benutzen wir dann Buttons, Ein- und Ausgabefelder usw.
- So starten wir Netbeans, um unsere ersten Java-Programme zu
schreiben:
Unter "Project Name" sollte man einen eigenen
aussagekräftigen Namen für das entsprechende Programm
wählen.
Automatisch wird folgender Programmrumpf erstellt:
- An dieser Stelle können nicht alle Elemente der
Programmiersprache aufgeführt werden.
Einen sehr guten Überblick in die Programmiersprache Java
erhält man
durch das Buch "Java
ist auch eine Insel", das in einer html-Ausgabe
online zu lesen ist.
- Eine Ausgabe auf den Bildschirm (unter Output) erhält man
z.B.
durch die Programmzeile
System.out.println("Das Ergebnis von 3*5 ist "+(3*5));
- Der Typ von Variablen muss festgelegt werden:
int a; // a ist eine ganze Zahl
double b, c, summe; // b, c und summe sind Deziamlzahlen
- Soll eine Eingabe über die Tastatur während des
Programmablaufs
geschehen, so fügt man folgende Zeilen im Programm ein:
Zeile 6:
import java.util.Scanner;
Zeile 17 (zwischen den beiden geschweiften Klammern von public static
void main...):
Scanner sc;
sc=new Scanner(System.in);
Eine Eingabe für die Variable a erfolgt dann z.B. so:
a=sc.nextInt();
- Eine Schleife, die solange durchlaufen wird, wie eine gegebene
Bedingung erfüllt ist, sieht so aus:
while (hier steht eine
Bedingung)
{
hier steht eine
oder stehen mehrere Anweisungen
}
- Soll das Programm entsprechend einer Bedingung entweder den einen
oder anderen Programmschritt ausführen, geschieht das durch die
if-else-Anweisung:
if (hier steht eine
Bedingung)
{
hier steht eine oder
stehen mehrere Anweisungen, die ausgeführt werden sollen, wenn die
Bedingung erfüllt ist
}
else
{
hier steht eine oder
stehen mehrere Anweisungen, die ausgeführt werden sollen, wenn die
Bedingung nicht erfüllt
ist
}
- a % b berechnet den Rest, der bleibt, wenn man die ganze Zahl a
durch die ganze Zahl b dividiert.
Man kann z.B. untersuchen, ob die Zahl a gerade ist, indem man a durch
2 teilt und nachschaut, ob dabei der Rest 0 ergibt: a % 2
== 0
- Berechnung der Ulam-Folge mit beliebigem Startwert
Ist eine Zahl gerade, so berechnet sich die nächste Zahl der Folge
durch "Zahl/2".
Ist eine Zahl ungerade, so berechnet sich die nächste Zahl der
Folge
durch "3*Zahl+1"
- Soll ein Programmteil wiederholt werden und weiß man, wie
oft das
geschehen soll, kann man gut die for-Schleife benutzen:
for ( hier wird eine
Variable definiert und ein Startwert zugewiesen ; hier steht, wie lange die Schleife
wiederholt wird ; hier steht,
wie die Variable jedesmal geändert wird )
{
hier stehen die
Anweisungen, die immer wiederholt werden
}
Beispiel: Die Zahlen von 7 bis 23 sollen untereinander ausgegeben werden
for ( int i=7 ; i<=23 ; i=i+1 )
{
System.out.println(i);
}
- Beispielprogramm 1 für die for-Schleife:
- Beispielprogramm 2 für die for-Schleife:
Erstellen eines Programms
mit grafischer Oberfläche (GUI)
- Starten des Programms zunächst wie schon bekannt:
Nun wird es etwas anders (grüne Markierungen):
Projektname wählen (beliebig) und Haken bei "Create Main Class"
wegnehmen!
eigenes Package anlegen (der Name ist beliebig):
ein JFrame anlegen:
nun erscheint rechts folgender Inhalt:
Mit "Source" und "Design" schaltet man zwischen der gestalteten
Oberfläche und dem Programmtext um.
"Swing Containers", "Swing Controls" und "Swing Menues" enthalten
Bauteile für die Oberfläche.
Rechtsklick auf die Bauteile erlaubt Änderung der Eigenschaften
wie Name, Beschriftung usw.
Die Eigenschaften können auch bei "Properties" eingestellt werden.
- Beispiel für ein Programm mit grafischer Oberfläche:
Taschenrechner
- Design
- Quelltext (ohne die Verknüpfungen "+", "-" und ":" , die
aber mit Kopieren und Einfügen und dem Ersetzen des
jeweiligen Rechenoperators leicht hergestellt werden können)
- Programmfenster während des Laufs
- Einfügen von Grafik in die grafische Oberfläche:
- Man kann grundsätzlich auf allen Komponenten der
grafischen Oberfläche zeichnen.
Es bietet sich z.B. besonders die Komponente jPanel an.
- Folgende Einträge sind im Sourcecode notwendig:
- Unter "package ..." wird eingetragen import java.awt.*;
- Im Programmblock, in dem Zeichenfunktionen ausgeführt
werden sollen, steht z.B.
Graphics gr;
gr=jPanel1.getGraphics();
Statt gr kann auch ein anderer Bezeichner gewählt werden.
Statt jPanel1 wird die gewünschte Komponente eingesetzt.
- Im weiteren Programm wird dann der Bezeichner gr verwendet,
um Zeichenfunktionen oder -einstellungen auszuführen:
gr.setColor(Color.yellow); stellt die Zeichenfarbe auf
"gelb" ein.
gr.drawLine(15,160,45,280); zeichnet eine Strecke vom
Punkt (15/160)
zum Punkt (45/280).
gr.drawRect(15,160,45,280); zeichnet eine Rechteck,
dessen Eckpunkt links oben bei (15/160)
und dessen Eckpunkt rechts unten bei (45/280) liegt.
gr.fillRect(15,160,45,280); zeichnet dasselbe
Rechteck, nur
ausgefüllt mit derr aktuellen Farbe.
- Der folgende Programmteil zeichnet einen Farbverlauf von
grün
nach rot:
for (int i=0;i<255;i++)
{
gr.setColor(new
Color(i,255-i,0));
gr.drawLine(i,0,i, jPanel1.getHeight());
}
2011-11-04
- In dieser Stunde haben Steffen und Elia ihre Projekte
"Tic-Tac-Toe"
und "Schreibmaschinentastatur" vorgestellt.
- Wir haben uns dann weiter beschäftigt mit den Themen
"for-Schleife", "Grafik" und "Zufallszahlen".
Das Programm hieß "Regentropfen, hätte aber zum Schlus auch
"Konfetti" benannt werden können:
- Hier der von uns erstellte Programmcode:
private void jBEndeActionPerformed(java.awt.event.ActionEvent
evt)
{
System.exit(0);
}
private void jBStartActionPerformed(java.awt.event.ActionEvent
evt)
{
Graphics g;
g=jPanel1.getGraphics();
for (int i=0; i<1000; i=i+1)
{
g.setColor(new
Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256)));
g.fillRect((int) (Math.random()*jPanel1.getWidth()), (int)
(Math.random()*jPanel1.getHeight()) , 3, 3);
}
}
- Einige Erläuterungen:
- zu "Color" gehören 3 Argumente (=Zahlen in der Klammer,
durch Kommata getrennt).
Die Zahlen geben den Rot-, Grün- und Blauanteil der
gewünschten Farbe an.
0 bedeutet: dieser Farbanteil ist gar nicht enthalten, 255 bedeutet:
dieser Farbanteil ist voll enthalten.
Die Farbe wird dann aus den 3 Farbanteilen gemischt.
- "Math.random()" erzeugt eine Zufallszahl zwischen 0 und 1.
Bei "Color" bildet man mit dem Faktor 256 dadurch Zufallszahlen im
Bereich zwischen 0 und 256.
(int) wandelt diese Zufaalszahl in eine integer-Zahl (also eine ganze
Zahl) um, indem die Nachkommastellen abgeschnitten werden. Aus (int)
24.7235 wird dadurch 24.
- Da man die Breite und Höhe der Zeichenfläche
(vielleicht) nicht kennt, ruft man die Breite mit jPanel1.getWidth()
und die Höhe mit jPanel1.getHeight() auf.
- Das ganze Programm könnt hier
hier herunterladen.
2011-11-11
- Als Vorbereitung auf ein Programm, in dem man mit Hilfe von
Tastaturbefehlen Bilder verschieben kann, haben wird das Programm
"Taste"
geschrieben, das zu einer gedrückten Taste das Zeichen und den
Code angibt:
Hier die wichtigsten Programmzeilen:
private void jBStartActionPerformed(java.awt.event.ActionEvent
evt)
{
// hiermit erhält der Start-Button den Fokus
}
private void jBStartKeyPressed(java.awt.event.KeyEvent evt)
{
jTFZeichen.setText(""+evt.getKeyChar());
jTFCode.setText(""+evt.getKeyCode());
}
- Mit dem Programm "Verschiebung" sind wir noch nicht fertig
geworden.
Hier die bis jetzt erstellten Programmzeilen:
private void jBStartKeyPressed(java.awt.event.KeyEvent evt) {
Graphics gr;
gr=jPanel1.getGraphics();
int dx=0;
int dy=0;
int taste;
taste=evt.getKeyCode();
if (taste == 37) // nach
links
{
dx=-10;
dy=0;
}
x=x+dx;
y=y+dy;
gr.drawOval(x, y, d, d);
}
/**
* @param args the command line arguments
*/
int x=100;
int y=100;
int d=5;
...
2011-11-18
- Verbesserung des Programms "Taste"
Layout:
Wichtige Programmzeilen:
- Programm "Verschiebung"
Ein "Ball" soll auf der Zeichenfläche durch Drücken der
Cursor-Tasten gesteuert werden.
Zum Speichern der Werte für den Ball haben wir die "class Ball"
eingerichtet und dabei zum ersten Mal eine selbstgeschriebene Klasse
erzeugt:
Das Programm:
Layout:
Programmtext:
2011-11-25
- Das Programm der letzten Stunde haben wir auf 2 Weisen
"verbessert":
- Statt endloser else-if-Abfragen kann man übersichtlicher
die switch-Anweisung benutzen.
Hinter dem letzten case kann noch ein default:... angehängt
werden, dessen Anweisungen dann ausgeführt werden, wenn keine
Übereinstimmung gefunden wurde.
- In die class Ball haben wir auch die Befehle zum Zeichnen
eingebunden.
In der Methode des Hauptprogramms werden dann folgende Zeilen
eingefügt
- Das Programm haben wir dann so abgewandelt, dass das Springen
eines Balls simuliert wird.
Es ergibt sich folgendes Bild:
Der zugehörige Programmtext:
Die Anfangswerte sind folgendermaßen abgelegt:
2011-12-02
- Folgende neue Sprachelemente haben wir kennengelernt:
- array (oder Feld)
Während wir mit einer Variable "Zahl"
nur einen einzelnen Speicherplatz benennen können und also auch
nur einen Wert speichern können,
können wir mit dem array "Zahl[2]" mehrere Speicherplätze
unter demselben Namen erreichen.
Die Unterscheidung gelingt durch den in eckigen Klammern stehenden
Index.
Beispiel:
int[] Zahl=new int[6];
Hier
wird festgelegt, dass mit dem Namen "Zahl" 6 Speicherplätze zu
erreichen sind: Zahl[0], Zahl[1], Zahl[2], Zahl[3], Zahl[4], Zahl[5].
Die Nummerierung geht immer von 0 bis zur angegebenen Zahl minus 1.
Zugreifen kann man so auf die einzelnen Werte des arrays:
Zahl[4]=5;
Zahl[2]=8-Zahl[4];
Zahl[1]=Zahl[2]*Zahl[4];
Im Speicherplatz Zahl[1] steht dann der Wert 3*5=15.
In
2-dimensionalen arrays kann man die Werte aus eine Tabelle ansprechen,
die sich in 2 Richtungen erstreckt (x- und y-Richtung).
Definition eines 2-dimensionalen arrays:
int[][] Zahl=new int[6][7];
Zugriff auf das Element an der Stelle (x/y) mit x=2 und y=4:
Zahl[2][4]=7;
- Will man Werte definieren, deren Wert sich während des
Programmablaufs nicht ändern soll, so setzt man das Wort "final"
voran:
final int a=14;
final Color c=Color.red;
- Projekt "GFSKasten"
Wir erstellen ein Spiel, bei dem man Kisten auf vorgegebene
Zielplätze schieben muss.
Bedingungen:
- Für den Spieler (gelb) sind nur freie Plätze (grau)
und die Zielplätze (grün) zugänglich.
- Kästen (blau) können nur auf freie Plätze oder
Zielfelder geschoben werden.
- Der Spieler kann nur einen einzigen Kasten zur selben Zeit
verschieben.
- Mauern (rot) sind nicht zugänglich.
- Erstellen des Spielfeldes und Setzen der Spielfiguren
Spielfeld:
Vorläufiger Programmcode dazu (nur die selbst erstellten
Programmzeilen):
2011-12-09
- Das Programm GFSKasten läuft jetzt.
Es fehlen nur noch die Level...
Hier das Programm zum Herunterladen.
2011-12-16
- Den Quellcode des Programms GFSKasten könnt ihr hier finden.
Ihr könnt ja mal noch ein paar Level dazuerfinden.
2012-01-06
- Zum Programm GFSKasten haben wir begonnen, einen Leveleditor zu
schreiben.
Hier die beiden Programme GFSKasten und Leveleditor auf dem Stand vom 2012-01-06
als zip-file.
2012-01-13
- Um die Level abzuspeichern, haben wir eine Möglichkeit
kennengelernt, Daten in Dateien abzuspeichern.
Hier eine Beispieldatei, die zeigt,
wie man Dateien anlegen und füllen, Dateien auslesen und Dateien
löschen kann.
2012-02-03
- Beim Erstellen eines Applets kann man fast so vorgehen wie beim
Erstellen eines Java-jar-Programms.
Hier das Applet zum Spiel Game of
life.
- Und damit Ihr seht, wie ein Applet dann in eine Website
eingebunden wird, hier das Applet in Aktion:
Die Steine können mit Mausklick gesetzt und wieder entfernt werden.
Start startet ein neues Spiel mit leerer Spielfläche.
Im Textfenster wird die laufende Nummer der aktuellen Generation angezeigt.
Mit ALT + s bzw. ALT + g werden die mit den Schaltflächen verbundenen Ereignisse mit Hilfe der Tastatur ausgelöst.
2012-02-17
- Hier die beiden Programme aus dem Unterricht zum Herunterladen:
2012-02-24
- Einbinden von Bildern in das Programm:
- import java.awt.*; // unter package ...
- Image img=getToolkit().getImage("meinbild.png"); // "meinbild.png" ist der Name der Bilddatei
gr.drawImage(img,10,20,null); // 10 und 20 stehen für die x- und die y-Koordinate der oberen linken Bildecke
- Das Programm (gegenüber dem Unterricht leicht verändert) zum Zeichnen der schönen Kurve (download)