Vererbung Strukturierung

[kaoZ]

Nabend, ich hab grade ein kleines Strukturierungsdilema, und brauch mal einen Tipp....

Folgende Situation:

Ich habe mehrere unabhängig voneinander agierende Views, für Setup, Main, das Anlegen neuer Kunden usw.

Zudem noch Views welche als Komponenten später in Bereichen der Frames dargestellt werden ( diese erben aber alle von JPanel , demnach also kein Problem )

meine überlegung war das ich entweder eine Abstrakte Basisklasse nutze und alle Frames von dieser ableite, oder ein Interface welches die benötigten Methoden anbietet, sprich

init();
addComponents();
showView();

usw.....

oder vielleicht eine Kombination aus Interface und Abstrakter Basisklasse die dann z.B JFrame erweitert und das Interface erfüllt, und schon überladene Konstruktoren anbietet, so muss ich allerdings in jeder Klasse wieder einen Konstruktor anbieten welche den jeweiligen Superkonstruktor aufruft.....aber kann gleichzeitig flexibel bleiben da ich nicht in jeder klasse alle Methoden des Interfaces erfüllen muss,

wie würdet ihr es Strukturieren ? Vererbung ? Komposition ? gegen ein Interface oder eine Abstrakte Basisklasse programmieren ?

 

[kaoZ]

Ok, anscheinend muss ich das ganzen noch etwas konkretisieren .....

mein Ansatz war folgender :

Abstrakte Basisklasse

Spoiler: AbstractView

public abstract class AbstractView extends JFrame{

	private static final long serialVersionUID = 1L;

	public AbstractView() {}
	
	public AbstractView(String title, int width, int height, int defaultCloseOperation){
		super(title);
		super.setSize(width, height);
		super.setDefaultCloseOperation(defaultCloseOperation);
	}
	
	public void showView() {
		super.setVisible(true);
	}
}

hier ein Auszug der Unterklassen ( noch nicht vollständig ausprogrammiert , nur zum testen):

Spoiler: SetupView

public class SetupView extends AbstractView{
	private static final long serialVersionUID = 1L;
	
	public SetupView() {
		// TODO Automatisch generierter Konstruktorstub
	}
	
	public SetupView(String title, int x, int y, int close){
		super(title, x, y, close);
	}

}

Der Gedanke dahinter war das ich so unter anderem einen Konstruktor zur Verfügung stellen kann , welcher gleich das Elternelement übergibt oder dem ich direkt eine Position zuweisen kann , und ich später einfach z.B Dialoge so erzeugen kann

new DialogView("Ordnerauswahl", 200,300,2,mainView).showView();

Nun die Frage, macht sowas
sinn ? ist es zu Overnuked ? wäre ein Factory-pattern sinnvoller ?

Oder Vielleicht doch über ein Interface, welches dann Methoden bereitstellt zum initialisieren / einrichten des Frames und dies dann nicht über den Konstruktor machen ?

Bin über jeden Sinnvollen Tipp dankbar

[EDIT]Da ich vorhatte den Inhalt der einzelnen Frames durch Klassen zu realisieren die jeweils von JPanel abgeleitet werden wollte ich das ganze später wie ein Baukastensystem nutzen können, und dem entsprechend bei erzeugen eines Frames einfach den Inhalt dem Konstruktor übergeben in etwa so:

new DialogView("Ordnerauswahl" 300, 250, 2, mainView, new DirChooseDialog()).showView();

[/EDIT]

 

[kaoZ]

Keiner ? 129 Views und nicht ein Vorschlag , was die sauberste Lösung wäre ? oder wie Ihr es umsetzen würdet ?! Ich bin erschüttert ^^

 

[Gucky]

Da sich die Views nicht allzusehr ähneln, würde ich das Interface bevorzugen.

 

[kaoZ]

Immerhin mal eine Antwort ^^

Also würdest du ein Interface bereitstellen welches von den einzelnen Views implementiert wird, meine Idee war das ich nicht in jeder Klasse eine Referenz auf ein JFrame halten muss wenn ich von JFrame ableite, und jeder Klasse einen Konstruktor bereitstelle welcher einfach den Konstruktor der Abstrakten basisklasse aufruft, sprich durch die einzelnen Ebenen calle, bis in der Basisklasse dann der Konstruktor von JFrame aufgerufen wird, ich war der Meinung so schenke ich mir die ganze Codeverdoppelung in den einzelnen Klassen, andererseits ist es wahrscheinlich ein grauen das ganze dann zu erweitern oder zu warten insofern ich mich auf Vererbung stütze, da ist wiederum ein Interface angenehmer

Oder halt wie schon gesagt die Mischung aus beidem, da in jeder Klasse die ein "Frame" darstellt ja immer die gleichen Methoden zur Verfügung stehen

