Ordner-Synchronisierer
Der Ordner-Synchronisierer ist
ein Programm mit dem man Ordner von A nach B kopieren kann. Außerdem beinhaltet
es Zusatzfeatures mit dem man den Kopiervorgang erweitern kann
Inhaltsverzeichnis
Einleitung 2
1. Planung 3
2. Programmieranfang
(GUI) 5
3. Der
JFileChooser 7
4. Anfang
des Actionlistener 8
5. Änderung
der GUI 8
6. Kopieren 9
7. Neue
Idee (Batch) 9
8. Ausführen
der Batch 11
9. Erste
Ergebnisse 12
10. Mehrfachauswahl 13
11. Schleifenproblem 15
12. Zusatzfeatures 18
13. Die Letzte GUI 21
14. Das Problem des
Einfrieren 22
15. Ein letzter Fehler
und Änderungen 23
16. Schluss 24
17. Literaturverzeichnis 24
18. Quelltext
des Programms 25
Einleitung
Die nachfolgende
Dokumentation zeigt, wie ich mein Java Programm fertiggestellt habe. Mein
Projekt handelt um ein Programm das Ordner von A nach B kopiert. Dieser
Kopiervorgang ist unteranderem noch erweiterbar. Die Idee für dieses Projekt
fand ich in einem Forum indem Diskutiert wurde was man programmieren könnte.
Unter diesen Vorschlägen wurde auch mein jetziges Projekt, ein
Ordner-Synchronisierer, genannt. In dieser Dokumentation zeige ich euch mit was
für Probleme ich mich auseinandersetzten musste und wie ich zu anderen
Hilfsmitteln greifen musste damit mein Programm seine Aufgabe erfüllt. Meine
Arbeit ist so aufgebaut so wie ich mein Projekt in Wirklichkeit geschrieben
habe, deswegen weil es einen Einblick mit sich bringt wie nach und nach ein
Programm entsteht. Die Quellenangabe befindet sich am der Dokumentation.
1. Planung
Ich fang mit einer Planung
an weil ich wissen muss wie das Programm aussehen soll und was für Befehle ich
dann entsprechend brauche. Auch weiß ich nicht in welcher Programmiersprache
ich das Programm schreiben solle. Ich hab mir anfangs gedacht so ein Programm
sei relativ einfach zu schreiben und versuchte es mal mit C++. Also kaufe ich
mir das Buch: „C++ von A bis Z – Das umfassende Handbuch“. Als ich mir ein paar
Seiten durchlese stelle ich fest dass es die meisten Befehle von C++ auch in
Java gibt. Ich versuche dann einen Praxistest mit ein paar Beispielen. Doch da fängt
das Problem schon mit der Software an. Ich komme mit dem Programm nicht klar
und die Beispiele aus dem Buch wollen einfach nicht laufen. Deshalb schreib ich
das Programm nun in Java da ich mit dieser Programmiersprache und dem Editor
vertraut bin.
Zum Aussehen des Programms. Ich
mache mir eine Skizze mit Paint die die Oberfläche des Programms zeigt. Dort
steht dann zuallererst: „Wählen Sie bitte Ihre Aufgabe:“ gefolgt von drei
Buttons darunter mit der Aufschrift(von links nach rechts): „Kopieren von:
Ordner oder mehrere.“, „Kopieren von: Dateien und Ordner.“, „Automatisierter
Vorgang Bearbeiten.“
Abbildung 1
Nach Betätigen eines Buttons
solle sich dann ein Fenster mit der dann folgenden Aufgabe öffnen. Zum Beispiel
wenn man auf den Button „Kopieren von: Ordner oder mehrere.“ klickt öffnet sich
ein neues Fenster. Man kann nun ein Ordner oben auswählen oder unten mehrere
Ordner. Rechts oben wählt man die Zieladresse aus. Wenn dieser Vorgang mehrmals
ablaufen soll, wählt man noch „Automatisieren?“ aus und gibt einen Namen für
den Vorgang ein. Dann nur noch auf Synchronisieren klicken und das Programm
kopiert die Ordner zum Ziel.
.
Abbildung 2
Mir ist dann aber später aufgefallen,
dass so eine Prozedur recht lange dauert und somit nicht wirklich
benutzerfreundlich ist. Ich entscheide mich deshalb für ein anderes Design,
bestehend aus nur einem Fenster und alles was man zum Kopieren benötigt.
Zu den Befehlen. Die
Grundbefehle habe ich alle noch von der Schule und dem Unterricht. Diese
reichen jedoch nur für die GUI und ein paar Befehlen im Actionlistener. Der
Hauptbefehl den ich benötigte war der um die Ordner auszuwählen. Der Befehl
heißt JFileChooser.
Meine Planung ist fertig und
ich fange mit der Grafischen Benutzeroberfläche an(kurz GUI).
2. Programmieranfang (GUI)
Ich beginne eine GUI zu
erstellen welche 2 Buttons und einen Text mit der Aufschrift: „Bitte Aufgabe
auswählen“, zeigt.
Abbildung 3
Die Buttons haben noch keine
Funktion sollen aber wenn man draufklickt ein neues Fenster öffnen. Also
erstelle ich ein neues Programm das mit diesem geöffnet werden sollte. Ich
recherchiere nach möglichen Befehlen in meinen Unterlagen und im Internet um so
etwas zu bewerkstelligen, finde aber nichts Spezifisches.
Das ist ein Punkt an dem ich
denke nur ein Fenster zu gebrauchen und ich beschließe meine alten Skizzen
nicht zu verwenden und plante eine neue Oberfläche. Diese solle alles
beinhalten was man zum Kopieren braucht. Dadurch entsteht der Vorteil, dass der
Benutzer schneller seine Aufgaben wählen kann. Ich behalte mein Programm mit
den 2 Buttons und dem Text und füge ein BorderLayout hinzu. Mit diesem Layout
hab ich nun bestimmte Bereiche im Programm, sodass ich genau bestimmen, kann wo
Buttons oder anderes platziert werden soll.
Abbildung 4
Diese Bereiche sind
aufgeteilt in: NORTH, EAST, SOUTH, WEST und CENTER. Im Bereich NORTH implementiere
ich den Text und die 2 Buttons vom ersten Programm. Der Bereich CENTER
beinhaltet einen weiteren Button und ein Textfeld. Dort soll die Quelle
angegeben werden und im Textfeld solle dann der Pfad stehen. Im Bereich SOUTH
sind 2 weitere Buttons und noch ein Textfeld. Dort solle der Zielpfad angegeben
und im Textfeld angezeigt werden. Der letzte Button ist der Synchronisier
Button. Drückt man den Button, wenn Quelle und Ziel angegeben sind, kopiert das
Programm entsprechend.
Abbildung 5
Somit habe ich die
AnfangsGUI fertig und kann nun zum Punkt gehen an dem die Buttons aktiv werden
wenn man draufklickt. Ich weiß dass ich die GUI so nicht lassen werde. Sie ist
eher als Baustelle da um nach und nach zu testen ob die Befehle funktionieren.
3. Der JFileChooser
Auf der Suche nach einem
Befehl mit dem man unter Java Ordner auswählen kann, nutzte ich schnell das
Internet und suche nach: „Ordner auswählen unter Java.“ Zu meinem Glück steht
der Befehl beim ersten Suchergebnis. Der JFileChooser ist der Befehl um Ordner
oder Dateien auszuwählen. Diesen zu implementieren gestaltet sich aber als sehr
schwierig. Ich nehme den Befehl den ich zuerst finde und setze ihn in eine neue
Klasse ein. Er funktioniere jedoch nicht. Also suche ich nach anderen
Beispielen in anderen Foren. Als ich endlich einen finde der funktioniert
verändert ich ihn um zu verstehen was die einzelnen Befehle tun. Danach weiß
ich wie Ich den JFileChooser in mein Programm implementiere. Mein erster
fertiger JFileChooser seht dann so aus:
1. JFileChooser
fc1 = new JFileChooser();
2. fc1.setMultiSelectionEnabled
(false);
3. fc1.setFileSelectionMode
(JFileChooser.FILES_AND_DIRECTORIES);
4. fc1.showOpenDialog
(null);
5. this.auswahl1.setText
(fc1.getSelectedFile ());
1. Erstellt ein JFileChooser
2. Mehrfachauswahl ein(true) oder aus(false)
3. Gibt an, dass nur Dateien und Ordner auswählbar sind
4. Gibt an welcher Text im Auswahlfenster gezeigt wird
5. Zeigt an wo der Pfad gespeichert bzw. ausgegeben wird
fc1.showOpenDialog (null);
|
|
fc1.setMultiSelectionEnabled
(true);
|
|
Abbildung 6
Die letzte Zeile
zeigt an wo der Pfad gespeichert werden soll. Dieser Befehl zeigt aber nur den
Pfad an ohne die ausgewählte Datei, das heißt wenn ich einen Ordner auswähle
wird im Textfeld nur der Pfad gezeigt wo sich diese Datei befindet. Es wird
also nicht der komplette Pfad zurückgegeben. Ich habe nach ein paar Recherchen
nun aber doch den Befehl gefunden. Ich musste nur .getAbsolutePath() am Ende
der letzten Zeile anbringen damit der komplette Pfad gezeigt wird.
this.auswahl1.setText
(fc1.getSelectedFile ().getAbsolutePath ());
Nun habe ich den
fertigen Befehl und musste danach den Actionlistener programmieren damit die
Buttons diesen Befehl ausführen.
4. Anfang des Actionlistener
Als ich anfing den
ActionListener zu schreiben dachte ich, dass ich das schnell schaffe, dass die
Buttons etwas tun sollen. Doch es will mir einfach nicht gelingen, also muss
ich nochmal recherchieren damit dies auch klappt. Ich fand den Befehl der dafür
nötig war:
if(e.getActionCommand()=="Ordner
auswählen")
So hab ich es dann auch
geschafft dass ein Button den JFileChooser aufruft. Also hab ich den 2ten
Button auch so programmiert das dieser den JFileChooser öffnet. Dann das 1te
Problem. Wenn ich den Ordner auswählen will öffnet sich danach auch automatisch
der 2te JFileChooser um die Zieladresse auszuwählen. Das sollte nicht so sein
also suchte ich nach dem Fehler Im ActionListener. Der Fehler aber wollte mir
nicht ins Auge springen also suchte ich in meinen anderen Programmen nach den
ActionListener und sah wie sie da geschrieben werden. Als ich einen Hinweis sah
versuchte ich mein Programm so umzuschreiben und siehe da, es Funktioniert.
5. Änderung der GUI
Da mein Quellcode etwas
unübersichtlich geworden ist habe ich ihn für mich ein bisschen
benutzerfreundlicher geschrieben und Kommentare gesetzt. Ich will aber auch,
dass das Programm benutzerfreundlicher wird und deshalb Tooltipps eingesetzt.
Tooltipps sind Texte die erscheinen wenn man z.B. die Maus über einen Button
bewegt. Die Texte erscheinen dann und man bekommt z.B. hilfreiche Tipps oder
eine Beschreibung des Buttons.
6. Kopieren
Nun da ich eine GUI habe und
2 Pfade mittels des JFileChooser auswählen kann komm ich zur Hauptaufgabe
meines Programms, das Kopieren. Da ich nicht weiß wie so etwas in Java
funktioniert und wir das in der Schule noch nie durchgenommen haben muss ich
mittels Internet wieder recherchieren. Ich finde schnell eine Seite wie man
Dateien verschieben und Kopieren kann. Doch verschieben will ich nicht und den
Kopierbefehl kann man nur mit einer Datei benutzen. Außerdem bricht dieser bei
einer großen Datei manchmal ab und ist somit ungeeignet.
Ich suche dann weiter, doch
ich finde zunächst nichts, bis einer meiner Schulkameraden mir ein Vorschlag macht
dass ich die Windows Batch nehmen solle. Denn dort ist ja der Kopierbefehl XCOPY
vorhanden. Ich finde die Idee anfangs nicht so toll da ich ja mit Java kopieren
will und nicht mit Batch. Doch da ich keine andere Möglichkeit finde es mit
Java zu bewerkstelligen versuche ich es mal mit Batch.
7. Neue Idee (Batch)
Da ich nun Batch zum
Kopieren nutze, recherchiere ich schnell zu dem Befehl XCOPY mit Hilfe der
Kommando Konsole nach und finde heraus dass man einen Quellpfad und einen Zielpfad
braucht. Außerdem kann man mit Zusatzbuchstaben am Ende den Kopiervorgang mit
Features erweitern, z. B. wenn am Ende des Befehls /C eingesetzt wird, wird
auch weiterkopiert wenn Fehler auftreten. Da ich Quellpfad und Zielpfad habe,
muss ich nur noch eine Methode in meinem Programm schreiben das eine Batch
Datei erstellt. Ich werde schnell fündig mit der Methode BufferedWriter mit der
man in der Lage ist eine Datei zu erstellen. Im Beispiel im Internet wurde eine
.txt Datei erstellt. Ich muss einfach das .txt in .bat umwandeln und schon
erstellt die Methode Batch Dateien. Mit dem Befehl out.write(„Text“) wird das
Wort Text in diese Batch geschrieben. Dann schreib ich den Pfad „auswahl1“ in
die Methode rein da ja das der Pfad ist. Doch es geht nicht weil „auswahl1“ als
JTextField deklariert ist und man nur String werte reinschreiben kann. Also
brauche ich 2 neue String werte. So sieht meine Methode aus um eine Batch zu
schreiben(S10):
BufferedWriter out;
try
{
out = new BufferedWriter (new FileWriter("M:/test.bat")); out.write("XCOPY");
out.write(" "); out.write(auswahl2);
out.write(" ");
out.write(jtfName2);
out.write(" ");
out.write("/Y");
out.write(" ");
out.write("/E");
out.write(" ");
out.close();
catch (IOException e1)
{
e1.printStackTrace();
}
XCOPY war der Befehl für den
Batch Befehl. Danach kommt eine Leerzeile(out.write(„ “);). auswahl2
ist der Quellpfad aber da auswahl2 noch kein String Wert hat muss ich am Ende
des JFileChoosers für die Quellpfad Auswahl folgendes schreiben.
JFileChooser
fc1 = new JFileChooser();
fc1.setMultiSelectionEnabled
(false);
fc1.setFileSelectionMode
(JFileChooser.FILES_AND_DIRECTORIES);
fc1.showOpenDialog
(null);
this.auswahl1.setText
(fc1.getSelectedFile().getAbsolutePath ());
this.auswahl2
= auswahl1.getText();
Auswahl2 wurde vorher als
String deklariert und erhält nun in dieser Methode den Pfad der Quelldatei. Das
gleiche muss ich auch beim JFileChooser der Zieladresse angeben. Die Buchstaben
/Y und /E sind Zusatz Features und haben folgende Aufgabe: /Y unterdrückt die
Aufforderung zur Bestätigung, dass eine vorhandene Zieldatei überschrieben
werden soll. /E kopiert alle Unterverzeichnisse(leer oder nicht leer).
out.close(); schließt die die Datei. Ohne diesen Befehl funktioniert die
Methode nicht.
Nun führe ich einen Test
durch. Zu meinem Glück hat es funktioniert und eine Batch wurde erstellt. Dazu
habe ich 2 Testordner auf meinem Desktop erstellt und in einem der Ordner einen
neuen Ordner erstellt indem ein Textdokument liegt. Der Inhalt der Batch sieht
so aus:
XCOPY
C:\Users\Terratex\Desktop\Test1\Neuer Ordner C:\Users\Terratex\Desktop\Test2 /Y
/E
Ich starte die Batch Datei
aber es wird nichts kopiert. Ich füge am Ende der Batch den Begriff „pause“ ein
damit sich das Fenster nicht schließt. Dann sehe ich als Fehler unter dem
Befehl: „Ungültige Parameteranzahl“. Ich recherchiere und finde heraus dass
keine Leerzeichen in den Ordnernamen vorhanden sein dürfen. Dieses Problem kann
man aber lösen indem man die beiden Pfade jeweils in Anführungszeichen setzt.
Also muss ich einen Weg finden die Pfade in Anführungszeichen zu setzen damit
das auch klapp.
Das war einfach da jemand
ein ähnliches Problem hatte und entsprechend ein Lösungsvorschlag gegeben hat.
Dazu muss man wie folgt den Befehl schreiben:
this.auswahl2
= “\““ + auswahl2 + “\““;
Das Backslash Zeichen ist
dafür da um das Anführungszeichen zu schreiben. Das Gleiche ebenfalls auch mit
dem anderen Pfad und der Batch Befehl sieht wie folgt aus:
XCOPY
“C:\Users\Terratex\Desktop\Test1\Neuer Ordner“
“C:\Users\Terratex\Desktop\Test2“ /Y /E
Nach Starten der Batch bin
ich zufrieden dass sie funktionierte und kann mich daran setzen, dass mein
Programm diese Batch auch ausführen soll wenn sie erstellt wird.
8. Ausführen der Batch
Auf der Suche nach einer
Methode das die Batch ausführen soll nachdem sie erstellt wird, finde ich die
Methode Process. Dort gibt es den Befehl Runtime.getRuntime().exec() mit dem
man Dateien ausführen kann. Nur weiß ich nicht wie ich diesen Befehl schreiben
muss. Nach nach einer kurzen Recherche finde ich was Besseres. Auf der Seite
steht wie ich den Befehl schreibe und noch eine komplette Lösung wie ich eine
Batch ausführe. Ich entscheide mich diese Lösung anfangs zu nehmen und später
wenn mein Programm läuft selber eine zu schreiben.
Process myProcess = null;
try
{
myProcess
=
Runtime.getRuntime().exec("C:\\Programme\\Testen\\sprachdatei.bat");
myProcess.waitFor();
} catch
(IOException e) {
System.out.println("Exception beim Ausfuehren batch Files " +
e.getCause());
}catch
(InterruptedException e) {
System.out.println("Exception beim Ausfuehren batch Files " +
e.getCause());
}
if(myProcess.exitValue() == 0) {
System.out.println("Das Programm wurde erfolgreich ausgeführt!");
return ;
}
else
{
System.out.println("Das Programm ist nicht erfolgreich ausgeführt
worden!");
return;
}
Ich nehme also die fertige
Methode und füge sie am Ende meiner Methode, die die Batch Datei erstellt, ein.
Ich starte mein Programm um es zu testen aber es passiert nichts. Ich suche
nach dem Problem und stelle fest, dass ich vergessen habe den Pfad zu ändern.
Ich ändere den Pfad der in dem Befehl Runtime.getRuntime().exec(„Pfad“)
steht um, in den Pfad, in dem die Batch Datei erstellt wird.
Nach dem vielen Rumprobieren
steht nun endlich bei der Ausgabe:
Das
Programm wurde erfolgreich ausgeführt!
9. Erste Ergebnisse
Meine ersten Ergebnisse sehen
wie folgt aus: Mithilfe meines Programms kann ich zuerst den Ordner auswählen
der kopiert werden soll, danach wählt man den Ordner aus wohin es kopiert
werden soll. Ein Klick auf den Button Synchronisieren erstellt eine Batch Datei
und wird anschließend auch ausgeführt, ohne dass das cmd Fenster gezeigt wird
wenn man solche Dateien startet.
Als nächstes war es mir wichtig
eine Mehrfachauswahl zu ermöglichen um mehr Ordner auszuwählen.
10. Mehrfachauswahl
Die Mehrfachauswahl
gestaltet sich als sehr schwierig da ich einige Änderungen vornehmen muss.
Zum einen ist da das Problem
mit der Auswahl der Quelle. Der Wert der Quelle ist ein String und kann deshalb
nicht mehrere Pfade annehmen. Ich suche nach einer Lösung und finde ein
Programm mit dem man mehrere Dateien auswählen kann. Ich sehe mir den Quellcode
von dem Programm an und finde schließlich heraus wie die Mehrfachauswahl
funktioniert. Die Pfade werden in einem File gespeichert und dann mit Hilfe
einer Schleife und einem Array in eine JList ausgegeben. Ich habe mir die
Befehle rauskopiert die für die Mehrfachauswahl nötig sind und in meinen
Quellcode eingesetzt.
selectedFileLabel = new JLabel("-");
selectedFileLabel.setBorder(BorderFactory.createTitledBorder("Selected
File/Directory: "));
displayPanel.add(selectedFileLabel,
BorderLayout.NORTH);
selectedFilesList = new JList();
JScrollPane
sp = new JScrollPane(selectedFilesList);
sp.setBorder(BorderFactory.createTitledBorder("Selected
Files: "));
displayPanel.add(sp);
returnCodeLabel = new JLabel("0");
returnCodeLabel.setBorder
(BorderFactory.createTitledBorder ("Return
Code:"));
displayPanel.add (returnCodeLabel, BorderLayout.SOUTH);
Diesen Code brauche ich um
die JList darzustellen indem die Pfade gezeigt werden. Die 2 JLabels habe ich
später entfernt weil sie für mich unnötig waren.
selectedFile = chooser.getSelectedFile();
selectedFiles = chooser.getSelectedFiles();
Diesen Code hänge ich an den
JFileChooser dran der die Quellen auswählt, da ich für diesen einen File
brauche in den die Pfade gespeichert werden. So sieht mein fertiger
JFileChooser aus:
JFileChooser
fc1 = new JFileChooser ();
fc1.setMultiSelectionEnabled (true);
fc1.setFileSelectionMode (JFileChooser.DIRECTORIES_ONLY);
fc1.showDialog (this, "Auswählen");
selectedFile = fc1.getSelectedFile ();
selectedFiles = fc1.getSelectedFiles
();
Ich habe noch den Text des
Buttons in „Auswählen“ geändert da sich das sinnvoller anhört als „Öffnen“.
Mit diesem Code werden die
Files erstellt:
File selectedFile = null;
File[] selectedFiles = new File[0];
Wie man erkennen kann ist
„selectedFiles“ ein Array und für die Mehrfachauswahl nötig.
Doch nun kam ein schwieriges
Problem an dem in lange festhing. Ich kann die Files nicht in mein
BufferedWriter schreiben da diese keine Strings sind. Ich versuche viele
Möglichkeiten wie z.B. das „selectedFile“ als String zu deklarieren. Aber dann
hätte ich nur einen Pfad und nicht mehrere. „selectedFiles“ kann ich nicht als
String setzen also suche ich weiter. Die Lösung war sehr einfach und simpel.
Ich muss einfach in BufferedWriter folgendes schreiben:
out.write(“selectedFile.toString“)
Ein Einfaches toString am
Ende und der File ist ein String Wert. Diesen kann ich endlich in mein
BufferedWriter einsetzen und es zeigt keinen Fehler an. Nach einem kurzen
Testdurchlauf kommt das Ergebnis dass das Programm ausgeführt worden ist. Doch
das funktioniert nur für einen Pfad. Ich muss also das Array einsetzen und eine
Schleife einfügen.
11. Schleifenproblem
Um mehrere Pfade nutzen zu
können brauche ich eine Schleife. Doch da ich mit Arrays wenig Erfahrung habe
war für mich die Schleife zu schreiben besonders schwierig. Ich stieß dann aber
zufällig auf eine Schleife in meinem Programm die genau das Array ausgibt. Sie
ist mir nicht sofort aufgefallen da ich sie ans Ende des ActionListener gesetzt
habe. Ich nehme also die Schleife, schreib eine neue Aufgabe im ActionListener
und verbinde die Methode mit dem Button der die automatischen Aufgaben
bearbeiten soll. In der Methode stehen die Schleife und eine Ausgabe. Sie soll
die Pfade nacheinander ausgeben. Ich starte mein Programm und teste es. Heraus kommt
ein unverständlicher Zeichensatz. Das kommt mit bekannt vor und ich weiß, dass
ich die Ausgabe falsch geschrieben habe. Ich
hab geschrieben:
for (int i = 0; i < selectedFiles.length; i++)
System.out.println (selectedFiles.toString);
Und herauskam:
[Ljava.io.File;@146c1d4
[Ljava.io.File;@146c1d4
[Ljava.io.File;@146c1d4
[Ljava.io.File;@146c1d4
Also versuchte ich eine
andere Schreibweise um das Array auszugeben und finde die Lösung:
for (int i = 0; i < selectedFiles.length; i++)
System.out.println(selectedFiles[i]);
Das finde ich dann auch in
dem Code bei der ich die Schleife gefunden habe, ich habe sie nur übersehen.
Mit diesem Code werden nun endlich alle Pfade ausgegeben die ich ausgewählt
habe. Nun muss ich es irgendwie in meinen BufferedWriter einfügen.
Ich setze also die Schleife
in die Aufgabe ein indem die Batch Datei erstellt wird. Dann versuche ich wie
oben das Array auszugeben und verändere im out.write(„“) den Code. Es zeigt einen
Fehler an, also setze ich hinter dem selectedFiles[i] noch ein toString an. Der
Code sieht dann so aus(S.16):
out.write("XCOPY");
out.write("
"); out.write(selectedFiles[i].toString());
out.write("
");
out.write(jtfName2);
out.write("
");
out.write("/Y");
out.write("
");
out.write("/E");
out.write("
");
out.close();
Ich teste mein Programm und bekomme
einen Fehler beim Synchronisieren. Ich sehe mir die Batch an und stelle fest,
dass die Anführungszeichen nicht gesetzt sind. Nun muss ich es schaffen dass,
die Anführungszeichen bei selectedFiles gesetzt werden. Ich nehme also die
Methode die beim anderen Pfad eingesetzt wird und versuche es so zu
bewerkstelligen. Zu meiner Überraschung funktioniere es und mein Code sieht
dann so aus:
out.write("XCOPY");
out.write("
"); out.write("\""+selectedFiles[i]+"\"");
out.write("
");
out.write(jtfName2);
out.write("
");
out.write("/Y");
out.write("
");
out.write("/E");
out.write("
");
out.close();
Das toString kann ich nun
weglassen da dieser Code auch ohne funktioniert.
Jetzt nochmal testen. Ich nehme
mehrere Ordner und eine Textdatei als Kopiertest. Zu meiner Überraschung wird
alles kopiert. Ich teste mit mehreren Ordnern und Dateien. Es funktioniert
wieder. Dann wähle ich nur einzelne Ordner und Dateien aus. Die Überraschung: es
wird wieder alles kopiert obwohl ich den Inhalt des Zielpfades immer lösche.
Ich habe mir die Batch Datei vor lauter Testen nicht angeschaut und als ich sie
mir ansehe war ich zuerst verwirrt. Dort steht die letzte Auswahl, in diesem
Fall die Textdatei. Mir wird klar, dass ich die Schleife falsch gesetzt habe
und deswegen hat mein Programm immer eine neue Batch Datei für einen neuen Pfad
geschrieben und die alte Batch überschrieben. Der letzte Pfad, in diesem Fall
die Textdatei, steht deswegen in der Batch und nach manuellem Starten der Batch
finde ich folgendes heraus: Wird beim XCOPY Befehl eine Datei kopiert, wird der
komplette Ordnerinhalt indem sich die Datei befindet kopiert. Das sagt mir nur,
dass ich mit meinem Programm keine einzelne Dateien und/oder bestimmte Dateien
mit Endungen kopieren kann. Ich nahm diese Erkenntnis an und programmiere
weiter.
Da die Schleife immer eine
neue Batch schreibt, habe ich mein Programm so programmiert das auch
entsprechend viele Batches geschrieben werden sollen, sprich bei z.B. 5
ausgewählten Ordnern sollen 5 Batch Dateien entstehen mit dem entsprechenden
Kopierbefehl. Die Batches heißen dann: „test1, test2, test3,…“ usw. Nun setzt
ich auch eine Schleife beim Code, der die Batch Dateien startet. Als das
erledigt ist teste ich mein Programm und es funktioniert. Ich stelle aber fest,
dass sehr viele Batch Dateien erstellt werden und es viel effektiver wäre, dass
alle Pfade in einer Batch Datei geschrieben werden.
Ich versuche die Schleife
richtig zu setzen damit dies auch funktioniert. Ich weiß auch wo sie hin muss
aber es klappt nicht, da der out.close(); Befehl dazwischenfunkt und auch immer
wieder dafür sorgt, dass eine neue Batch Datei erstellt wird. Die Lösung ist,
dass ich die geschweifte Klammer falsch gesetzt habe. So sah
dann mein neuer BufferedWriter aus:
for (i = 0; i < selectedFiles.length; i++)
{
out.write("XCOPY");
out.write(" "); out.write("\""+selectedFiles[i]+"\"");
out.write(" ");
out.write(jtfName2);
out.write(" ");
out.write("/Y");
out.write(" ");
out.write("/E");
out.write(" ");
out.newLine();
}
out.close();
Der Befehl out.newLine();
erzeugt einen neuen Absatz damit der Befehl nicht in einer einzige Reihe
geschrieben wird. Die Schleife zählt i solang hoch bis sie nicht mehr kleiner
ist als die Zahl der ausgewählten Ordner ist.
Nach einem schnellen Test
sehe ich - es funktionierte. Alle Pfade werden richtig in die Batch Datei
geschrieben und jeder neue Kopiervorgang steht in einer neuen Zeile. Somit habe
ich das Schleifenproblem geschafft und kann mich um die Zusatzfeatures kümmern,
die der Nutzer einstellen kann.
12. Zusatzfeatures
Die Zusatzfeatures sind wie
ich schon oben beschrieben habe, Aufgaben, die während dem Kopiervorgang
gemacht werden, z. B. wenn am Ende des Befehls /C eingesetzt wird, wird auch
weiterkopiert wenn Fehler auftreten. Oder wenn man /H einsetzt werden auch
versteckte Dateien kopiert. Diese in meinen BufferedWriter zu schreiben war
einfacher als erwartet. Die GUI allerdings muss ich auch erweitern und ein
neues Layout hinzufügen. Ich entscheide mich JCheckBox zu verwenden. JCheckBox
wird in Form eines Kästchens und einem Text ausgegeben. Der Nutzer kann nun ein
Kästchen anklicken und es ist ausgewählt.
Für die GUI habe ich ein GridLayout
genommen. Dieses Layout ordnet seine Komponenten in einem Gitter an.
Mit der folgenden Anweisung
wird ein GridLayout mit null Spalten und einer Zeile angelegt.
JPanel
checkPanel = new JPanel(new GridLayout(0, 1));
Die Kästchen mitsamt Text
werden so von oben nach unten ausgegeben. So sieht der Quelltext aus wie die
JCheckBox angelegt wird:
JCheckBox
copyfehl = new JCheckBox ("Fehler?");
copyfehl.addActionListener(this);
copyfehl.getActionCommand();
copyfehl.setToolTipText("Kopiert
trotz Fehler weiter.");
checkPanel.add(copyfehl);
Die
erste Zeile legt die JCheckBox mit dem Text „Fehler?“ an. Die zweite fügt ihn
in den ActionListener hinzu. Die Dritte Zeile gibt an dass ich die JCheckBox im
ActionListener mit dem Namen Der JCheckBox anwählen kann. Die vierte Zeile gibt
einen Text an wenn der Mauszeiger über der JCheckBox ist.
Abbildung 7
Die Letzte Zeile fügt die
JCheckBox in das Layout ein und ist dann sichtbar.
Ich habe 2 Zusatzfeatures
und einen zusätzlichen Befehl für die Batch genommen, die mithilfe der JCheckBox
ausgewählt werden können. Die Zusatzfeatures sind die, die ich vorher als
Beispiel genannt habe. /C und /H. Der zusätzliche Befehl ist dafür da, dass das
Quellverzeichnis nach dem kopieren gelöscht wird.
Da ich nicht weiß wie ich
überprüfen kann, ob die Kästchen ausgewählt sind oder nicht, habe ich mir was
einfallen lassen und folgendes in den ActionListener geschrieben:
if(e.getActionCommand() == "Löschen?")
{
copylösch1=1;
}
if(e.getActionCommand() == "Fehler?")
{
copyfehl1=1;
}
if(e.getActionCommand()
== "Versteckte Dateien?")
{
copyhide1=1;
}
Diese 3 if Anweisungen sind
die Zusatzfeatures und wenn die JCheckBox ausgewählt wird, wird der
entsprechende int Wert auf 1 gesetzt. Dann habe ich noch im BufferedWriter etwas
ergänzt. Mit einer if Anweisung wird überprüft, ob das entsprechende
Zusatzfeature ausgewählt ist oder nicht. Sollte es ausgewählt sein wird dann
entsprechend die Batch Datei um die Befehle erweitert. Der
Fertige BufferedWriter sah dann so aus(S.20):
out
= new BufferedWriter (new FileWriter("M:/test.bat"));
for (i = 0; i < selectedFiles.length; i++)
{
out.write("XCOPY");
out.write(" ");
out.write("\""+selectedFiles[i]+"\"");
out.write(" ");
out.write(jtfName2);
out.write(" ");
out.write("/Y");
out.write(" ");
out.write("/E");
out.write(" ");
if(copyfehl1 == 1)
{
out.write("/C");
out.write(" ");
}
if(copyhide1 == 1)
{
out.write("/H");
out.write(" ");
}
if(copylösch1 == 1)
{
out.newLine();
out.write("rd");
out.write(" ");
out.write("\""+selectedFiles[i]+"\"");
out.write(" ");
out.write("/S");
out.write(" ");
out.write("/Q");
}
out.newLine();
}
out.close();
Der Batch Befehl „rd“ löscht
den Ordner der als Quelle ausgewählt wurde. Die Zusatzfeatures für diesen
Befehl /S und /Q sorgen dafür, dass der Ordner ohne Bestätigung gelöscht wird.
Somit wären die
Zusatzfeatures erst mal erledigt und ich kann nun an meinem Programm die Letzte
GUI programmieren
13.Die Letzte GUI
Meine GUI sah bis hierhin so
aus:
Abbildung 8
Da ich den Button
„Automatische Aufgaben bearbeiten“ nicht brauche habe ich ihn entfernt. Den
Text „Bitte Aufgabe auswählen“ ebenso, da ich ja nur noch einen Button in der
Oberen Leiste habe.
Für die große Lücke in der
Mitte meines Programms hab ich mir gedacht ich füg da einen Status Textfeld
ein. Der zeigt an wie der Nutzer das Programm richtig nutzt.
Deshalb habe ich dort eine JTextArea
eingefügt. Der Quelltext dafür sieht so aus:
1. auswahl1 = new
JTextArea(4,20);
2. auswahl1.setEditable(false);
3. auswahl1.setBorder(BorderFactory.createTitledBorder("Status"));
4. auswahl1.setLineWrap(true);
5. auswahl1.setWrapStyleWord(true);
6. auswahl1.setText("Bitte
zuerst Ordner oder Zielpfad auswählen.");
7. statusPanel.add(auswahl1, BorderLayout.CENTER);
1. Erstellt
die JTextArea
2. Man
kann in der JTextArea nichts reinschreiben
3. Fügt
den Text Status oben an die JTextArea an
4. Legt
fest, ob automatisch ein Zeilenumbruch gemacht wird
5. Legt
fest ob automatisch ein Wortumbruch gemacht wird, sofern automatischer
Zeilenumbruch vorhanden ist
6. Legt
den Text fest der angezeigt werden soll.
7. Fügt
die JTextArea in das entsprechende Layout ein
Danach habe ich mein
Programm so geändert, dass immer ein Text erscheint damit der Nutzer keine
Probleme bekommt. So wird z.B. der Text geändert wenn der Nutzer einen Ordner
ausgewählt hat. Außerdem zeigt er an, wenn man auf Synchronisieren klickt, ob
das Programm erfolgreich ausgeführt wird.
Als letztes habe ich noch
einen Button eingefügt der das Programm beendet und ein Button der alles
zurücksetzt damit man einen Neuen Kopiervorgang machen kann.
Meine letzte GUI sieht so
aus:
Abbildung 9
14.Das Problem des Einfrieren
Wie die Überschrift schon
sagt, hatte mein Programm ein Problem. Bei Kopiervorgängen kann es sein, dass
sich es Komplett aufhängt und es nicht mehr nutzen kann. Nur ein Beenden des
Prozesses in Eclipse beendet das Programm. Der Fehler liegt bei der Methode,
die die Batch Datei startet. Also muss ich eine andere Methode suchen. Ich entdeckte
eine und zwar dort wo ich die erste Methode zum Aufrufen fand. Diese übernehme
ich schnell, füge sie da ein wo meine alte Methode steht, füge eine try/catch
Anweisung ein und teste es. Zu meinem Glück funktioniert es. Als Zusatz gibt
die Methode den Inhalt der Batch in Eclipse wieder. Diesen sieht der Nutzer
jedoch nicht.
Nach mehreren erfolgreichen
Testdurchläufen, auch mit größeren Dateien, war das Problem des Einfrierens nun
gelöst.
15.Ein letzter Fehler und Änderungen
Einen fatalen Fehler hab ich
als letztes noch entdeckt als ich mir den Quelltext angeschaut habe. Es geht um
die JCheckBoxen und wie sie im ActionListener geschrieben werden. Dort ist mir
aufgefallen, dass wenn man ein Kästchen auswählt wird der int Wert zwar auf 1
gesetzt, aber wenn man das Kästchen wieder deselektiert ist der Wert immer noch
1. Das wäre ein fataler Fehler. Wenn man z.B. aus Versehen auf Löschen klickt
und es wieder deselektiert, wird der Quellordner trotzdem gelöscht was ja nicht
gewollt ist.
Ich suche deshalb wieder
nach einer Lösung und finde den ITemListener. Dieser Listener ist was Ähnliches
wie der ActionListener nur, das er für die JCheckBox geeigneter ist. Doch auch
nach vielen rumprobieren klappt es nicht, obwohl ich sicher war, dass mein Code
funktionierte.
Also schrieb ich einen
simpleren Code mit if Anweisungen. Am Ende sieht mein neuer Quelltext für eine
JCheckBox, dann so aus:
if(e.getActionCommand() == "Löschen?")
{
if(l==0)
{
copylösch1=1;
l=1;
}
else
if(l==1)
{
copylösch1=0;
l=0;
}
}
Es funktioniert so: int l =
0; Wenn jetzt das Kästchen ausgewählt wird, wird geprüft ob l=0 ist. Wenn ja,
dann, ist der int Wert von copylösch1 = 1; Gleichzeitig wird der int Wert l auf
1 gesetzt. Wenn der Nutzer das Kästchen nun deselektiert, wird wieder geprüft
ob l=0 ist. Da l aber jetzt den Wert 1 hat wird der int Wert von copylösch1 und
l auf 0 gesetzt. Somit funktionierte die JCheckBox nun auch wieder.
Als kleinen Zusatz hab ich
mein Programm so geändert, dass man alle Knöpfe mit einer Tastenkombination
einzeln auswählen kann. Z.B. den Button „Ordner auswählen“ kann man mit der
Tastenkombination „Alt + O“ öffnen.
16.Schluss
Zum Schluss möchte ich sagen,
dass mir die Arbeit an diesem Projekt sehr gefallen hat. Anfangs war es noch
schwer richtig zu arbeiten, aber nach und nach wurde es immer interessanter. Am
Ende ist ein eigenes geschriebenes Programm herausgekommen, das in dieser
Dokumentation Schritt für Schritt beschrieben wurde.
17.Literaturverzeichnis
dpunkt.Verlag: Infos und
Beispiele über den JFileChooser. Online unter: , In
der Fassung vom Jahr 2002.
Oracle: Infos und Beispiele
über die verschiedenen Layouts in Java. Online unter:
Oracle: Infos und Beispiele
über die JCheckBox. Online unter:
Thomas Darimont: Beispiel
Code für das Ausführen einer Batch unter Java. Online unter: ,
Thread 8, in der Fassung vom 01.01.2007 17:12 Uhr.
global.hs-mittweida: Infos
und Beispiele über JTextArea. Online unter: ,
Verfasser und Erscheinungsdatum unbekannt.
Example Depot: Beispiel wie
man eine Datei schreibt. Online unter:
JavaDoc: Schreibweise für
die Mehrfachauswahl beim JFileChooser. Online unter:
18. Quelltext des Programms:
OrdnerSyncner.java
package ordnerSync;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.util.Scanner;
@SuppressWarnings("serial")
public class OrdnerSyncner extends JFrame implements ActionListener
{
int h=0;
int l=0;
int f=0;
int s=0;
int z=0;
int a=0;
int b=0;
private int copyfehl1=0;
private int copyhide1=0;
private int copylösch1=0;
private JButton zp1;
private JButton Sync;
private JButton DatOrd;
private JButton Neu;
private JButton end;
public String selectedFile1;
public JTextArea auswahl1;
public File auswahl2;
public JTextField jtfName;
public String jtfName2;
public String speicherort;
JCheckBox copyfehl;
JCheckBox copyhide;
JCheckBox copylösch;
String contentNameField;
JList selectedFilesList;
JLabel selectedFileLabel;
JLabel returnCodeLabel;
File[] selectedFiles = new File[0];
int cellWidth = 300;
DefaultListModel listModel;
public OrdnerSyncner()
{
super ("OrdnerSynchronisierer BETA");
super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
JPanel statusPanel = new JPanel(new
BorderLayout());
JPanel displayPanel = new JPanel();
displayPanel.setLayout(new
FlowLayout(FlowLayout.LEFT));
displayPanel.setBackground(Color.WHITE);
JPanel checkPanel = new JPanel(new
GridLayout(0, 1));
JPanel unterPanel = new JPanel();
unterPanel.setLayout(new
FlowLayout(FlowLayout.LEFT));
unterPanel.setBackground(Color.WHITE);
add(statusPanel, BorderLayout.CENTER);
add(checkPanel, BorderLayout.EAST);
add(unterPanel, BorderLayout.SOUTH);
add(displayPanel, BorderLayout.NORTH);
DatOrd = new JButton("Ordner auswählen");
DatOrd.setToolTipText("Mithilfe diesem Button Wählen sie den Quellordner
aus.");
DatOrd.setMnemonic(KeyEvent.VK_O);
Neu = new JButton("Neuer Kopiervorgang");
Neu.setToolTipText("Mit diesem Button starte sie einen neuen
Kopiervorgang.");
Neu.setMnemonic(KeyEvent.VK_N);
selectedFilesList = new JList();
JScrollPane sp = new JScrollPane(selectedFilesList);
sp.setBorder(BorderFactory.createTitledBorder("Ausgewählte
Ordner: "));
selectedFilesList.setFixedCellWidth(cellWidth);
statusPanel.add(sp, BorderLayout.WEST);
displayPanel.add(DatOrd);
displayPanel.add(Neu);
auswahl1 = new JTextArea(4,20);
auswahl1.setEditable(false);
auswahl1.setBorder(BorderFactory.createTitledBorder("Status"));
auswahl1.setLineWrap(true);
auswahl1.setWrapStyleWord(true);
auswahl1.setText("Bitte zuerst Ordner oder Zielpfad auswählen.");
statusPanel.add(auswahl1, BorderLayout.CENTER);
JCheckBox copylösch = new JCheckBox ("Löschen?");
copylösch.addActionListener(this);
copylösch.getActionCommand();
copylösch.setToolTipText("Löscht den Quellordner.");
copylösch.setMnemonic(KeyEvent.VK_L);
JCheckBox copyfehl = new JCheckBox ("Fehler?");
copyfehl.addActionListener(this);
copyfehl.getActionCommand();
copyfehl.setToolTipText("Kopiert trotz Fehler
weiter.");
copyfehl.setMnemonic(KeyEvent.VK_F);
JCheckBox copyhide = new JCheckBox ("Versteckte Dateien?");
copyhide.addActionListener(this);
copyhide.getActionCommand();
copyhide.setToolTipText("Kopiert auch Versteckte Dateien und Ordner.");
copyhide.setMnemonic(KeyEvent.VK_V);
checkPanel.add(copylösch);
checkPanel.add(copyfehl);
checkPanel.add(copyhide);
zp1 = new JButton("Zielpfad auswählen");
zp1.setToolTipText("Mithilfe diesem Button Wählen sie die Zieladresse
aus.");
zp1.setMnemonic(KeyEvent.VK_Z);
Sync = new JButton("Synchronisieren");
Sync.setToolTipText("Mithilfe diesem Button starten sie die
Synchronisation.");
Sync.setEnabled(false);
Sync.setMnemonic(KeyEvent.VK_S);
end = new JButton("Programm Beenden!");
end.setToolTipText("Programm schließen!");
end.setMnemonic(KeyEvent.VK_P);
DatOrd.addActionListener(this);
Neu.addActionListener(this);
zp1.addActionListener(this);
Sync.addActionListener(this);
end.addActionListener(this);
unterPanel.add(zp1);
JLabel jlbName = new JLabel ("Zielpfad:");
unterPanel.add(jlbName);
jtfName = new JTextField("", 20);
unterPanel.add(jtfName);
unterPanel.add(Sync);
unterPanel.add(end);
}
public void actionPerformed(ActionEvent e)
{
if(e.getActionCommand()=="Ordner auswählen")
{
JFileChooser fc1 = new
JFileChooser();
fc1.setMultiSelectionEnabled(true);
fc1.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
fc1.showDialog(this, "Auswählen");
selectedFiles = fc1.getSelectedFiles();
DefaultListModel listModel = new
DefaultListModel();
for (int i = 0; i
< selectedFiles.length; i++)
{
listModel.addElement(selectedFiles[i]);
selectedFilesList.setModel(listModel);
if(selectedFiles.length>0)
{
s=1;
}
}
if(s==1)
auswahl1.setText("Jetzt bitte den Zielpfad auswählen.");
if(s==1 && z==1)
{
Sync.setEnabled(true);
auswahl1.setText("Wollen sie das Quellverzeichnis Löschen nach dem Kopieren
wählen sie Rechts -Löschen-\n" +
"Sind
versteckte Dateien im Quellverzeichnis wählen sie -Versteckte Dateien-\nSollten
Fehler beim Kopieren passiert sein Wählen sie rechts -Fehler-");
}
}
if(e.getActionCommand()== "Zielpfad auswählen")
{
try
{
JFileChooser fc2 = new
JFileChooser();
fc2.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
fc2.showDialog(this, "Auswählen");
this.jtfName.setText(fc2.getSelectedFile().getAbsolutePath());
this.jtfName2 = jtfName.getText();
jtfName2= "\"" + jtfName2 + "\"";
}
catch(NullPointerException
e1)
{
System.out.println("");
}
z=1;
if(z==1)
auswahl1.setText("Jetzt bitte den/die Ordner auswählen.");
if(s==1
&& z==1)
{
Sync.setEnabled(true);
auswahl1.setText("Wollen sie das Quellverzeichnis Löschen nach dem Kopieren
wählen sie Rechts -Löschen-\n" +
"Sind
versteckte Dateien im Quellverzeichnis wählen sie -Versteckte Dateien-\nSollten
Fehler beim Kopieren passiert sein Wählen sie rechts -Fehler-");
}
}
if(e.getActionCommand()== "Neuer Kopiervorgang")
{
s=0;
z=0;
jtfName.setText("");
selectedFilesList.setListData(new String[]
{});
Sync.setEnabled(false);
auswahl1.setText("Bitte zuerst Ordner oder Zielpfad auswählen.");
}
if(e.getActionCommand()== "Programm Beenden!")
{
System.exit(0);
}
if(e.getActionCommand() == "Löschen?")
{
if(l==0)
{
copylösch1=1;
l=1;
}
else
if(l==1)
{
copylösch1=0;
l=0;
}
}
if(e.getActionCommand() == "Fehler?")
{
if(f==0)
{
copyfehl1=1;
f=1;
}
else
if(f==1)
{
copyfehl1=0;
f=0;
}
}
if(e.getActionCommand() == "Versteckte Dateien?")
{
if(h==0)
{
copyhide1=1;
h=1;
}
else
if(h==1)
{
copyhide1=0;
h=0;
}
}
if(e.getActionCommand()== "Synchronisieren")
{
for (int i = 0; i
< selectedFiles.length; i++)
{
BufferedWriter out;
try
{
out = new BufferedWriter (new
FileWriter("M:/test.bat"));
for (i = 0; i < selectedFiles.length; i++)
{
out.write("XCOPY");
out.write(" ");
out.write("\""+selectedFiles[i]+"\"");
out.write(" ");
out.write(jtfName2);
out.write(" ");
out.write("/Y");
out.write(" ");
out.write("/E");
out.write(" ");
if(copyfehl1 == 1)
{
out.write("/C");
out.write(" ");
}
if(copyhide1 == 1)
{
out.write("/H");
out.write(" ");
}
if(copylösch1 == 1)
{
out.newLine();
out.write("rd");
out.write(" ");
out.write("\""+selectedFiles[i]+"\"");
out.write(" ");
out.write("/S");
out.write(" ");
out.write("/Q");
}
out.newLine();
}
out.close();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
{
try{
File scripFile = new File("M:/test.bat");
ProcessBuilder processBuilder = new
ProcessBuilder(scripFile.getAbsolutePath());
processBuilder.directory(scripFile.getParentFile());
Process process = processBuilder.start();
Scanner scanner = new
Scanner(process.getInputStream());
while(scanner.hasNextLine())
{
System.out.println(scanner.nextLine());
}
scanner.close();
System.out.println(process.waitFor());
}
catch(IOException e1)
{
auswahl1.setText("Fehler beim Ausführen des Programms " + e1.getCause());
}
catch(InterruptedException e1)
{
auswahl1.setText("Fehler beim Ausführen des Programms " + e1.getCause());
}
auswahl1.setText("Das Programm wurde erfolgreich ausgeführt! \nUm einen neuen
Kopiervorgang zu Starten Klicken sie Bitte auf Neuer Kopiervorgang");
return;
}
}
}
public static void main(String[] args)
{
OrdnerSyncner hauptfenster = new OrdnerSyncner();
hauptfenster.setLocation(100, 100);
hauptfenster.setSize(750, 300);
hauptfenster.setVisible(true);
}
}