[java] actions, waar klasse te plaatsen

[robbert]

Na een tijdje niks gedaan te hebben met java ben ik weer eens wat gaan proberen met java en swing.
Erg veel voorbeelden in boeken en op internet gebruiken button.addactionlistener(this), en dan bij actionPerformed checken met getSource waar de action vandaan komt. Dit vond ik direct al erg smerig, want als je een wat grotere gui hebt met veel knoppen krijg je daar een ontzettend lange lijst met if'jes.
Maar naar wat zoeken op got vond ik actions. Voorbeeld

Java:

OpenAction openAction = new OpenAction("Open", null, "Open a file", new Integer('O'));
JButton open = new JButton(openAction);
.........................
class OpenAction extends AbstractAction {
    public OpenAction(String text, ImageIcon icon,
                      String desc, Integer mnemonic) {
        super(text, icon);
        putValue(SHORT_DESCRIPTION, desc);
        putValue(MNEMONIC_KEY, mnemonic);
    }

    public void actionPerformed(ActionEvent e) {
        System.out.println("Actie!");
    }
}

Dit werkt aanzich goed, maar er zijn 2 dingen die ik me afvraag.
Waar ga ik al deze klassen neerzetten? Moet ik elke klasse in een eigen bestand zetten en eventueel al deze bestanden in een package? Of is er iets gemakkelijkers? Ik las in een topic [rml]mbravenboer in "[ Java] ActionListeners vs Action"[/rml] iets over een controller, maar daar begreep ik helaas niet veel van.
Als tweede, op deze manier moet je bij elke class

Java:

public OpenAction(String text, ImageIcon icon,
                      String desc, Integer mnemonic) {
        super(text, icon);
        putValue(SHORT_DESCRIPTION, desc);
        putValue(MNEMONIC_KEY, mnemonic);
    }

neer zetten (uiteraard wel de goede naam voor de constructor), kan dat ook niet gemakkelijke? Nu heb je dadelijk tientallen keren bijna het zelfde stukje code.
Ik kon hier verder niet veel over vinden op got, ook niet met google, verder als de standaard voorbeeldjes kwam ik niet.

[Alarmnummer]

robbertkrebbers schreef op 21 oktober 2004 @ 11:23:
Waar ga ik al deze klassen neerzetten? Moet ik elke klasse in een eigen bestand zetten en eventueel al deze bestanden in een package?

Ik maak er bijna altijd innerclasses van. Hou je je shit een beetje bij elkaar en heb je minder programmeer overhead. Verder hebben innerclasses volledige toegang tot de class waar ze in zitten, dus je hoeft niet de internals van je gui publiekelijk te maken of mee te geven.

[ Voor 21% gewijzigd door Alarmnummer op 21-10-2004 11:32 ]

[Alarmnummer]

Java:

public OpenAction(String text, ImageIcon icon,
                      String desc, Integer mnemonic) {
        super(text, icon);
        putValue(SHORT_DESCRIPTION, desc);
        putValue(MNEMONIC_KEY, mnemonic);
    }

neer zetten (uiteraard wel de goede naam voor de constructor), kan dat ook niet gemakkelijke? Nu heb je dadelijk tientallen keren bijna het zelfde stukje code.

Je kan natuurlijk wel een gemeenschappelijke superclass maken die zelf de description en de mnemonic invult (zoals hierboven). Abstract classes zijn ideaal om dit soort overeenkomstig gedrag in te bundelen.

[Robtimus]

Sterker nog, dan kun je anonieme classes gebruiken voor het echte werk.

Java:

abstract class MyAction extends AbstractAction
{
    public MyAction(String text, ImageIcon icon, String desc, Integer mnemonic)
    {
        super(text, icon);
        putValue(SHORT_DESCRIPTION, desc);
        putValue(MNEMONIC_KEY, mnemonic);
    }
}

...

JButton open = new JButton(
    new MyAction("Open", null, "Open a file", new Integer('O'))
    {
        public void actionPerformed(ActionEvent e)
        {
            System.out.println("Actie!");
        }
    }
);

Je creeert zo een subclass van MyAction zonder een aparte declaratie nodig te hebben. Ik bedoel, waarom een hele class maken die je op maar 1 plek gebruikt?
Dus als je bv 15 knoppen hebt creeer je maar 1 echte class (MyAction) en de rest gebruik je zoals hierboven op de plek waar je hem nodig hebt.

[ Voor 34% gewijzigd door Robtimus op 21-10-2004 12:02 ]

[Alarmnummer]

IceManX schreef op 21 oktober 2004 @ 11:59:
Sterker nog, dan kun je anonieme classes gebruiken voor het echte werk.

Als die syntax niet zo enorm kut was, en je weinig logica in je actions hebt staan, dan was dat wel een goeie oplossing. Helaas is de syntax kut en heb je wel vaak redelijk wat logica erin staan... dus ik heb mijn twijfels erover.

[Robtimus]

Dat je de syntax kut vindt is jouw mening, ik heb er totaal geen problemen mee.
Wat die logica betreft, zodra het te groot is maak ik het juist een private method van de omliggende class.
Voorbeeldje:

Java:

// initializer
    open = new AbstractAction("Open...")
    {
        public void actionPerformed(ActionEvent e)
        {
            open();
        }
    };

...

private void open()
{
    ....
}

Die open functionaliteit vind ik nml bij de class zelf horen, niet per se bij de actie.

[Alarmnummer]

IceManX schreef op 21 oktober 2004 @ 12:11:
Die open functionaliteit vind ik nml bij de class zelf horen, niet per se bij de actie.

Hmmm tja... vanuit een andere plek zul je het waarschijnlijk toch niet aanroepen... dus ik heb er geen problemen mee om gewoon een innerclass te maken.

[Macros]

En ik gebruik inner classes als de functionaliteit te groot wordt en anonymous classes als het maar een klein regeltje is. Per intstantie gebruik ik de meest handige methode. 99% van de tijd implementeer ik ActionListener ipv. een Action subclassen.

[Verwijderd]

Persoonlijk doe ik (bijna) altijd gewoon this. Maar innerclasses zijn ook wel zo netjes. Zeker als het enorm veel code betreft en je er een beetje structuur in wilt houden.

Iets anders zou ik eignelijk gewoon niet doen, want dan wordt het echt weer een appart object binnen je klassediagram en eigenlijk hoort het gewoon bij die klasse (vind ik)