Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich habe eine kleine Schiffsimulation geschrieben, die mir z.B. ein "Ruderboot" erzeugen kann.
Ich hab das Ganze mit einer GUI gebaut und nun meine Frage:
Wenn ich auf den Button "Ruderboot" klicke so wird die Klasse "RuderbootAktion" ausgeführt. Da drinnen erstelle ich ein Objekt r1 mit Hilfe der Klasse "Ruderboot".
Und Methoden aus der Klasse "Ruderboot" rufe ich auch hier in der RuderbootAktion auf.
Ist das so der korrekte Weg?
Es funktioniert alles, nur frage ich mich das "OOP-konform" ist...
Vielen Dank für eure Tips/Verbesserungen etc....,
Peter
Java:
class RuderbootAktion implements ActionListener {
public void actionPerformed(ActionEvent arg0){
Ruderboot r1 = new Ruderboot();
r1.setKurs(" 'Nord-Nord-West' ");
r1.setaKanonen(1);
t1.setText(r1.bewegen()+"\n"
+r1.angreifen() +r1.getaKanonen()+" Kanone"+"\n"+
"Kurs ist "+r1.getKurs());
}
}
Ist das t1 ein Textfeld? Möglicherweise, wäre es noch ein bisschen schöner designed, wenn die Klasse RuderbootAktion kein GUI Element enthalten müsste. Aber schlimm ist das nun auch wieder nicht.
Vielleicht solltest du nicht sagen: "Die Klasse XY wird ausgeführt". Das tönt ein bisschen nach "static"
Sag doch einfach, "ein ActionListener" oder "eine RuderbootAktion" wird ausgeführt. Naja, bisschen Haarspalterei ^^
Naja, das ist grunsätzlich nicht ... "falsch".. oder so... aber es irritiert mich, dass dieses Obekt nur in der Action-Klasse existiert... wenn da noch irgendwo ein
[c]bootSimulator.addNewBoat(r1);[/c]
dabei stehen würde, würde mich das weniger irritieren...
Ich verstehe was ihr meint. Ich werd das die nächsten Tage umbauen und melde mich wieder, falls ich Probleme hab und natürlich wenn es funktioniert hat.
Ja, t1. sind Textfelder und ich werd versuchen sämtlichen GUI Code aus der ActionListener Klasse rauszubringen und auch die Methodenaufrufe.
Also ich habe jetzt weitergemacht und weiß, daß ich hiermit mit "Riesenkanonen auf Spatzen" schieße. Ich wäre aber trotzdem sehr dankbar, wenn sich das jemand ansehen könnte:
In meiner GUI habe ich einen Button:
Java:
b1 = new JButton("Ruderboot");
p1.add(b1);
und ein Textfeld, in dem ich als Benutzer die Anzahl der Kanonen angeben kann:
Java:
jt1 = new JTextField(2);
Ein Textfeld zur Ausgabe der Kanonenanzahl:
Java:
t1 = new JTextArea(20,30);
und auch einen ButtonListener registriert
Java:
b1.addActionListener(new ButtonListener(t1,jt1));
Nun habe ich eine eigene Klasse, BootSimulator, gebaut, die mir ein Ruderboot erzeugt:
Java:
public class BootSimulator {
JTextField jt1;
public BootSimulator(JTextField jt1){
this.jt1=jt1;
}
public Ruderboot BootSimulator(){
Ruderboot r = new Ruderboot(jt1.getText());
return r;
}
}
Und eine eigene ButtonListener Klasse:
Java:
public class ButtonListener implements ActionListener{
JTextField jt1;
JTextArea t1;
public ButtonListener(JTextArea t1, JTextField jt1){
this.t1=t1;
this.jt1=jt1;
}
public void actionPerformed(ActionEvent e){
BootSimulator b = new BootSimulator(jt1);
t1.setText(b.BootSimulator().getaKanonen());
}
}
Soweit funktioniert alles, ich gebe in der GUI z.B 10 für die Kanonenanzahl ins "jt1" JTextField ein und klicke auf den Button b1 Ruderboot und in der JTextArea wird auch 10 ausgegeben.
Nur sehe ich den Wald vor lauter Bäumen nicht mehr.
Also ich verstehe es so, daß BootSimulator mit
Java:
jt1.getText()
- also der eingabe der kanonenanzahl - mir ein Ruderboot "r" erstellt.
In der Klasse ButtonListener erzeuge ich eine Instanz von BootSimulator, nämlich "b" (was ja eigentlich mein Ruderboot r darstellt) und dann setze ich mit der Zeile
Java:
t1.setText(b.BootSimulator().getaKanonen());
die Kanonenanzahl aus "b" (eigentlich r) mit Hilfe der getaKanonen Methode aus der Klasse Ruderboot (hier nicht aufgeführt) in das JTextField.
Bin ich halbwegs verständlich, es funktioniert wie gesagt, aber ich weiß nicht ob hier andere Mechanismen am Werk sind, als die die ich oben beschrieben habe.
Ich weiß ich könnte ohne ein Objekt Ruderboot zu erzeugen auch den Wert aus dem Textfeld übernehmen, aber das wäre nicht der Sinn meiner Übung.
Wie gesagt ich wäre sehr dankbar für Rückmeldungen, Ziel der Übung war es die Instanzierung von Ruderboot aus der ActionListener-Klasse rauszubekommen, so wie Marco13 es vorgeschlagen hat.
Was du beschrieben hast klingt - soweit ich es nachvollziehen konnte - richtig.
Allgemein stellen sich mir auch solche Fragen, wie warum in der ActionPerformed jetzt ein neuer BootSimulator erstellt wird... Im Prinzip hast du ja jetzt - im Vergleich zum zuerst geposteten - nur den BootSimulator um das Boot drumrumgewickelt ... und im Endeffekt wird nichts gemacht, außer den Text vom einen TextField quer durch Simulator und Boot zu einem anderen TextField weiterzureichen... ???:L
Allerdings ist das strukturell nicht so schön...
Du hast noch nicht gesagt, was dein eigentliches Ziel ist. Aber ein wichtiges... "Paradigma" ist häufig, dass man Daten und ihre visuelle Repräsentation trennt. Das entspricht dann grob dem, was mit dem "Model-View-Controller" (MVC) Pattern gemeint ist: Es gibt ein Datenmodell, das bei dir z.B. den Zustand der Simulation beschreibt. Und davon unabhängig gibt es eine View (das GUI). Das wichtige ist dabei, dass das Modell die View NICHT kennt - also genau das Gegenteil von dem, was du gemacht hast, als du dem BootSimulator ein TextField übergeben hast Die View kennt aber das Modell, und zeigt dessen Daten an. Über Änderungen wird sie i.a. informiert, indem sie als Listener am Modell hängt (und eben NUR als Listener).
Ein bißchen unfundiertes Gelaber:
Überleg' dir (und beschreibe hier gegebenenfalls), was du machen willst - und ignoriere das GUI. (Ja, ignoriere das GUI - das sind nur ein paar TextFields und Buttons, mit solchen Trivialitäten sollte man sich nicht aufhalten )
Was willst du machen? Einen Bootsimulator schreiben. Welche Arten von Booten soll es geben? NUR Ruderboote? Vermutlich nicht. Vermutlich hast du mehrere Arten von Booten, die alle nur die Gemeinsamkeit haben, ein "Boot" zu sein .... Oder um aus dem Zaunpfahl mal einen ganzen Zaun zu machen:
Java:
abstract class Boot { ... } // ggf. sogar "interface Boot {...}"
class Ruderboot extends Boot { ... }
class Segelboot extends Boot { ... }
Was soll jedes einzelne Boot können? Wo können alle Boote gleich behandelt werden (also als "Boot") und wo muss man wirklich wissen, ob ein konkretes Boot ein RUDER- oder ein SEGELBoot ist?
Was soll der Bootsimulator genau können? (Heißt: Welche Methoden soll er haben?). Soll wirklich der Simulator die Ruderboote erstellen, oder soll er nicht einfach nur (abstrakte) Boote übergeben bekommen und die dann simulieren? Schreibe alle Methoden, die dein BootSimulator haben muss, in ein Interface, und schreibe die Methoden die die Boote haben müssen auch in interfaces (dabei wird erstmal noch keine Zeile "echter" Code geschrieben... nur "leere" Methoden).
Wenn du eine genaue Vorstellung davon hast, wie das Erstellen von Booten abläuft, was die Boote können, und was der Simulator genau kann, kannst du diese Funktionalität schonmal "prototypisch" implementieren und antesten
Vielen Dank für die Hilfe und die Erläuterungen. Ich war schon soweit, daß ich den Großteil ohne GUI hatte, ließ mich aber dann von der Idee eine GUI zu machen auf den falschen Pfad verleiten...
Tja, das Programm soll 3 Schiffstypen erzeugen und abhängig vom Typ unterschiedliche Parameter ausgeben und Methoden aufrufen und eine einfach Textausgabe machen.
Ich habe nun sogar ein Klassendiagramm gezeichnet (Screenshot anbei!) und alle Klassen mit Variablen und Methoden geschrieben.
Ich poste mal alles.
Alle Klassen erben Variablen und Methoden von der Superklasse "Boot". Die bewegen()-Methode wird jeweils überschrieben. Die Fregatte hat eine zusätzliche Variable und Methode.
Die Superklasse Boot:
Java:
public abstract class Boot {
private String laenge;
private int kanonenAnz;
//getter und setter
public String getLaenge(){
return laenge;
}
public void setLaenge(String l){
laenge = l;
}
public int getKanonenAnz(){
return kanonenAnz;
}
public void setKanonenAnz(int a){
kanonenAnz = a;
}
//weitere Methoden
public String bewegen(){
String x = "Boot setzt sich in Fahrt";
return x;
}
public String angreifen(){
String y = "Schiff attackiert mit "+kanonenAnz+" Kanonen";
return y;
}
}
Das Ruderboot:
Java:
public class Ruderboot extends Boot {
//bewegen überschreiben
public String bewegen(){
String x = "Rudert los!";
return x;
}
}
Die Fregatte:
Java:
public class Fregatte extends Boot {
private int musketenAnz;
//bewegen überschreiben
public String bewegen(){
String x = "Alle Fregattsegel setzen!";
return x;
}
//eigene Methode
public String ausMusketenSchiessen(){
String i = "Aus allen "+musketenAnz+" Rohren schiessen!";
return i;
}
}
Der Segler:
Java:
public class Segler extends Boot {
//bewegen überschreiben
public String bewegen(){
String x = "Alle Segel setzen und los!";
return x;
}
}
Ich muß jetzt noch die "BootSimulator"-Klasse schreiben mit der main() Methode, aber ich glaub das mach ich morgen, hab mir ein Bier verdient Ich hoffe du bist meiner Meinung
Naja, was heißt "falsch" - in der Beschreibung war das so betont, weil es sich eben häufig rächt, wenn man GUI und Modell vermischt. Man müßte erstmal wissen, was das ist, was du vor hast...
Mit meinem BootSimulator komme ich einfach nicht voran. Mir ist nicht klar wie ich eine Methode schreiben soll, die mir ein generisches Objekt Boot erstellt und wenn ich den BootSimulator instanziere ich z.B. ein Ruderboot erhalte??
Ich bin nach langem Herumprobieren auf den Code unten gekommen, aber er sagt nur, er kann das nicht instanzieren, da "Boot" ja eine abstrakte Klasse ist. Aber wie soll ich ein generisches Boot-Objekt erstellen, wenn die Klasse nicht instanzierbar ist?
Java:
public class BootSimulator {
public Boot fuegeBootHinzu(Boot boot){
return new Boot();
}
public static void main(String[] args) {
BootSimulator simulator = new BootSimulator();
simulator.fuegeBootHinzu(new Ruderboot(10));
}
}
Die Klasse "Ruderboot" habe ich übrigens um den Konstruktor erweitert, so benötige ich die Setter-Methode für die Kanonenanzahl nicht:
Java:
public Ruderboot(int kanonenAnz){
super.setKanonenAnz(kanonenAnz);
}
Ich komm nicht drauf wie ich die Methode "fuegeBootHinzu" schreiben muß, daß ich alle möglichen Arten von Booten/Schiffen erstellen kann???:L
Darf ich dich nochmals um einen Tipp bitten! Vielen Dank!
In der main hast du dein neues Ruderboot.
In dem fuegeBootHinzu bekommst du das Boot übergeben. Da brauchst du kein new mehr, dein BootSimulator muss sich nur das neue Boot merken (array, List, Map oder sonstwie). Und es ist ihm dann egal was für ein Boot es ist, es ist nur wichtig dass es ein Boot ist.
Achja, ist die Frage ob es so sinnvoll ist ein Boot beim fuegeBootHinzu zurückzugeben - entweder ein boolean (um anzuzeigen ob das Boot eingefügt wurde oder nicht) oder gar nichts.
Was sollte es denn anzeigen wenn ein Boot zurückgegeben wird?
Die Klasse "Ruderboot" habe ich übrigens um den Konstruktor erweitert, so benötige ich die Setter-Methode für die Kanonenanzahl nicht:
Java:
public Ruderboot(int kanonenAnz){
super.setKanonenAnz(kanonenAnz);
}
Naja
a) Du benutzt ja den setter, also brauchst du ihn auch
b) Die KanonenAnzahl kann sich ja mal ändern (wir packen noch 2 drauf, oder uns fällt mal eine ins Wasser bei ner zu scharfen Kurve)
Was soll der Bootsimulator genau können? (Heißt: Welche Methoden soll er haben?). Soll wirklich der Simulator die Ruderboote erstellen, oder soll er nicht einfach nur (abstrakte) Boote übergeben bekommen und die dann simulieren? Schreibe alle Methoden, die dein BootSimulator haben muss, in ein Interface...
Vielen Dank für die Erklärung zum Setter, ich hab den wieder eingefügt.
Nun habe ich die BootSimulator-Klasse wie folgt erstellt:
Java:
public class BootSimulator {
//lege Variable b vom Typ Boot fest
//erstelle eine ArrayList fuer die generischen Boote
Boot b;
ArrayList <Boot> boote = new ArrayList <Boot>();
//schreib das Boot-Objekt in die ArryList
//in der main-Methode wird mit dem Simulator ein konkretes Objekt(Ruderboot,...) erzeugt
public void fuegeBootHinzu(Boot b){
this.b = b;
boote.add(b);
System.out.println(b.getLaenge());
System.out.println(b.bewegen());
System.out.println(b.angreifen());
}
public static void main(String[] args) {
BootSimulator simulator = new BootSimulator();
simulator.fuegeBootHinzu(new Ruderboot(10, "10 Meter"));
simulator.fuegeBootHinzu(new Fregatte(20, "20 Meter"));
}
}
Die funktioniert soweit einwandfrei und gibt mir mal die Länge, die Bewegungsart und den Angriffsmodus aus, 1x fürs Ruderboot, 1x für die Fregatte:
10 Meter
Rudert los!
Ruderboot attackiert mit 10 Kanonen
20 Meter
Alle Fregattsegel setzen!
Fregatte attackiert mit 20 Kanonen
Eine Frage habe ich aber noch. Zuvor hatte ich nämlich die Klasse wie folgt aufgebaut. Da hatte ich eine Methode BootAktionen, die dann in der main-Methode aufgerufen wurde.
Java:
public class BootSimulator {
//lege Variable b vom Typ Boot fest
//erstelle eine ArrayList fuer die generischen Boote
Boot b;
ArrayList <Boot> boote = new ArrayList <Boot>();
//schreib das Boot-Objekt in die ArryList
//in der main-Methode wird mit dem Simulator ein konkretes Objekt(Ruderboot,...) erzeugt
public Boot fuegeBootHinzu(Boot b){
this.b = b;
boote.add(b);
return b;
}
public void bootaktionen(){
for(Boot boot : boote){
System.out.println(b.getLaenge());
System.out.println(b.bewegen());
System.out.println(b.angreifen());
}
}
public static void main(String[] args) {
BootSimulator simulator = new BootSimulator();
simulator.fuegeBootHinzu(new Ruderboot(10, "10 Meter"));
simulator.fuegeBootHinzu(new Fregatte(20, "20 Meter"));
simulator.bootaktionen();
}
}
Das seltsame hierbei ist, daß 2x eine Fregatte ausgegeben wird:
20 Meter
Alle Fregattsegel setzen!
Fregatte attackiert mit 20 Kanonen
20 Meter
Alle Fregattsegel setzen!
Fregatte attackiert mit 20 Kanonen
Aber mit meiner For-Schleife müßten ja wohl ein Ruderboot und eine Fregatte erzeugt werden ???:L Warum erzeugt die For-Schleife 2x das Gleiche, ich kapier das nicht.
Könnt ihr mir bitte bei der Frage nochmal helfen!
Und noch was: Wie wäre es besser die BootSimulator-Klasse zu schreiben? Ist die 1. Variante besser oder die 2.? Ich denke die 2. wäre besser, da die Ausgabe eigens in einer Methode steht...
Vielen Dank für eure Bemühungen,
Peter
Ich weiß, dieser Thread ist uralt und ich bin die letzten Monate fast gar nicht dazugekommen hier weiterzumachen (private Problemchen, Jobwechsel, ...). War nicht so fein...
Ich wollte nur sagen, dass ich meinen BootSimulator nun wie folgt aufgebaut habe:
Java:
public void erstelleNeuenSegler(){
Segler segler = new Segler();
segler.setKanonenAnz(5);
System.out.println(segler.bewegen());
System.out.println(segler.angreifen());
}
public void erstelleNeueFregatte(){
Fregatte fregatte = new Fregatte();
fregatte.setKanonenAnz(5);
fregatte.setMusketenAnzahl(20);
System.out.println(fregatte.bewegen());
System.out.println(fregatte.ausMusketenSchiessen());
System.out.println(fregatte.angreifen());
}
public void erstelleNeuesRuderboot(){
Ruderboot ruderboot = new Ruderboot();
ruderboot.setKanonenAnz(1);
System.out.println(ruderboot.bewegen());
System.out.println(ruderboot.angreifen());
}
und mit der Klasse "BooteErstellen" die einzelnen Typen von Booten erzeuge:
Java:
public class BooteErstellen extends BootSimulator {
public static void main(String[] args){
BooteErstellen boote = new BooteErstellen();
boote.erstelleNeueFregatte();
boote.erstelleNeuenSegler();
boote.erstelleNeuesRuderboot();
}
}
Das funktioniert auch recht gut so und ich werde da jetzt weitermachen...
Danke, ich werde mir das ansehen mit dem Interface. Die Boote werden da praktisch einer ArrayList hinzugefügt. Der Code sieht nicht sehr komplex aus, aber das mit der ArrayList muss ich mir erst genauer ansehen.
