 | | | | | |||||||
| | | | | |||||||
| |
| | | |||||||
| | | | | |||||||
| | | | |
|
Mit den nächsten Beispielen möchte ich 2 kleinere Projekte
vorstellen.
Um die Möglichkeiten aufzuzeigen, wie schnell man sich in JAVA
einarbeiten kann, folgende Bemerkungen dazu :
- diese Projekte sind komplett selbständig von 2 Schülern
Klassenstufe 12 entwickelt worden
- sie erhielten das JDK und haben sich mit JAVA und dessen Dokumentation
ca. 2 Wochen intensiver befaßt (im Unterricht und privat)
- ein Schüler programmiert seit ca. 1 Jahr in Pascal
- der andere Schüler hatte längere Erfahrungen mit Pascal
und C++
Entstanden sind ein Projekt GALGENRATEN bzw. Wortratespiel, in dem mit
Files zum Einlesen verschiedener Wörter und eingebundenen GIF-Grafiken
gearbeitet wurde.
Das andere Projekt stellt eine Datenbank mit Anbindung an eine EXCEL
CSV - Datei dar. Somit können auch Daten mittels Excel nachbearbeitet
oder erweitert werden.
Die Scripte sind gut ausdokumentiert. Nach etwas Einarbeitung in JAVA
lassen sie sich leicht verfolgen.
Abschlußbemerkung :
Die Projekte sind nach kurzer
Einarbeitung in Java komplett selbständig innerhalb von ca. 14 Tagen
entstanden. Dies zeigt 2 Dinge :
a) Als Informatiklehrer dürfte
uns die Einarbeitung in Java nicht zu schwer fallen und auch nicht zu viel
Zeit in Anspruch nehmen.
b) Viele Schüler haben
Interesse an Java gefunden, arbeiten sich schon selbständig ein, sind
damit motivierbar und den Lehrern sehr schnell um Vieles voraus.
Resultat : Schneller Einstieg mit den Schülern in Java und somit in die OOP !
Hier die Scripte :
1. Script (Hangman):
komplett
als ZIP (19,8 kB)
2. Script (Datenbank):
komplett
als ZIP (17 kB)
/*
HANGMAN FOR JAVA
(c)1998/99 by Markus Birth <Robo.Cop(a)gmx.net>
This is the first program I wrote in Java. Thanks
to
Mr. Fröbel for making me learning Java so
quick (We had to
finish our projects for the computer science
lessons.)
Things used for the making of this:
-Xemacs with its Revision Control System
-hangman.java from Carlos von Hoyningen-Huene
-some bottles of PEPSI Coke
-hints & tips from Carlos von Hoyningen-Huene
*/
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.Character.*;
import java.math.*; //
eigentlich nur für die eine Zufallszahl
import java.io.*;
// für Dateioperationen ("Tupfer, Schere
...")
public class hangman extends Frame {
// Globale Variablen
final static int WND_B=400,
WND_H=300;
final int SX=50, SY=50;
RandomAccessFile file;
String myword=null;
//
Wort: was es mal werden soll
char xyword[];
// Wort: xy-ungelöst
char probed[];
char notprobed[];
char alphab[]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N',
'O','P','Q','R','S','T','U','V','W','X','Y','Z',
'Ä','Ö','Ü','ß'};
int mistakes=0; //
Anzahl Fehler (MIST!-akes)
int tries=0;
// Anzahl Versuche
KL CONTROL;
char c;
public hangman() {
// Hauptroutine
String stmp=new String();
try {
int wordcount=0;
// neuer Integer für Wörterzahl
int wordseek=0;
// ~ für Zielwort-Position
// und jetzt machen wir die Datei auf: "Schwester: Skalpell!"
RandomAccessFile f=new
RandomAccessFile("hangman.dat","r");
while ((stmp=f.readLine())!=null)
{ // solange das, was wir lesen, nicht
nichts ist ...
if (stmp.charAt(0) != '#') {
// und da auch kein "#" am Anfang klebt ...
wordcount++;
// zähle es als Wort.
}
}
if (wordcount==0) {
System.out.println("ACHTUNG!
In der Datendatei sind keine gültigen Wörter zu finden.");
System.exit(0);
}
System.out.println("Woerter
in Datendatei: "+wordcount); // Statusbericht
while (wordseek==0)
{ // Solange wordseek noch
0 ist, tue ...
wordseek=(int)(Math.random()*wordcount)+1;
// hol' Dir einen Integer-Wert
}
System.out.print("Ausgewaehltes
Wort: #"+wordseek); // Statusbericht
f.seek(0);
// Position auf Dateianfang setzen
wordcount=0;
// Wieder auf NULL
while ((stmp=f.readLine())!=null)
{ // und das ganze wieder von
vorn
if (stmp.charAt(0) != '#') {
wordcount++;
if (wordcount==wordseek)
{ // wenn an Position,
die wir suchen ...
myword=stmp;
// setze myword auf gerade gelesenen String
break;
// und raus hier!
}
}
}
f.close();
// Datei wieder zunähen
}
catch(IOException ioe) {
//
Falls doch mal ein Fehler auftreten sollte ...
System.out.println("IOException:
"+ioe.toString()); // Fehlermeldung
und tschüß!
System.out.println("\n\nFehler
beim Bearbeiten der Datendatei. Stellen Sie sicher, daß die Datei
HANGMAN.DAT auch existiert und lesbar ist.");
System.exit(0);
}
CONTROL=new KL(); //
neuer KeyListener: CONTROL
addKeyListener(CONTROL); //
hinzufügen
xyword=new char[myword.length()];
// array erstellen
for (int i=0;i<myword.length();i++)
{ // array initialisieren
xyword[i]='_';
}
probed=new char[alphab.length];
// array erstellen
notprobed=new char[alphab.length];
for (int i=0;i<alphab.length;i++) {
// array initialisieren
probed[i]='-';
notprobed[i]=alphab[i];
}
}
public void update(Graphics g)
{
paint(g);
} //Ergänzung
: Flackern beim Zeichen des Grafikbildschirms verhindern
//was nun noch flackert, ist das Überzeichnen
des Bildes bzw. Einlesen der Bilddatei
public void paint(Graphics
g) { // hier
die Grafik ...
// g.drawString("Datensaetze: "+maxdat,40,350);
// g.drawString("Wort: "+myword,40,200);
// g.drawString("Zeichen: "+c,40,230);
g.setColor(Color.black);
// Farbe auf SCHWARZ
g.fillRect(0,0,WND_B,WND_H);
// Fenster schön SCHWARZ machen!
g.setColor(Color.yellow);
// und Farbe auf GELB setzen
g.drawString("Wort: "+new String(xyword),40,215);
if (mistakes!=-1) {
g.drawString("Buchstaben:
",40,260);
for (int i=0;i<alphab.length;i++)
{
g.drawChars(probed,i,1,118+i*8,260);
g.drawChars(notprobed,i,1,118+i*8,275);
}
g.drawString("Fehler:
"+mistakes,40,230);
}
UpdateHangMan(g); //
Hangman updaten
}
public void UpdateHangMan(Graphics
g) {
Toolkit tk=Toolkit.getDefaultToolkit();
// Toolkit (für Grafikdatei-Support) zuweisen
switch(mistakes) { //
CASE mistakes of ...
case 6:
g.drawImage(tk.getImage("images/hm6.gif"),SX,SY,this);
g.setColor(Color.red);
g.drawString(">>> VERLOREN
<<<",WND_B/2-100,WND_H/2+10);
g.setColor(Color.white);
g.drawString("Das gesuchte
Wort war '"+myword+"'!",WND_B/2-100,WND_H/2+25);
removeKeyListener(CONTROL);
// Tastenkontrolle abschalten
break;
case 5:
g.drawImage(tk.getImage("images/hm5.gif"),SX,SY,this);
break;
case 4:
g.drawImage(tk.getImage("images/hm4.gif"),SX,SY,this);
break;
case 3:
g.drawImage(tk.getImage("images/hm3.gif"),SX,SY,this);
break;
case 2:
g.drawImage(tk.getImage("images/hm2.gif"),SX,SY,this);
break;
case 1:
g.drawImage(tk.getImage("images/hm1.gif"),SX,SY,this);
break;
case 0:
g.drawImage(tk.getImage("images/hm0.gif"),SX,SY,this);
break;
case -1:
g.drawImage(tk.getImage("images/hm.gif"),SX,SY,this);
g.setColor(Color.green);
g.drawString(">>> GEWONNEN
<<<",WND_B/2-100,WND_H/2+20);
removeKeyListener(CONTROL);
break;
}
}
class KL implements KeyListener
{
public void keyPressed(KeyEvent e) { }
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) {
c=e.getKeyChar();
// Taste holen
c=Character.toUpperCase(c);
// Buchstabe(?) evtl. GROß machen
int i;
// Wir brauchen bald ein Iiiiihh
boolean status=false;
// Booleans
boolean check=false;
// für versch. Status-Werte
for (i=0;i<alphab.length;i++)
{
if (c==alphab[i]) {
// wenn c = einer der Buchst. des Alphabets ist ...
if (probed[i]!=c)
probed[i]=c; else check=true; // und
der auch noch nicht vorher getippt wurde, dann ... u.s.w.
if (notprobed[i]==c)
notprobed[i]='-';
}
}
int underscores=0;
// Integer für Anzahl der "_" im bisher gepuzzleten Wort
for (i=0;i<myword.length();i++)
{
if (c==Character.toUpperCase(myword.charAt(i)))
{
xyword[i]=myword.charAt(i);
status=true;
}
if (xyword[i]=='_') underscores++;
}
if (!status &&
!check) mistakes++; // wenn falscher
Buchstabe und Buchst. nicht schonmal getippt: mistakes+1;
if (!check) tries++;
// solange nicht doppelter Tip: tries+1;
if (underscores==0 ||
mistakes>=6) {
System.out.println(" ("+myword+")");
System.out.println("Anzahl Versuche: "+tries+"
davon falsch: "+mistakes);
System.out.println("Getippte Buchstaben:
"+new String(probed));
System.out.println("Anzahl versch. Buchstaben
im Wort: "+(tries-mistakes));
System.out.println("Trefferquote: "+(((tries-mistakes)*100)/tries)+"%");
}
if (underscores==0)
mistakes=-1; // wenn keine fehlenden
Zeichen im Lösungswort ...
if (mistakes>=6) mistakes=6;
// wenn mehr als 5 Fehler ...
repaint();
// Grafikfenster neuzeichnen
}
}
public static void main(String
args[]) {
Frame frame=new hangman();
// neues Fenster
frame.addWindowListener(new
WindowAdapter() { // WindowListener
hinzufügen
public void windowClosing(WindowEvent
e) { // wenn auf X geklickt:
System.out.println();
System.exit(0);
// Programm beenden.
}
});
frame.setTitle("HangMan for Java - \u00a91998
by Markus Birth"); // Titel setzen
frame.setSize(WND_B, WND_H);
// Größe setzen
frame.show();
// und ab auf den Bildschirm damit!
/* Pictures
Image pic;
pic=Toolkit.getDefaultToolkit().getImage("image.jpg");
g.drawImage(pic,0,0,this);
*/
}
}
////////////////////////////////////////////////////////////////////////////////
// DATABANK - VERSION
1.0
//
//
von
//
//
Carlos von Hoyningen-Huene
//
//
//
// Enwickelt mit
den
//
//
Java Development Kit (JDK) 1.1.6 von Sun Microsystems
//
//
//
// Getestet auf
//
//
Windows NT 4.0, WIndows 98, Windows 95, Linux (Kernel 2.0.36) //
//
//
// Bei Fragen oder
Fehlern bin ich per Mail zu erreichen:
//
//
carlos.vhh@bigfoot.com
//
////////////////////////////////////////////////////////////////////////////////
// Bibliotheken einbinden für...
import java.applet.*;
//... die allgemeine Appletverwaltung
import java.awt.*;
//... das AWT-System (graphische Oberfläche
von Java)
import java.awt.event.*;
//... das AWT-Event-System
import java.io.*;
//... das IO-System
import java.util.*;
//... zusätzliche Dinge (hier: für die Vectoren entspr. Zeigern)
// Diese Daten können verarbeitet werden:
// nname
vname plz ort
str nr
// tel
fax mail url
geb.
class Person
// ein Objekt für die Personendaten
{
String data[]=new String[11];
// Feld für die einzelnen Daten initialisieren
public Person()
{
for
(int i=0;i<11;i++) data[i]=new String();//
die einzelnen Felder initialisieren
}
}
public class databank extends Frame
{
////////////////////////////////////////////////////////////////////////////////
//
Deklarationsteil der Variablen und Konstanten
////////////////////////////////////////////////////////////////////////////////
// Konstanten
final int MAX_ENTRY=11;
// max. Anzahl der Infos pro Person
final Frame parent_frame=this;
// "Zeiger" auf Hauptfenster (braucht FileDialogWindow)
// eigentlich gibt es keine Zeigerarithmetik in Java,
// aber einen passenderen Begriff gibt es nicht
// (siehe Code ab Zeile 303)
// alles für unseren Menübalken...
MenuBar menubar=new MenuBar();
// das Hauptmenü
Menu menu1=new Menu("Datei"),
// das Dateimenü
menu2=new Menu("Adresse");
// das Adressenmenü
// die Menüpunkte für unsere Menüs
MenuItem newf=new MenuItem("Neu"),
// neue Datenbank
open=new MenuItem("Öffnen"),// Datei
öffenen
save=new MenuItem("Speichern"),// Datei Speichern
exit=new MenuItem("Beenden"),// Programm beenden
newp=new MenuItem("Neu"), // neue Adresse
insert=new MenuItem("Einfügen"),// Adresse
einfügen
update=new MenuItem("Ändern"),// Adresse
aktualisieren
delete=new MenuItem("Entfernen");// Adresse
entfernen
// unsere graphischen Eingabeelemente
List lst=new List();
// unsere Adressenliste
TextField input[]=new TextField[MAX_ENTRY];//
unsere Eingabefelder als Feld,
// da Verwaltung einfacher ist
Label label[]=new Label[MAX_ENTRY];
//
Beschriftungen der Felder, auch als Feld
// für die Adressverwaltung
Vector adr=new Vector();
// die Adressen in einen dynamischen Feld
// In Java heiáen diese "Vectoren",
entsprechen
// aber von der technischen Seite her dem
// dynamischen Felder aus Pascal und C.
// Jedoch ist die Benutzung hier besser.
String fname, dname;
// Datei- und Verzeichnisname der Adressendatei
////////////////////////////////////////////////////////////////////////////////
//
Deklarationsteil der Methoden
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////
// *** databank - der Konstruktor
public databank()
{
// initialisiere das AWT-Eventsystem des Menus
...
// Die ITEM_xxx Bezeicher sind "inner classes",
welche die
// Steuerung der Menuitems verwalten (Deklaration
Unten)
// Jedes "Event" wird ab der AWT Version 1.1
als "inner class"
// gehandhabt (eine Objektklasse innerhalb einer
anderen).
newf.addActionListener(new
ITEM_NEUF());
open.addActionListener(new
ITEM_OPEN());
save.addActionListener(new
ITEM_SAVE());
exit.addActionListener(new
ITEM_EXIT());
newp.addActionListener(new
ITEM_NEUP());
insert.addActionListener(new
ITEM_INSERT());
update.addActionListener(new
ITEM_UPDATE());
delete.addActionListener(new
ITEM_DELETE());
// erstelle Hauptmenü ...
menu1.add(newf);
menu1.add(open);
menu1.add(save);
menu1.add(exit);
menubar.add(menu1);
menu2.add(newp);
menu2.add(insert);
menu2.add(update);
menu2.add(delete);
menubar.add(menu2);
setMenuBar(menubar);
// erstelle Eingabefelder und Labels ...
for
(int i=0;i<MAX_ENTRY;i++) input[i]=new TextField("",30);
label[0]=new
Label("Vorname",Label.RIGHT);
label[1]=new
Label("Nachname",Label.RIGHT);
label[2]=new
Label("Straße",Label.RIGHT);
label[3]=new
Label("Hausnummer",Label.RIGHT);
label[4]=new
Label("PLZ",Label.RIGHT);
label[5]=new
Label("Wohnort",Label.RIGHT);
label[6]=new
Label("Telefon",Label.RIGHT);
label[7]=new
Label("Fax",Label.RIGHT);
label[8]=new
Label("eMail",Label.RIGHT);
label[9]=new
Label("URL",Label.RIGHT);
label[10]=new
Label("Geburtstag",Label.RIGHT);
// Eingabefelder, Labels und Adressenliste in
Applet importieren ...
// Dieser Prozeß kann in Java OHNE die
Angabe von ABSOLUTEN KOORDINATEN
// durchgef?hrt werden.
// Java stellt dafür den "LayoutManager"
zur Verfügung, welcher die
// Elemente immer relativ zum systemsprezifischen
Programmfenster anordnet.
Panel
plabel=new Panel();
plabel.setLayout(new
GridLayout(MAX_ENTRY,1));
for
(int i=0;i<MAX_ENTRY;i++) plabel.add(label[i]);
Panel
pinput=new Panel();
pinput.setLayout(new
GridLayout(MAX_ENTRY,1));
for
(int i=0;i<MAX_ENTRY;i++) pinput.add(input[i]);
lst.addItemListener(new LST()); // hier wird noch das Listenevent aktiviert
setLayout(new
BorderLayout());
add("West",lst);
add("Center",plabel);
add("East",pinput);
}
//////////////////////////////////
// *** readFile - zum Einlesen der Adressen (aus
CSV-Datei)
public void readFile(String
filename)
{
Person
tmp;
// temporäre Variable für einen Datensatz
String
buf;
// temporäre Variable für Dateibearbeitung
char
ch[]=new char[1];
// ein Ein-Feld-Array f?r den String-Konstruktor
// (siehe Zeile 165)
int
entry;
// Eintrag eines Datensatzes, der gerade bearbeitet wird
lst.removeAll();
// Listenfeld leeren
adr.removeAllElements();
// Adressen aus Speicher entfernen
try
{
RandomAccessFile f=new RandomAccessFile(filename,"r");//
Datei oeffnen
while ((buf=f.readLine())!=null)// Zeile einlesen
{
// Zeile verarbeiten...
entry=0;
tmp=new Person();
for (int i=0;i<buf.length();i++)
{
ch[0]=buf.charAt(i);// Zeichen aus String
lesen
switch(ch[0])
{
case ';':
// wenn Trennzeichen ';', nächster Eintrag
entry++;
break;
case '\n':
// wenn neue Zeile (zwei Varianten, da Unix und Windows
case '\r':
// hier unterschiedliche Zeichen verwenden), Adresse in
// die Adress-Kette einfügen
adr.addElement(tmp);
break;
default:
// wenn kein besonderes Zeichen,
// füge das Zeichen an den Datensatz-
// eintrag an
tmp.data[entry]=tmp.data[entry].concat(new String(ch));
break;
}
}
}
f.close();
// Datei schließen
}
catch(IOException
e)
{
System.out.println(e.toString()); // falls
Fehler: ihn ausgeben
}
}
//////////////////////////////////
// *** writeFile - zum Sichern der Adressen (in
CSV-Datei)
public void writeFile(String
filename)
{
Person
tmp;
// temporäre Variable für einen Datensatz
try
{
RandomAccessFile f=new RandomAccessFile(filename,"rw"); //
Datei öffnen
for (int i=0;i<adr.size();i++) // alle
Adressen abspeichern
{
tmp=new Person();
tmp=(Person)adr.elementAt(i);
for (int j=0;j<MAX_ENTRY;j++) f.writeBytes(tmp.data[j]+";");
// Daten
// in Datei schreiben
f.writeBytes("\r\n"); // Zeilenende
in Datei schreiben
}
f.close();
}
catch(IOException
e)
{
System.out.println(e.toString()); // Fehler
? Hoffentlich nicht!
}
}
//////////////////////////////////
// *** showList - schreibt den Vector adr in
die Liste lst
public void showList()
{
Person
tmp=new Person();
lst.removeAll();
sortList();
// eigene Routine (siehe 229)
if
(!adr.isEmpty())
{
for (int i=0;i<adr.size();i++)
{
tmp=(Person)adr.elementAt(i);// Element aus
Vector holen
lst.addItem(tmp.data[0]+", "+tmp.data[1]);//
Element in Liste einfügen
}
}
}
//////////////////////////////////
// *** sortList - sortiert die Eintraege im Vector
adr
public void sortList()
{
// hier wird ein simpler Sortieralgorithmus durchgef?hrt,
der
// die Adresse alphabetisch, aufsteigend in dem
Vector sortiert.
// (Diesen Algorithmus sollte wirklich JEDER
erklären konnen :-)
Person
tmp1=new Person(),
tmp2=new Person(),
swp=new Person();
lst.removeAll();
if
(!adr.isEmpty())
{
for (int i=0;i<adr.size();i++)
{
for (int j=0;j<adr.size();j++)
{
tmp1=(Person)adr.elementAt(i); // Element an der Position i
// aus den Vector adr holen
tmp2=(Person)adr.elementAt(j);
if (tmp1.data[0].compareTo(tmp2.data[0])<0) //
Zwei Strings vergleichen
{
swp=tmp1;
tmp1=tmp2;
tmp2=swp;
adr.setElementAt(tmp1,i); // vertauschte Daten
an die
adr.setElementAt(tmp2,j); // entsprechende
Position in "adr" schreiben
}
}
}
}
}
//////////////////////////////////
// *** main - das Hauptprogramm
public static void main(String
args[])
{
Frame
frame=new databank();
// Frame-Objekt aus "databank" generieren
// jetzt wird ein "Window-Event" den Frame hinzugefügt,
so das man mit der
// Systemspezifischen Tastenkombination (unter
Windows ALT+F4) das Programmfenster
// schlieáen kann. Normalerweise l?uft
ein Java-Programm solange der Interpreter
// läuft und kümmert sich nicht um
die System-Events (z.B. Fenster schließen)
frame.addWindowListener(new
WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
frame.setTitle("Databank
- Version 1.0 by Carlos von Hoyningen-Huene");
frame.setSize(500,400);
frame.show();
}
////////////////////////////////////////////////////////////////////////////////
//
Deklarationsteil der inneren Klassen
////////////////////////////////////////////////////////////////////////////////
// wenn Menuitem "Neu" im Menü Datei aktiviert
wird...
class ITEM_NEUF implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
lst.removeAll();
// Liste leeren
adr.removeAllElements();
// Vector leeren
for (int i=0;i<MAX_ENTRY;i++) input[i].setText(""); //
Eingabefelder leeren
}
}
// wenn Menuitem "?ffnen" aktiviert wird...
class ITEM_OPEN implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
// FileDialog-Fenster aktivieren, um Dateinamen auszuw?hlen
//
Statt der Variablen "parent_frame", koennte man normalerweise
//
"this" verwenden. Da dies jedoch ein anderes Objekt als das
//
Programmfenster ist, wuerde "this" nicht auf unser Programm zeigen.
//
Daher verwendet man hier eine Variable, der man das Handle unseres
//
Programmes zuweist
FileDialog d=new FileDialog(parent_frame, "Datei oeffnen...");
d.setFile("*.csv");
// Standard-Datei-Maske setzen
d.setDirectory(".");
// aktuelles Verzeichnis setzen
d.show();
// das Fenster anzeigen
String openFile;
if ((openFile=d.getFile())!=null)
{
fname=openFile;
// gew?hlter Dateiname
dname=d.getDirectory(); // gew?hlter Verzeichnisname
}
readFile(dname+fname);
// Datei einlesen
showList();
}
}
// wenn Menuitem "Speichern" aktiviert wird...
class ITEM_SAVE implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
//
wie beim ?ffnen
FileDialog d=new FileDialog(parent_frame, "Datei speichern unter...");
d.setFile("*.csv");
d.setDirectory(".");
d.show();
String saveFile;
if ((saveFile=d.getFile())!=null)
{
fname=saveFile;
dname=d.getDirectory();
}
writeFile(dname+fname); //
Datei schreiben
}
}
// wenn Menuitem "Beenden" aktiviert wird...
class ITEM_EXIT implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
System.exit(0); // klar, oder ???
}
}
// wenn Menuitem "Neu" im Menue Adresse aktiviert
wird...
class ITEM_NEUP implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
for (int i=0;i<MAX_ENTRY;i++) input[i].setText(""); //
Alle Eingabefelder leeren
}
}
// wenn Menuitem "Einfuegen" aktiviert wird...
class ITEM_INSERT implements
ActionListener
{
Person
tmp;
public
void actionPerformed(ActionEvent e)
{
tmp=new Person();
// Eigentlich passt das ganze in eine for-Schleife,
//
nur da mein Dateiformat die Daten in einer anderen
//
Reihenfolge zur Verfuegung stellt, als sie in den
//
Eingabefeldern angezeigt werden, ist eine manuelle Zuweisung
//
notwendig.
tmp.data[0]=input[1].getText();
tmp.data[1]=input[0].getText();
tmp.data[2]=input[4].getText();
tmp.data[3]=input[5].getText();
tmp.data[4]=input[2].getText();
tmp.data[5]=input[3].getText();
tmp.data[6]=input[6].getText();
tmp.data[7]=input[7].getText();
tmp.data[8]=input[8].getText();
tmp.data[9]=input[9].getText();
tmp.data[10]=input[10].getText();
adr.addElement(tmp);
showList();
}
}
// wenn Menuitem "?ndern" aktiviert wird...
class ITEM_UPDATE implements
ActionListener
{
Person
tmp;
public
void actionPerformed(ActionEvent e)
{
tmp=new Person();
int id=lst.getSelectedIndex(); // ausgew?hlte
Item-ID abfragen
// Datensatz aktualisieren
if (id>=0 && id<adr.size())
{
tmp.data[0]=input[1].getText();
tmp.data[1]=input[0].getText();
tmp.data[2]=input[4].getText();
tmp.data[3]=input[5].getText();
tmp.data[4]=input[2].getText();
tmp.data[5]=input[3].getText();
tmp.data[6]=input[6].getText();
tmp.data[7]=input[7].getText();
tmp.data[8]=input[8].getText();
tmp.data[9]=input[9].getText();
tmp.data[10]=input[10].getText();
adr.setElementAt(tmp,lst.getSelectedIndex()); //
Datensatz in
// den Vector an die Position des alten
// setzen.
}
showList();
}
}
// wenn Menuitem "Entfernen" aktiviert wird...
class ITEM_DELETE implements
ActionListener
{
public
void actionPerformed(ActionEvent e)
{
int i=lst.getSelectedIndex();
if (lst.isIndexSelected(i))
{
lst.deselect(i); //
Markierung entfernen, da sonst Fehler
// auftauchen (hat was mit dem Betriebssystem
// zu tun)
adr.removeElementAt(i); // Element an der Vectorposition i entfernen
showList();
}
}
}
// wenn Listenlement selektiert...
class LST implements ItemListener
{
public
void itemStateChanged(ItemEvent e)
{
Person tmp=new Person();
//
Daten in den Eingabefeldern aktualisieren
if (lst.getSelectedIndex()!=-1)
{
tmp=(Person)adr.elementAt(lst.getSelectedIndex());
input[0].setText(tmp.data[1]);
input[1].setText(tmp.data[0]);
input[2].setText(tmp.data[4]);
input[3].setText(tmp.data[5]);
input[4].setText(tmp.data[2]);
input[5].setText(tmp.data[3]);
input[6].setText(tmp.data[6]);
input[7].setText(tmp.data[7]);
input[8].setText(tmp.data[8]);
input[9].setText(tmp.data[9]);
input[10].setText(tmp.data[10]);
}
}
}
}
|
