Wenn jemand Rechtschreib- oder Grammatikfehler

!!!ACHTUNG!!! Wenn jemand Rechtschreib- oder Grammatikfehler findet, kann er sie behalten.
Ich habe diesen Text nicht Korrektur gelesen.
Deshalb bitte: Inhaltliche Fehler MELDEN!!!
Ansonsten VIEL SPAß!
Nicholas Ohs (GK 11 IF 2)
Sooo,
da der Felix uns letztens gezeigt hat, dass Swing mehr zu bieten hat als vielleicht mancher gedacht hat,
habe ich mir überlegt, etwas Grundsätzliches über Swing und Java zu schreiben. Allerdings bin ich mir
selbst nicht über jedes Detail klar, sodass jeder, der Interesse hat, durchaus das Java Handbuch oder
die Java Docs als detailliertere Hilfe in Anspruch nehmen sollte.
Na dann. So viel vorab.
Fangen wir am besten ganz am Anfang an.
Kapitel 1: Basis
Damit wir die vorgefertigten Objekte nutzen können wie Labels, Buttons etc., müssen wir zunächst
noch ein paar "packages" (siehe JavaDocs) importieren.
Das geht wie folgt:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
Diese drei Zeilen werden an den Anfang einer Datei geschrieben (wenn man ein Swing-Gui erzeugen
möchte).
das Wort import versteht sich von selbst.
java bzw. javax sind die Oberklassen, aus denen importiert wird. Da wir nicht die abstrakten Objekte
von java bzw. javax sondern awt bzw. swing Objekte
verwenden wollen verfeinern wir unsere Angaben. Dies tun wir, indem wir hinter einen Punkt eine
Unterklasse schreiben.
In diesem Beispiel wären das awt bzw. swing.
Ist das erledigt, können wir mit unserem eigentlichen Gui anfangen.
public class FensterTest extends JFrame
{
...
}
Das ist der Klassen-Rumpf.
Public: mindestens eine Klasse in einer Datei muss public sein, damit von außen auf sie zugegriffen
werden kann.
class: deutet an, dass hier eine neue Klasse definiert wird
FensterTest: Der Name, den ich für die Klasse gewählt habe
extends JFrame: Die Klasse ist also abgeleitet aus der vorhandenen Klasse JFrame, die Sun zur
Verfügung stellt.
{...}: In diese Klammern kommen später alle Methoden und Attribute rein.
Jetzt da der Rumpf steht können wir damit Beginnen, Labels und ähnliches einzufügen.
Wichtig an dieser Stelle ist, dass die Objekte zunächst nur erzeugt werden. Im Konstruktor unserer
Klasse bekommen sie dann Werte wie Größe und Farbe zugewiesen.
Fangen wir mit einem Label als Überschrift an.
das Label ist Teil unseres Guis und sollte im Sinne der Objektorientiertheit nicht von außen einfach so
verändert werden können ohne die entsprechende Methode. Um unser Label also zu schützen setzen
wir es auf private
1. private
Label existiert wie gesagt schon als Klasse. Wir müssen es also nicht neu definieren. Die Klasse, derer
wir uns bedienen heißt: JLabel. Unser neues Objekt, das wir erzeugen werden, wird also vom Typ
JLabel sein.
2. JLabel
Als Namen wählen wir: lb_Header
3. lb_Header
So ergibt sich für unseren Java Code um ein Label zu erzeugen:
ein private Objekt vom Typ JLabel soll mit dem Namen lb_Header als neues jLabel erzeugt werden.
zu Java:
private JLabel lb_Header = new JLabel();
JLabel() ist der Konstruktor von jLabel durch den ein neues Label erzeugt wird. Der Konstruktor kann
stets gefunden werden, wenn der Cursor auf dem Objekt Typ (hier jLabel) ist und man F1 drückt.
Nun wollen wir ein Textarea erzeugen.
Ein Textarea besteht bei einem Swing Fenster stets aus 2 Komponenten!!
Zum einen Das Textarea an sich, in dem der später angezeigte Text als String angezeigt wird. Zum
anderen ein sogenanntes JScrollPane.
Der Unterschied zum AWT Textarea ist der, dass die Aufgabe der Scrollbalken bei Swing i.d.R. auf
das JScrollPane verlagert wird. Eine Grafik, wie man sich das mit dem JScollPane vorzustellen hat,
steht im JavaDoc: Einfach im Java-Quelltext JScrollPane eintippen, Cursor darauf platzieren und F1
(für Hilfeanzeige) drücken!
Ich will allerdings an dieser Stelle nicht genauer darauf eingehen, da die Grafik schon recht viel über
das JScrollPane zeigt.
Nun aber zur Implementation:
Folgendes sollte nach der oberen Zeile klar sein:
private JTextArea ta_Ausgabe = new JTextArea(); <--erzeugt ein neues TextArea
private JScrollPane jSp1_ta_Ausgabe = new JScrollPane(); <-- erzeugt ein neues JScrollPane
Wie wir diese beiden Objekte nachher zusammen fügen, werde ich später noch erläutern. Zunächst
haben wir sie erst einmal erzeugt.
Zum Schluss erzeugen wir noch einen Button, damit wir auch etwas machen können in unserem Gui.
private JButton bt_Start = new JButton(); <-- erzeugt einen neuen Button
jetzt haben wir erst mal unsere Objekte erzeugt.
Unsere Datei sollte demnach wie folgt aussehen:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class FensterTest1 extends JFrame
{
private JLabel lb_Header = new JLabel();
private JTextArea ta_Ausgabe = new JTextArea();
private JScrollPane jSp1_ta_Ausgabe = new JScrollPane();
private JButton bt_Start= new JButton();
}
Als nächstes werden wir uns ein wenig mit dem Konstruktor unserer Klasse befassen.
public FensterTest(String title) {}
ein Konstruktor wir GENAU so wie die Klasse benannt. Zusätzlich wird noch festgelegt, dass wenn
der Konstruktor aufgerufen wird ein String übergeben werden muss.
title ist eine Variable in die der übergebene String zwischengespeichert wird. Diese kann man
natürlich nach belieben umbenennen aber title trifft es eigentlich ganz gut wie sich später herausstellen
wird.
Im Konstruktor passiert folgendes:
super(title);
Wie am Anfang erwähnt ist unsere Klasse abgeleitet von JFrame. D.h. wir können mit dem Befehl
super den Konstruktor der Oberklasse (also von JFrame) aufrufen und uns somit ersparen selbst ein
Fenster basteln zu müssen.
Der Konstruktor von JFrame verlangt einen String. Dieser String wird nachher in die Windowsleiste
eingetragen und ist für den Benutzer sichtbar. Wir übergeben hier an der Stelle einfach die String
variable title, die wir vom FensterTest Konstruktor schon kennen.
Was wird also passieren. Wenn später der Konstruktor aufgerufen wird, wird der eingegebene String
an die Methode super übergeben, die ein Fenster mit dem übergebenen String als Überschrift erzeugt.
Als nächstes müssen wir dafür sorgen, dass unser Programm beim Klicken auf das "X" im Fenster
auch beendet wird.
Dafür dient folgender Code:
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) { System.exit(0); }
});
Hierzu nur soviel:
der WindowListener "lauscht" die ganze Zeit, ob das X gedrückt wird. Ist dies der Fall, wird
System.exit(0); ausgeführt. Ein Befehl, der das komplette Programm schließt (nicht nur das Fenster
entfernt).
Nachdem jetzt unser Fenster soweit erzeugt wurde, müssen wir es Skalieren und Platzieren.
setSize(300, 300); <-- Die Größe wird mit Hilfe der Methode setSize festgelegt (Breite, Höhe)
Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); <-- Die Größe des Bildschirmes (die
Auflösung) wird ausgelesen und in eine Dimension Variable d eingespeichert. Der Vorteil einer
Dimension Variable ist, dass sie Breite und Höhe in einer Variable vereint.
int x = (d.width - getSize().width) / 2; <--hier werden neue int-Variablen erzeugt, die dafür sorgen,
dass das Fenster in der Mitte positioniert wird
int y = (d.height - getSize().height) / 2 ;
setLocation(x, y); <-- Das Fenster wird positioniert. die übergebenen int-Variablen der oberen
Zeilen geben die Position der sich links oben befindenden Ecke.
Container cp = getContentPane();
<-- Hierüber haben wir mit Herrn Ziemke
ausführlich gesprochen.
cp.setLayout(null); <--Hier wird das Standard layout unserer Objekte wie Buttons etc. festgehalten
als weitere Info zu Containern (aus den JavaDocs):
Components added to a container are tracked in a list. The order of the list will define the components'
front-to-back stacking order within the container. If no index is specified when adding a component to
a container, it will be added to the end of the list (and hence to the bottom of the stacking order).
Jetzt endlich können wir Anfangen unsere Objekte zu bearbeiten.
//Label
lb_Header.setBounds(64, 80, 44, 16); <-- setBounds setzt die Größe unseres Labels. (x-Position der
LO Ecke, y-Position der LO Ecke, Breite, Höhe) Die Position ist immer in Relation zum Fenster!
lb_Header.setText("Hier steht die Überschrift");
lb_Header.setFont(new Font("MS Sans Serif", Font.PLAIN, 13)); <-- Hier wird Schriftart und
ähnliches festgelegt.//Wichtig! Die Schriftgröße darf die Höhe des Labels nicht überschreiten, sonst ist
die Schrift z. T. abgeschnitten.
cp.add(lb_Header); <-- hier wird das ganze noch zu unserem Container hinzugefügt.
//TextArea
jSp1_ta_Ausgabe.setBounds(20, 20, 100, 50); <-- set Bounds setzt die Größe unseres ScrollPanels.
ta_Ausgabe.setText("Das ist der Text der im TextArea nachher beim Start angezeigt wird");
jSp1_ta_Ausgabe.setViewportView(ta_Ausgabe); <-- siehe Grafik
cp.add(jSp1_ta_Ausgabe); <-- hier wird das ganze noch zu unserem Container hinzugefügt.
Unser TextArea ist somit erfolgreich platziert.
//Button
bt_Start.setBounds(104, 240, 97, 25); <-- set Bounds setzt die Größe unseres ScrollPanels.
bt_Start.setText("Was drauf steht");
cp.add(bt_Start); <-- hier wird das ganze noch zu unserem Container hinzugefügt.
bt_Start.addActionListener(new ActionListener() { Den Listener kennen wir schon von unserem
Fenster. Er überwacht die Aktionen unseres Buttons. Wird der Button gedrückt, wird die Methode
bt_StartActionPerformed(evt) aufgerufen, die wir später noch schreiben werden.
public void actionPerformed(ActionEvent evt) {
bt_StartActionPerformed(evt);
}
});
setResizable(false);
setVisible(true);
Diese selbsterklärenden Begriffe müssen noch angefügt werden.
Damit wäre unser Konstruktor aufs Erste fertig.
So sieht er aus:
public FensterTest(String title)
{
//Alles rund ums Fenster
super(title);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) { System.exit(0); }
});
setSize(300, 300);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
int x = (d.width - getSize().width) / 2;
int y = (d.height - getSize().height) / 2 ;
setLocation(x, y);
Container cp = getContentPane();
cp.setLayout(null);
///////////////////////////////
//Alles rund um die Komponenten
//Label
lb_Header.setBounds(64, 80, 44, 16); <-- set Bounds setzt die Größe unseres Labels. (x-Position
der LO Ecke, y-Position der LO Ecke, Breite, Höhe) Die Position ist immer in Relation zum Fenster!
lb_Header.setText("Hier steht die Überschrift");
lb_Header.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
cp.add(lb_Header);
//TextArea
jSp1_ta_Ausgabe.setBounds(20, 20, 100, 50);
ta_Ausgabe.setText("Das ist der Text der im TextArea nachher beim Start angezeigt wird");
jSp1_ta_Ausgabe.setViewportView(ta_Ausgabe);
cp.add(jSp1_ta_Ausgabe);
//Button
bt_Start.setBounds(104, 240, 97, 25);
bt_Start.setText("Was drauf steht");
cp.add(bt_Start);
bt_Start.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
bt_StartActionPerformed(evt);
}
});
setResizable(false);
setVisible(true);
}
Jetzt gilt es als nächstes unseren Button zum Laufen zu bekommen.
Dafür brauchen wir eine bt_StartActionPerformed(evt) Methode, die sagt, was passieren soll, wenn er
gedrückt wird.
public void jButton1ActionPerformed(ActionEvent evt) {}
Methoden sind i. d. R. public. Was Action Event evt in der Klammer genau zu bedeuten hat kann ich
zum jetzigen Zeitpunkt nicht 100%ig sagen, werde mich aber ggf. melden falls ich es herausgefunden
habe.
Dieser Methode fügen wir jetzt noch etwas hinzu, damit wir sehen ob unser Button funktioniert.
Wir werden zunächst nur einen Text in das TextArea schreiben lassen.
um von unserem ta_Ausgabe den Text zu ändern müssen wir die Methode setText() dieses Objektes
aufrufen.
dies tun wir wie folgt: ta_Ausgabe.setText("Hurra der Button funktioniert!!");
unsere Button Methode sieht also wie folgt aus:
public void jButton1ActionPerformed(ActionEvent evt)
{
ta_Ausgabe.setText("Hurra der Button funktioniert!!");
}
Noch ein Schritt fehlt zum ersten fertigen eigenhändig erstellten Swing Gui.
Wenn Java ein Gui ausführt, sucht es nicht nach dem Konstruktor dieser Klasse sondern nach einer
"Main" Methode. Diese kennen wir schon von Con Klassen.
In dieser Main Methode wird dann der Konstruktor der Klasse aufgerufen.
public static void main(String[] args) {
new FensterTest("Titel-leisten Titel");
}
Dieser main Methode wird eine String-array variable mit dem Namen args übergeben. Wofür das gut
ist weiß ich nicht, da ich nicht weiß was Java da übergibt.
Wichtig in dieser Zeile ist das void, da die Methode keinen Wert zurück gibt und kein Konstruktor ist.
Das Entscheidende ist der Konstruktor-Aufruf in der Main Methode.
Wenn wir alles zusammenflicken sieht unsere Datei so aus:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class FensterTest extends JFrame
{
//Attribute
private JLabel lb_Header = new JLabel();
private JTextArea ta_Ausgabe = new JTextArea();
private JScrollPane jSp1_ta_Ausgabe = new JScrollPane();
private JButton bt_Start = new JButton();
//Konstruktor
public FensterTest(String title)
{
//Alles rund ums Fenster
super(title);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) { System.exit(0); }
});
setSize(300, 300);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
int x = (d.width - getSize().width) / 2;
int y = (d.height - getSize().height) / 2 ;
setLocation(x, y);
Container cp = getContentPane();
cp.setLayout(null);
///////////////////////////////
//Alles rund um die Komponenten
//Label
lb_Header.setBounds(50, 10, 200, 16);
lb_Header.setText("Hier steht die Überschrift");
lb_Header.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
cp.add(lb_Header);
//TextArea
jSp1_ta_Ausgabe.setBounds(50, 50, 200, 150);
ta_Ausgabe.setText("Das ist der Text, \nder im TextArea nachher \nbeim Start angezeigt wird.");
jSp1_ta_Ausgabe.setViewportView(ta_Ausgabe);
cp.add(jSp1_ta_Ausgabe);
//Button
bt_Start.setBounds(80, 220, 140, 25);
bt_Start.setText("Was drauf steht");
cp.add(bt_Start);
bt_Start.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
bt_StartActionPerformed(evt);
}
});
setResizable(false);
setVisible(true);
}
//Methoden
public void bt_StartActionPerformed(ActionEvent evt)
{
ta_Ausgabe.setText("Hurra der Button funktioniert!!");
}
public static void main(String[] args) {
new FensterTest("Titel-leisten Titel");
}
}
Die dazugehörige Java Datei befindet sich im Anhang und heißt FensterTest1.java
Zum Thema Java Datei: Die Java Datei muss wie die public Klasse heißen!!!
Diese Datei ist ohne das Drag and Drop Menu vom JavaEditor erstellt worden (sieht also für manchen
nicht so toll aus).
Kapitel 2: Einfache Verarbeitung
Jetzt gibt es sicher den ein oder anderen, der es etwas stupide findet auf einen Button zu drücken um
"Hurra der Button funktioniert!!" angezeigt zu bekommen.
Deshalb wollen wir jetzt ein paar neue Objekte einbauen und eine Eingabe verarbeiten.
Der Plan sieht aus wie folgt:
Wir verwenden unsere alte Datei FensterTest. Wir bauen ein Popup Fenster und ein TextFeld ein.
Außerdem implementieren wir einen weiteren Button.
Was wir erreichen wollen, sind Eingabe-Abfragen und ein paar Spielereien mit der Optik.
Erst einmal ersetze ich die verwendeten Strings durch sinnvolle Texte. ^^
lb_Header.setText ändere den String in "Eingabe Test"
ta_Ausgabe.setText ändere den String in "Status:\n"
bt_Start.setText ändere den String in "Schritt 1"
new FensterTest ändere den String in "Eingabe verarbeiten"
Dies sind natürlich nur Beispiele, aber sie passen denke ich recht gut.
Zudem entferne ich die Methode ta_Ausgabe.setText("Hurra der Button funktioniert!!"); aus der
ActionPerformedMethode meines Buttons.
Jetzt die Implementation der einzelnen Objekte:
das Textfeld platziere ich unter das TextArea. D. h., dass der Button erst einmal ein wenig nach unten
wandern muss. ich erhöhe also den zweiten Wert bei der setBounds Methode des Buttons in unserem
alten Projekt um 20.
Jetzt habe ich genug Platz um ein TextFeld zwischen TextArea und Button zu platzieren.
Als erstes muss ich das TextFeld erzeugen. Dafür erstelle ich eine neue Leerzeile unter private
JButton bt_Start = new JButton(); (bei mir in Zeile 12). Dort erzeuge ich jetzt ein neues TextFeld mit
dem Namen tf_Eingabe.
private JTextField tf_Eingabe = new JTextField();
jetzt muss ich Position und Größe bestimmen und es dann zu cp hinzufügen (im Konstruktor
natürlich).
//TextFeld
tf_Eingabe.setBounds(50, 210, 200, 18);
tf_Eingabe.setText("(Bitte tata eingeben)");
tf_Eingabe.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
cp.add(tf_Eingabe);
Für unser Popup Fenster müssen wir so gut wir gar nichts tun. Popupfenster sind fertig strukturiert, mit
Buttons ausgestattet und allem was man braucht.
Das einzige, was wir tun müssen, ist zu unseren Methoden eine weitere hinzufügen.
public int abfrage() {
return JOptionPane.showConfirmDialog(this, "Möchten sie das große Geheimnis lüften?", "Frage!",
JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE );
}
was hier passiert: es wird die Methode showConfirmDialog der Klasse JOptionPane ausgeführt. Diese
gibt am Ende einen int-Wert aus, der returned wird. D. h., bei ja wird eine 0 zurück gegeben, bei nein
eine 1 und bei abbrechen eine 2.
Daher MUSS die Methode public int abfrage() heißen, da sie einen int zurück gibt.
wofür sind die einzelnen Teile in der Klammer: mit diesen übergebenen Strings etc. kann man das
Option Panel gestalten. Fangen wir hinten an:
JOptionPane.QUESTION_MESSAGE bedeutet, dass ein Fenster aufpopped mit einem
Fragezeichensysbol.
JOptionPane.YES_NO_CANCEL_OPTION bedeutet, dass diese Optionen zur Verfügung stehen.
"Frage!" repräsentiert in diesem Fall den Titel des Fensters.
"Möchten sie das große Geheimnis lüften?" repräsentiert den gezeigten Text.
das this musste ich noch nie modifizieren. Ich hoffe einfach, dass das auch in Zukunft so bleibt ^^' .
Diese Methode werden wir später brauchen.
Als letztes noch einen Button hinzufügen. Hierauf werde ich nicht speziell eingehen, da wir schon mal
einen Button erzeugt haben. Nur so viel: der Button heißt in meinem Code immer: bt_Fortfahren
gelabled habe ich ihn mit Schritt 2. Und hier noch meine Bounds:
Button 1: (20, 240, 120, 25) Button 2: (160, 240, 120, 25)
Was jetzt passieren soll. Zunächst soll der Benutzer ins tf tata eingeben. Dann soll er bt_Start drücken.
die Eingabe soll überprüft werden. Ist sie richtig, so soll der Benutzer sehen, dass er Button 2 drücken
muss. Dann wird das Popupfenster aufgerufen und gefragt Möchten sie ... siehe oben. Wenn ja
gedrückt wird, soll ein Text ins TA eingetragen werden und bt2 soll deaktiviert werden. Wenn nein
gedrückt wird, soll das Fenster resettet werden. Wenn abbrechen gedrückt wird, soll nichts passieren.
Wie geht man vor. Zunächst einmal ist es wichtig, dass man Button 2 nicht am Anfang drücken kann.
Deshalb fügen wir bei unserem Button 2 im Konstruktor ein:
bt_Fortfahren.setEnabled(false); <-- ist selbsterklärend ansonsten: http://www.leo.org
sinnvoll ist es auch, wenn man das TA uneditierbar macht:
ta_Ausgabe.setEditable(false);
Jetzt gehen wir in die ActionMethode von Button 1
Dort soll jetzt die Eingabe überprüft werden (natürlich mit einer if Abfrage)
Wenn der vom Tf genommen Text "tata" ist, soll folgendes passieren
bt2 wird aktiv, bt1 wird inaktiv, tf wird inaktiv im Ta steht zusätzlich "Sie können jetzt auf Fortfahren
klicken"
Sonst schreibe ins TA "Falsche Eingabe" und setze das TF auf "(Bitte tata eingeben)" .
zu Java:
if (tf_Eingabe.getText().equals("tata"))
<--- equals um auf Gleichheit der Inhalte zu prüfen
{
bt_Fortfahren.setEnabled(true);
<--- siehe oben
bt_Start.setEnabled(false);
tf_Eingabe.setEnabled(false);
ta_Ausgabe.append("Sie können jetzt auf Fortfahren klicken\n"); <---append hängt an anders als
setText()
}
else
<--- sonst
{
ta_Ausgabe.append("Falsche Eingabe\n");
tf_Eingabe.setText("(Bitte tata eingeben)");
}
das war es auch schon für den ersten Button
Als Nächstes müssen wir noch sagen, was passieren soll, wenn bt2 gedrückt wird.
Auch hier wieder eine if Abfrage:
Falls der vom Popup Fenster wiedergegebene Wert 0 ist (ja)
deaktiviere bt2, ta anfügen "Du hast soeben die geheime Botschaft anzeigen lassen."
falls der vom Popup Fenster wiedergegebene Wert 1 ist (nein)
tf "(Bitte tata eingeben)", tf aktiv, bt1 aktiv, bt2, deakt, ta "Status:\n"
in Java:
int i1 = abfrage();
if(i1 == 0 )
{
bt_Fortfahren.setEnabled(false);
ta_Ausgabe.append("Du hast soeben die geheime Botschaft anzeigen lassen.");
}
if(i1 == 1)
{
tf_Eingabe.setText("(Bitte tata eingeben)");
tf_Eingabe.setEditable(true);
bt_Start.setEnabled(true);
bt_Fortfahren.setEnabled(false);
ta_Ausgabe.setText("Status:\n");
}
Was haben wir jetzt erreicht:
Wir können jetzt TextAreas Buttons Popups TextFelder Lables und Guis erstellen.
Außerdem können wir Eingaben per IF abfrage auswerten und das Programm entsprechend reagieren
lassen.
Im Anhang gibt es das Projekt als FensterTest2.java
Als nächstes solltest du vielleicht versuchen den Primzahl-Algorithmus erneut in Java zu
implementieren um die While Schleife noch zu erarbeiten.
Das Gerüst sieht wie folgt aus:
while (int variable * Wert oder Variable)
{
Methoden;
...
variable++;
}
* einsetzten < oder > oder <= oder >=
Kapitel 3:
Jetzt geht es um das Thema Dateien.
Für dieses Thema nehmen wir wieder unser erstes Projekt als Grundgerüst. Wieder mal "leeren" wir
die actionPerformed Methode. Siehe notfalls Kapitel 2.
Die Benennung kannst du selbst wählen.
Jetzt müssen wir noch java.io.*; importieren. Wie das geht sollte bekannt sein.
Benutze zusätzlich den Rumpf von Herr Ziemke (Attribute und Methoden). !Wichtig! Da wir nicht mit
Con sondern mit Gui arbeiten müssen die static Einträge weg!
Folgendes sollte dein Programm können: Eine Datei erzeugen incl. Inhalt. Eine Datei auslesen. Wörter
oder Buchstaben aus dem Text ersetzten. und ausgelesene bzw. geänderte Texte in einem ta anzeigen
können. (Sprich Herr Ziemkes Aufgaben aus den letzten Stunden.
Nur falls du nicht selbst zurecht kommst, solltest du einen Blick auf das Projekt DateiTest1.java im
Anhang werfen. Es sind einige neue Funktionen drin, die ich nicht erklären werde, weil sie eigentlich,
wenn du die ersten beiden Kapitel verstanden hast, so weit verstanden werden können, dass sie
verwendet werden können!!!! Außerdem sollten die JavaDocs auch benutzt werden. Bei Detailfragen
steht der Verteiler denke ich mal offen.