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.
Hallo zusammen,
ich wollte mal fragen welche(s) Pattern ihr für die GUI Entwicklung einsetzt?
Builder Pattern? Factorys? "Komponente extenden" (zB SuperButton extends JButton)? Scheiss-egal-hauptsache-es-klappt?
hey Handwerker, was setzt du alles für schicke Terrassen ein, Nägel, Hämmer, Sägen?
eine GUI ist ein Java-Programm und verwendet potentiell alles, mit selben Vor-/ Nachteilen wie überall anders auch
MVC ist ein Pattern welches man überwiegend nur in GUIs kennt
Genau, es geht mir in erster Linie um Desing patterns.
Ich will einfach mal nur wissen, was ihr so verwendet. Bzw wie ihrs einsetzt.
ZB sagt "man" ja, dass man eine Komponente nur extenden soll, wenn man zusätzliche Funktionialität einbaut, aber nicht um zB nur die Farbe zu ändern.
Wie löst ihr denn solche Fälle? (gut, anderes L+F verwenden ist natürlich eine Möglichkeit, aber das ist hier nicht gemeint).
Genau, es geht mir in erster Linie um Desing patterns.
Ich will einfach mal nur wissen, was ihr so verwendet. Bzw wie ihrs einsetzt.
ZB sagt "man" ja, dass man eine Komponente nur extenden soll, wenn man zusätzliche Funktionialität einbaut, aber nicht um zB nur die Farbe zu ändern.
Wie löst ihr denn solche Fälle? (gut, anderes L+F verwenden ist natürlich eine Möglichkeit, aber das ist hier nicht gemeint).
Ich schreibe gerade an einem E-Mail Client und nutze MVC und ich konnte meine Entscheidung nicht besser treffen. Es lässt sich so leicht erweitern: einfach ein neues Action Objekt anlegen, ein neuer Button und das Action Objekt daran binden. Fertig.
Zwar muss man erstmal das Modell umsetzen, aber einmal gemacht, spart man sich massig Zeit. Besonders praktisch: bei Teamarbeit können Mitglieder das Konzept fortsetzen ohne sich viel Gedanken um die Problembehandlung zu machen.
Hi Cole,
das hängt vermutlich auch von der Komplexität des Projekts ab. MVC finde ich für kleine Progrämmchen immer ziemlich überdosiert. Für große Sachen kommt man vermutlich nicht drum rum.
Die Frage ist halt dan was ist klein und bleibt das Programm klein?
Ehe du dich versiehst hast du einen 150000 Zeilen Moloch den du nur noch mit der Pinzette anfassen kannst...
welchen Sinn soll es haben zuerst die Design/ArchitekturPatterns auszuwählen um diese dann in die Anwendung zu pressen?
Wenn man gute Software entwickelt dann ergeben sich die DesignPatterns.
Implementiere ich die Anwendung mit vernünftiger Trennung zwischen UI/Model/Logik dann habe ich damit implizit schon eine Art MVC implementiert. Ob das nun MVC mittels Observer/Observable oder sonstwas ist macht keinen Unterschied.
Von eigenen UI-Toolkits halte ich gar nix. Meistens sind die Dinger nur dafür da um z.B. Daten besser an Controls binden zu können.
Oftmals wird sowas abgefackelt mittels irgendwelchen Interfaces..z.B:
Code:
public interface HasValue<T>{
public T getValue();
public void setValue(T value);
}
public interface HasMultipleValues<T>{
public Collection<? extends T> getItems();
public void setItems(Collection<? extends T> items);
}
class MyTextField implements HasValue<String>{...}
class MyCombo<T> implements HasValue<T>, HasMultipleValues<T>{...}
Finde ich nicht übermäßig schon und vor allem sehr wartungsintensiv.
Besser ist meiner Meinung nach diese Logik auszulagern in ein Bindingframework welches für verschiedene Komponenten weiß was es zu tun hat.
Code:
class ComboBoxBinding{
// weiß wie es die Daten in eine Combobox bekommt
// und auch wieder Daten zurückliefern kann
}
class MyApp{
MyModel model = new MyModel();
model.setPersonen(getPersonen());
UI myUI = new MyUI();
BindingHelper.addBinding(model, "personen", myUI, "comboPersonen.items");
}
class BindingHelper{
public void addBinding(Object source, String sourcePath, Object target, String targetPath){
...
}
}
BeansBinding macht das genau so. Größter Vorteil ist das die Bindings unabhängig von der UILibrary sind. Man kann auch von Swing auf SWT ändern oder das BindingFramework z.B. im Web verwenden.
Koppelt man die Logik an den UIToolkit muss man für jedes Framework (Swing, SWT, AWT, GWT...) eine Abstraktion schreiben - was in vielen Fällen gar nicht geht - siehe SWT und Vererbung (geht zwar aber sollte man unterlassen).
Ansonsten wüsste ich nicht was ich z.B. mit einem Factorypattern in der UI tun sollte?
Default werte schon vorher zu implementieren und nicht jedes mal den gleichen Code zu haben...
z.b. farben, layout sachen usw.
Wie gesagt kommt aufs Toolkit an, gibt viele sinnvolle sachen.
Außerdem gibts es sehr wohl Berechtigungen für eigene Textfelder z.B. wenn man ein Bild im Textfeld haben will oder immer gleiche Suchfunktionen.
Sobald man das Widget mehrmals verwendet, sollte man sich etwas überlegen wie man es einfach wiederverwenden kann. Ob dann über Vererbung, Beziehung, Eigene Komponente usw. muss dann abgewägt werden.
Den Einsatz von einem Builder, kann auch recht interessant sein.
Java:
class ButtonBuilder{
Color background = null;
public ButtonBuilder setBackground(Color color){
background = color;
return this;
}
}
//dann per Vererbung oder Factory
class MyButton extends JButton{
public MyButton(ButtonBuilder builder){
if(builder.background!=null){
this.setBackground(builder.background);
}
}
}
public static JButton createButton(ButtonBuilder builder){
JButton button = new JButton();
if(builder.background!=null){
button.setBackground(builder.background);
}
return button;
}
ButtonBuilder builder = new ButtonBuilder().setBackground(Color.BLUE).setBackground(Color.BLACK);
JButton save = createButton(builder);
JButton cancel = createButton(builder);
Das erinnert mich irgendwie an das GridBagLayout und die Verwendung von GridbagConstraints (Builder) der beim Hinzufügen von Komponenten immer mitgegeben wird.