init();
addComponents();
showView();

um nur 3 zu nennen.

 

[Gucky]

Ich hab mir das noch mal durch den Kopf gehen lassen und jetzt finde ich die abstrakte Klasse an. Da alle Views auch das Interface implementieren müssen, reicht die abstrante Klasse.

 

[kaoZ]

Wie ich sehe kannst du mein Problem bzw. meine zweifel an der Sache nachvollziehen , wäre natürlich geil wenn nochmal jemand der vielleicht Professionelle Swing Guis erstellt sein Senf dazu geben könnte :toll:

 

[Gucky]

Gibt es denn irgendwie eine Möglichkeit, wie das Interface oder die abstrakte Superklasse GETRENNT verwendet werden können? Sonst reicht, denke ich mal, die abstrakte Klasse. Die werden nicht umsonst "abstraktes Interface" genannt. (zumindest in C++)

 

[kaoZ]

Du meinst getrennt im Sinne von ? Ob z.B noch andere Klassen das Interface als Schnittstelle nutzen können ?

Ggf. hätte ich das Interface mit den 3 Initialisierungsmethoden dann auch für die Klassen die dann später den Inhalt für die Frames anbieten und von JPanel erben verwendet , insofern du das meinst.

Sprich :

public class SetupDialog extends PanelInput{

public SetupDialog(){...}

@Override
public void init(){...}

@Override
public void addComponents(){...}

/* Da die Superklasse das Interface Implementiert und diese Abstract ist, muss ich methoden die ich    
 * nicht benötige ja nicht überschreiben und brauch diese auch nicht zu implementieren, wie z.B hier 
 * showView(), diese Methode würde ich dann einfach nur leer in der Superklasse und nicht in den 
 * Subklassen implementieren. 
 */

//----------

@Override
public void showView(){...}

//-----------

}

Die Vererbungsherachie wäre dann z.B jeweils

JPanel <-- ABSTRACT PanelInput (implements Initialisable) <-- SetupDialog

[EDIT]Da ich mich vorher genau null mit Programmiersprachen außer Html beschäftigt habe kann ich dir nicht sagen ob es in C / C++ genauso ist ^^[/EDIT]

 

[Gucky]

Ich lerne grade C/C++, weshalb ich ein bisschen was weiß.



Ich meinte damit, dass es für mich keinen Sinn machen würde beides zu implementieren, wenn sie trotzdem nur gemeinsam benutzt werden können.



Und dann würde ich auch die abstrakte Klasse das Interface implementieren lassen, wenn es doch ein Interface sein soll.

 

[kaoZ]

Ich bin immernoch am Probieren und hab mich glaube ich dazu entschieden es jetzt folgendermaßen zu realisieren ( nach dem Factory Pattern ):

Spoiler: Factory

public class FrameFactory {

	JFrame frame;
	JPanel content;
	
	public FrameFactory() {
		frame = new JFrame();
		content = new JPanel();
	}
	
	public JFrame createFrame(String title, int width, int height, int closeOp, JFrame parent, JPanel content){
		frame.setTitle(title);
		frame.setSize(width, height);
		frame.setDefaultCloseOperation(closeOp);
		frame.setLocationRelativeTo(parent);
		
		if(content != null){
			this.content = content;
		}
		frame.add(this.content);
		
		return this.frame;
	}
	
	public void show(boolean value){
		frame.setVisible(value);
	}
	
	public static void main(String[] args) {
		FrameFactory fac = new FrameFactory();
		
		fac.createFrame("Test", 300, 150, 2, null, null);
		fac.show(true);
	}
}

ich spiele auch mit dem Gedanken es zu einer statischen Hilfsmethode zu machen, wobei ich noch nicht weiß wie ich dann das mit dem Initialpanel realisieren soll, wahrscheinlich müsste ich dann mit einem NULL-Objekt arbeiten um NPE's zu unterbinden.

Kritik und oder eventuellen Vorschlägen bin ich nicht abgeneigt ^^

[EDIT]Des ist noch nicht ganz ausgereift atm.... [/EDIT]

Ok ich muss das Konzept nochmal überarbeiten ^^ aber auf sowas in der Art wird es wohl hinauslaufen, das ich bereits eine gewisse Initialisierung im Konstruktor bereitstellen kann und nicht immer jeden setter aufrufen muss.

So ungefähr wird das dann später aussehen :

import javax.swing.JFrame;
import javax.swing.JPanel; 
import static constants.Constants.*;

public class EditorView {
	
	JFrame frame;
	JPanel panel;
	
	public EditorView() {
		frame = FrameFactory.createFrame(TITLE, SCREEN_WIDTH, SCREEN_HEIGHT, 2, null);
	}
	
	public void show(){
		frame.setVisible(true);
	}

	public static void main(String[] args) {
		new EditorView().show();
	}
}