Aloha , ich hätte da eine kleine Frage, wie realisiere ich bei folgender Situation am geschicktesten das EventHandling für Komponenten welche in den statischen hilfsmethoden deklariert werden ?!
Übergabe eines ActionListeners als Parameter ?!
Factory :
Verwendung der Factory :
und wenn ja , Schreibe ich dann am besten eine Innere Klasse die sich um die Eventbehandlung kümmert ? eine Eigene Klasse ? oder implementiere ich einfach einen ActionListener im Installer ?
Oder sollte ich vielleicht die erzeugung der einzelnen "cards" ( JPanel ) in separate Klassen auslagern, welche dann dort Referenzen auf ihren Inhalt halten ?
also Sprich :
und diese dann einfach im Installer instanzieren ? bzw. sollte ich dann nicht den Schritt gehen und UserCard von JPanel ableiten ? ( an sich ist es ja ein Container der daten enthält )
und dann beim eigentlichen Aufruf
so könnte ich mir dann auch die Factory sparen um das "komplizierte" Objekt zu konstruieren , und habe kein Problem an die enthaltenen Komponenten zu gelangen , bzw. muss ich nicht den weg über
gehen...
[EDIT]
Die einzelnen Karten enthalten später Content wie z.B JTextFields oder auch einen JFileChooser, da ich ja an inhalte, bzw. Texteingaben kommen muss stellt sich mir die Frage ob das mit Statischen hilfsmethoden nicht vielleicht eine eher schlechte idee wäre .
[/EDIT]
ich dachte da Quasi an sowas in der Art :
und dann um an den input der TextFelder zu gelangen
:toll:
Übergabe eines ActionListeners als Parameter ?!
Factory :
Java:
public class CardFactory {
public CardFactory(){}
public static JPanel createWelcomeCard(){
JPanel panel = new JPanel();
//TODO
return panel;
}
public static JPanel createUserCard(){
JPanel panel = new JPanel();
//TODO
return panel;
}
public static JPanel createRootCard(){
JPanel panel = new JPanel();
//TODO
return panel;
}
public static JPanel createCompanyCard(){
JPanel panel = new JPanel();
//TODO
return panel;
}
public static JPanel createDisclaimerCard(){
JPanel panel = new JPanel();
//TODO
return panel;
}
}Verwendung der Factory :
Java:
public class Installer{
private JFrame frame;
private JPanel contentPane;
private JPanel btnPane;
private JPanel[] cards;
private InstallerModel model;
final Dimension btnSize = new Dimension(125,25);
final Dimension frameSize = new Dimension(600,450);
public Installer() {
this.model = new InstallerModel();
initComponents();
addComponents();
}
private void initComponents(){
frame = new JFrame(INSTALLER_TITLE);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setSize(frameSize);
frame.setLocationRelativeTo(null);
contentPane = new JPanel(new CardLayout());
contentPane.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
btnPane = createBtnPane();
cards = new JPanel[5];
cards[0] = CardFactory.createWelcomeCard();
cards[1] = CardFactory.createUserCard();
cards[2] = CardFactory.createRootCard();
cards[3] = CardFactory.createCompanyCard();
cards[4] = CardFactory.createDisclaimerCard();
}
private void addComponents(){
addCards(cards);
getFrame().add(BorderLayout.CENTER, contentPane);
getFrame().add(BorderLayout.PAGE_END, btnPane);
}
private JPanel createBtnPane(){
JPanel panel = new JPanel();
return panel;
}
private void addCards(JPanel...cards){
for (JPanel card : cards) {
contentPane.add(card);
}
}
public void setVisible(){
frame.setVisible(true);
}
public JFrame getFrame() {return this.frame;}
public InstallerModel getModel() {return this.model;}
}und wenn ja , Schreibe ich dann am besten eine Innere Klasse die sich um die Eventbehandlung kümmert ? eine Eigene Klasse ? oder implementiere ich einfach einen ActionListener im Installer ?
Oder sollte ich vielleicht die erzeugung der einzelnen "cards" ( JPanel ) in separate Klassen auslagern, welche dann dort Referenzen auf ihren Inhalt halten ?
also Sprich :
Java:
public class UserCard{
JPanel panel;
//...usw
}und diese dann einfach im Installer instanzieren ? bzw. sollte ich dann nicht den Schritt gehen und UserCard von JPanel ableiten ? ( an sich ist es ja ein Container der daten enthält )
Java:
public class UserCard extends JPanel{
//...usw
}und dann beim eigentlichen Aufruf
Java:
cards[0] = new UserCard();so könnte ich mir dann auch die Factory sparen um das "komplizierte" Objekt zu konstruieren , und habe kein Problem an die enthaltenen Komponenten zu gelangen , bzw. muss ich nicht den weg über
Code:
userCard.getComponents();[EDIT]
Die einzelnen Karten enthalten später Content wie z.B JTextFields oder auch einen JFileChooser, da ich ja an inhalte, bzw. Texteingaben kommen muss stellt sich mir die Frage ob das mit Statischen hilfsmethoden nicht vielleicht eine eher schlechte idee wäre .
[/EDIT]
ich dachte da Quasi an sowas in der Art :
Java:
public class UserCard extends JPanel {
private static final long serialVersionUID = 1L;
JTextField[] fields;
JLabel[] labels;
String[] input = {"Vorname / Nachname :","Strasse / Nr. :","Plz. / Ort :","Tel. / Fax : ", "Email :"};
GridBagConstraints g = new GridBagConstraints();
public UserCard() {
initComponents();
addComponents();
}
private void initComponents(){
getCard().setLayout(new GridBagLayout());
fields = new JTextField[9];
labels = new JLabel[5];
for (int i = 0; i < labels.length; i++) {
labels[i] = new JLabel(input[i]);
}
for (int i = 0; i < fields.length; i++) {
fields[i] = new JTextField();
fields[i].setColumns(10);
}
}
private void addComponents(){
g.gridx = 0;
g.gridy = 0;
getCard().add(labels[0], g);
g.gridx = 0;
g.gridy = 1;
getCard().add(fields[0], g);
//...usw usw...
}
public JTextField getTextField(int i){
return fields[i];
}
public JPanel getCard() {return this;}
}und dann um an den input der TextFelder zu gelangen
Java:
userCard.getTextField(2).getText();:toll:
Zuletzt bearbeitet:
