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 Frage zur Vererbung bei der GUI Erstellung.
Meine Gui hat zwei Buttons, und jeder soll ein anderes JDialog Fenster öffnen. Diese Dialogfenster ähneln sich. Bzw das eine hat mehr Komponenten als das andere. Deshalb habe ich gedacht, macht Vererbung bestimmt Sinn.
Leider hab ich kein wirkliches Tutorial oder Beispiel für sowas gefunden.
In meinem bisher erstellen JDialog habe ich nun im Konstruktor eine private initComponents() sowie die private Eventhandlung Methoden.
Den Dialog erstelle ich also beim ActionEvent vom Buttonclick, und setze dort auch auf visible.
So, jetzt möchte ich mit dem zweiten Button aber einen zweiten/anderen JDialog erstellen können, und bei diesem noch einige Komponenten hinzufügen.
Kann ich dafür irgendwie die initComponents() der Elternklasse erben und weitere Elemente dort hinzufügen (irgendwie mit super())? Oder sollte ich besser die init Methode komplett überschreiben (dh den Code aus der Elternklasse dorthin kopieren + eben die zusätzlichen Komponenten an Ort und Stelle einfügen)?
Wie kann ich die bereits erstellten ActionPerformed Methoden meines ersten JDialogs in der Kindklasse verwenden? Muss ich sie dafür einfach public setzen und sie dann ganz normal wiederverwenden?
Irgendwie macht das alles einen Knoten in meinen Kopf :autsch:
Danke
Ja. Du kannst in der Sub die initComponents() überschreiben, und darin als erstes super.initComponents() aufrufen. Damit wird zuerst die der nächsthöheren Superklasse aufgerufen. Darunter machst du das, was du bei dem Dialog eben weiteres machen willst.
Ja, wenn er als Klassenvariable angelegt ist ginge das. Du übergibst ihn wie jede andere Instanz auch. Schöner fände ich persönlich aber eine Methode, die im Listener aufgerufen wird. Dann bist du nicht an die Action gebunden. Dafür würde ich aber für jeden Komponenten einen eigenen Listener erzeugen und die Methode aufrufen lassen. Ist zwar wartungstechnisch nicht soooo toll als nur eine Instanz, aber am Ende kann ich damit besser arbeiten als mit nur einen Listener.
Ja. Du kannst in der Sub die initComponents() überschreiben, und darin als erstes super.initComponents() aufrufen. Damit wird zuerst die der nächsthöheren Superklasse aufgerufen. Darunter machst du das, was du bei dem Dialog eben weiteres machen willst.
Das kann ich ja leider nicht. Zumindest ergibt es: initComponents() has private access in <ParentclassJDialog>
Aber da die private initComponents() in dem Konstruktor steht, wird sie dann nicht sowieso schon direkt aufgerufen, wenn ich den ChildJDialog erzeuge?
Ich versuch das gerade auch noch parallel im Netbeans Gui Editor umzusetzen. Dann wäre das mit dem positionieren der Zusatzelemente einfacher. Aber ich schaff es nicht dort eine Vererbung zu erzeugen. Wenn ich manuell extends im Code eintrage, bekomme ich im Visual Editor nur einen leeren Frame.
Wenn jemand weiß wie ich Visual Inheritance in Netbeans hinbekomme wäre ich echt dankbar...
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
public class Dialog1 extends JDialog implements ActionListener {
public Dialog1() {
setLayout(new GridLayout(1, 0));
initComponents();
makeItVisible();
}
private void makeItVisible() {
System.out.println("Make it visible");
pack();
setVisible(true);
}
private void initComponents() {
System.out.println("Add some components");
JButton button = new JButton("B1");
button.addActionListener(this);
add(button);
}
private void handleEvent() {
System.out.println("E1");
}
public void actionPerformed(ActionEvent e) {
handleEvent();
}
}
Java:
import java.awt.event.ActionEvent;
import javax.swing.JButton;
public class Dialog2 extends Dialog1 {
public Dialog2() {
super();
initComponents();
}
private void initComponents() {
System.out.println("Add more Components");
JButton button = new JButton("B2");
button.addActionListener(this);
add(button);
}
private void handleEvent() {
System.out.println("E2");
}
public void actionPerformed(ActionEvent e) {
handleEvent();
}
}
Ein kleines Beispiel und daraus resultierende Probleme.
Dialog1 ist straight Forward, ein einfacher Dialog mit einem Button der beim Drücken auf die Konsole E1 schreibt. Der ActionListener ist ein Bestandteil vom Dialog1.
Dialog2 erbt davon und soll einen weiteren Button hinzufügen. Das erste Problem ist, daß die Methode makeItVisible zu früh aufgerufen wird. Also bevor, der Dialog2 fertig initialisiert ist
Code:
Add some components
Make it visible
Add more Components
Daraus ergibt sich dann auch das das pack zu früh aufgerufen wird und die Buttons insgesamt zu schmal werden.
Das heißt, das beim Dialog2 nochmals sichergestellt werden muß, dass das pack() nochmals nach dem hinzufügen des zweiten Buttons geschehen muß.
Läßt man das ganze (Dialog2) laufen und clickt auf den zweiten Button, scheint alles in Ordnung. "E2" landet auf dem Terminal.
Drückt man nun Button1, erscheint auf der Konsole abermals E2 anstatt korrekterweise E1. Das ist weil durch die Vererbung auch der ActionListener vererbt und überschrieben wurde und die Referenz die an button1 geheftet wird nun auf den ActionListener, so wie er in Dialog2 definiert wurde zeigt.
Eine Lösung besteht nun dahingehend, dass man den ActionListenern eigene Klassen zugesteht, die dann nicht mitvererbt werden. Dies kann z.B. in einer inneren Klasse geschehen.
Oder aber, man geht hin und ruft in Dialog2#actionPerformed(AE e) mit super.actionPerformed(e), den ActionListener aus der Oberklasse mitauf. Das hätte allerdings zur Folge das auf der Konsole bei einem Klick E1 und E2 landen. Egal welcher Button gedrückt wird.
D. H. man müßte im ActionListener eine Unterscheidung einbauen, die erkennt welcher Button gedrückt wurde.
Die Variante mit der inneren Klasse gefällt mir hierfür am besten und würde dann so aussehen
Java:
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
public class Dialog1 extends JDialog {
public Dialog1() {
setLayout(new GridLayout(1, 0));
initComponents();
makeItVisible();
}
private void makeItVisible() {
System.out.println("Make it visible");
pack();
setVisible(true);
}
private void initComponents() {
System.out.println("Add some components");
JButton button = new JButton("B1");
button.addActionListener(new MyAL());
add(button);
}
private void handleEvent() {
System.out.println("E1");
}
private class MyAL implements ActionListener{
public void actionPerformed(ActionEvent e) {
handleEvent();
}
}
}
Das ganze ist aber immer noch zufriedenstellend. Zumindest für mich. Daher würde ich folgendes machen
Eine Klasse Dialog1 die von JDialog erbt und im Konstruktor DialogInhalte übergeben bekommt.
Die Inhalte werden nacheinander aufgerufen und zum Dialog hinzugefügt und dann angezeigt.
Java:
import java.awt.GridLayout;
import javax.swing.JDialog;
public class Dialog1 extends JDialog {
public Dialog1(DialogInhalt...inhalte) {
setLayout(new GridLayout(1,0));
for(DialogInhalt inhalt : inhalte){
inhalt.initComponents(this);
}
pack();
setVisible(true);
}
}
Das Interface für die einzelnen Inhalte sieht so aus
Java:
import javax.swing.JDialog;
public interface DialogInhalt {
public void initComponents(JDialog dialog);
}
Ein einfacher DialogInhalt
Java:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
public class DialogInhaltEinfach implements DialogInhalt{
public void initComponents(JDialog dialog) {
System.out.println("Add some components");
JButton button = new JButton("B1");
button.addActionListener(new MyAL());
dialog.add(button);
}
private void handleEvent() {
System.out.println("E1");
}
private class MyAL implements ActionListener{
public void actionPerformed(ActionEvent e) {
handleEvent();
}
}
}
und zusätzliche Funktionalität
Java:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
public class DialogInhaltErweiterung implements DialogInhalt{
public void initComponents(JDialog dialog) {
System.out.println("Add more Components");
JButton button = new JButton("B2");
button.addActionListener(new MyAL2());
dialog.add(button);
}
private void handleEvent() {
System.out.println("E2");
}
private class MyAL2 implements ActionListener {
public void actionPerformed(ActionEvent e) {
handleEvent();
}
}
}
Das ganze baut sich in einer Main wie folgt zusammen
Java:
public class Main {
public static void main(String[] args) {
new Dialog1(new DialogInhaltEinfach(),
new DialogInhaltErweiterung()
);
}
}
Aber am Schluß bleibt immer noch das Problem ein exaktes Layout zusammenzubekommen.Hier klappt das mit dem GridLayout noch einigermaßen, aber mit anderen Layouts kann das unendlich komplex werden.
Auf die Gefahr hin, dass ich mich gerade vollends irre: Nein?! Der wesentliche Unterschied zwischen einer Komposition und einer Vererbung ist, dass bei Letzterer dem Erben ein Typ mitgegeben wird. Wenn du Komposition und Vererbung durcheinanderwürfelst, darfst du dich nicht wundern, wenn plötzlich dein Haus woanders steht, bloß weil der dort ansässige Mensch Auto gefahren ist.
Außerdem kannst du mehrere Dinge des gleichen Typs aggregieren bzw. zur Komposition einsetzen, während du nur einmalig einen Typ erben kannst. Ansonsten müsste ja auch so was gehen wie [c]Auto extends Seitenspiegel,Seitenspiegel[/c] oder sogar [c]B extends A; C extends A,B[/c] (WTF, OO-Inzest ).
Da mir in Arks Post die Kurzzusammenfassung des Unterschieds von beidem fehlt:
Inheritance - Vererbung. Ist-ein Beziehung: Man Leitet seine Klasse von einer anderen Klasse ab und erbt somit alle non-private (und glaube non-static) Methoden. Das non-private is das für dich, membersound, entscheidende
Komposition. Hat-ein Beziehung: Mein Auto hat ein Nummernschild, also lege ich eine Instanzvariable vom Typ Nummernschild an, anstatt mein Auto von Nummernschild erben zu lassen. Weil ein Auto ist kein Nummernschild^^
Komposition. Hat-ein Beziehung: Mein Auto hat ein Nummernschild, also lege ich eine Instanzvariable vom Typ Nummernschild an, anstatt mein Auto von Nummernschild erben zu lassen. Weil ein Auto ist kein Nummernschild^^
Richtig ein Auto ist kein Nummernschild.
Ein Auto könnte von einem GegenstandMitNummernschild erben, da es ja ein Gegenstand mit Nummernschild ist. Das wäre dann der Fall mit Vererbung.
Auf die Gefahr hin, dass ich mich gerade vollends irre: Nein?!
Sorry, war eine kleine Verwechslung (Übersetzungsfehler), Inheritance ist Vererbung, Komposition ist Composition. Wenn man bei einer Suche Vererbung vs Komposition eingibt, kommt man auch zu Ergebnissen wie Inheritance vs Composition, daher die Verwechslung zur frühen Stunde.
Richtig ein Auto ist kein Nummernschild.
Ein Auto könnte von einem GegenstandMitNummernschild erben, da es ja ein Gegenstand mit Nummernschild ist. Das wäre dann der Fall mit Vererbung.
Wobei "GegenstandMitNummernschild" konzeptionell keine sauber definierte Superklasse für irgendwas ist, sondern eher die Erweiterung einer anderen Klassen mit zusätzlicher Funktionalität. Dieses Konzept wird gemeinhin auch als "Mixin" oder "Trait" bezeichnet. In Pseudocode:
Code:
class Auto extends Fahrzeug with HatNummernschild {
...
}
Das ist ja irgendwie eine endlose Frickelei, wenn ich wirklich die Komponenten des Dialogs vererben will. Ich glaub das mach ich besser einen eigenständigen und kopiere das meisten aus dem ersten.
Trotzdem würd ich ja gerne die nun public gesetzten Methoden, ActionPerformed usw des ersten Dialogs vererben.
Jetzt ist die Frage: Wie kann ich den JDialog extenden, um seine public Methoden zu vererben, aber den Aufruf der visuelle Methode initComponents() vermeiden? Die steht ja im Konstruktor des ersten Dialogs, und wird bei Subklassen somit ja zwangsweise aufgerufen, selbst wenn ich sie dort überschreibe...
/ok, ich denke eine abstrakte Klasse ist hier das Stichwort. Belehrt mich bitte falls es ne bessere Möglichkeit gibt.
).
