[JAVA] Method doorgeven via parameter?

[chronozphere]

Hoi,

Ik ben begonnen met een JOGL tutorial, maar ik kom hier niet helemaal uit:

code:

    frame.setSize(300, 300);
    frame.setBackground(Color.WHITE);

    frame.addWindowListener(new WindowAdapter()
    {
        public void windowClosing(WindowEvent e)
        {
            System.exit(0);
        }
    });

Er word een nieuwe instantie van WindowAdapter gemaakt en doorgegeven aan addWindowListener(). Wat ik niet begrijp is wat die method definitie tussen accollades daar doet.

Wat gebeurd hier pricies? Heeft dit fenomeen ook een naam, dan kan ik even verder googlen.

Bedankt!

[momania]

good luck

[dominic]

chronozphere schreef op maandag 24 mei 2010 @ 14:46:
Hoi,

Ik ben begonnen met een JOGL tutorial, maar ik kom hier niet helemaal uit:

code:

    frame.setSize(300, 300);
    frame.setBackground(Color.WHITE);

    frame.addWindowListener(new WindowAdapter()
    {
        public void windowClosing(WindowEvent e)
        {
            System.exit(0);
        }
    });

Er word een nieuwe instantie van WindowAdapter gemaakt en doorgegeven aan addWindowListener(). Wat ik niet begrijp is wat die method definitie tussen accollades daar doet.

Wat gebeurd hier pricies? Heeft dit fenomeen ook een naam, dan kan ik even verder googlen.

Bedankt!

De andersoortige leesbaarheid in je voorbeeld kan je als beginner op het verkeerde been zetten inderdaad, zie dit;

Pseudo-code

code:

    frame.setSize(300, 300);
    frame.setBackground(Color.WHITE);
    
    var wA =    new WindowAdapter() {
                    Public void windowClosing(WindowEvent e) {
                        System.exit(0);
                    }
                };

    frame.addWindowListener(wA);

[ Voor 7% gewijzigd door dominic op 24-05-2010 20:26 ]

[dtech]

Het voordeel hiervan is dat doordat je een anonieme class aanmaakt je niet voor elk van dit soort dingen een aparte (normale) class hoeft aan te maken, maar dit zou dus bijv. ook werken:

code:

class exitSystem{
    Public void windowClosing(WindowEvent e){
        System.exit(0);
    }
}

class Prog{
     int main(){
        frame.setSize(300,300);
        frame.setBackground(Color.WHITE);
        frame.addWindowListener(new exitSystem());
    }
}

Als je een anonymous class gebruikt is het gelijk duidelijk en hoef je niet in een ander file te kijken. Als de class erg groot wordt (zeg meer dan 20 regels) kun je wel gaan overwegen hem als een normale class te declareren, of nog beter als inner class.

[YopY]

chronozphere schreef op maandag 24 mei 2010 @ 14:46:
Wat ik niet begrijp is wat die method definitie tussen accollades daar doet.

Wat gebeurd hier pricies? Heeft dit fenomeen ook een naam, dan kan ik even verder googlen.

Er wordt ter plekke een nieuwe implementatie van de WindowAdapter interface (neem ik aan) gedefinieerd en gelijk geïnitialiseerd. Dit heet een Anonymous Inner Class, ofwel een class-in-een-class die geen specifieke naam meekrijgt. (ook al is het technisch gezien een class-in-een-method-argument).

Wordt ook veel gebruikt in GUI programmeren, waar je ActionHandlers toekent aan knopjes en dergelijke.

[ Voor 8% gewijzigd door YopY op 25-05-2010 13:15 ]

[Salandur]

chronozphere schreef op maandag 24 mei 2010 @ 14:46:
Er word een nieuwe instantie van WindowAdapter gemaakt en doorgegeven aan addWindowListener(). Wat ik niet begrijp is wat die method definitie tussen accollades daar doet.

Wat gebeurd hier pricies? Heeft dit fenomeen ook een naam, dan kan ik even verder googlen.

Bedankt!

Er wordt hier een nieuwe instantie gemaakt van een WindowAdapter, waarbij één specifieke methode wordt overschreven. WindowAdapter implementeert namelijk WindowListener, welke een 7-tal methodes heeft. WindowAdapter heeft 7 lege implementatie methodes, welke je naar behoeve kan overschrijven. Op deze manier hoef je niet alle 7 methodes zelf te implementeren en vervuilt je code niet.

Dit fenomeen heet, zoals al eerder beschreven, anonynous inner class en wordt vrij veel gebruikt binnen Java en ook andere talen. Meestal wordt dit gebruikt om een interface met 1 methode aan te kunnen roepen, waarbij het niet zoveel zin heeft om per keer een volledige classe te implementeren. Deze laatste wordt ook wel het call back pattern genoemd en is meer gebruikt.

[ Voor 4% gewijzigd door Salandur op 25-05-2010 14:07 ]

[.oisyn]

Salandur schreef op dinsdag 25 mei 2010 @ 14:07:
Dit fenomeen heet, zoals al eerder beschreven, anonynous inner class en wordt vrij veel gebruikt binnen Java en ook andere talen.

Even specifiek over inner classes, Java is een van de weinige talen waarbij de inner class instance een impliciete referentie heeft naar de outer class instance die 'm gemaakt heeft. De meeste andere OO talen, zeker de overige C-like talen als C++ en C#, kennen dit concept niet, al is het voor anonymous classes en methods vaak wel mogelijk om aan variabelen zichtbaar vanuit de huidige scope te refereren.

[Macros]

.oisyn schreef op dinsdag 25 mei 2010 @ 15:14:
[...]

Even specifiek over inner classes, Java is een van de weinige talen waarbij de inner class instance een impliciete referentie heeft naar de outer class instance die 'm gemaakt heeft. De meeste andere OO talen, zeker de overige C-like talen als C++ en C#, kennen dit concept niet, al is het voor anonymous classes en methods vaak wel mogelijk om aan variabelen zichtbaar vanuit de huidige scope te refereren.

Even voor de oorspronkelijke topic starter. Dit betekend dat je vanuit de (annonymous) inner class je bij alle fields (en methodes) van de buitenste klasse kan. Ook betekend dat, dat je inner class nooit meer los kan zijn van de outer class. Zolang je een referentie naar de inner klas ergens vast houd, in een list of een ander field, dan zal de outer klasse nooit gegarbage collect kunnen worden.

Als je de inner class toch los wilt hebben van de outer class. Bijvoorbeeld omdat je instanties wilt maken zonder dat er een instantie van de outer class is. Dan kan je ze static declaren. Dan is het eigenlijk een hele eigen klasse die net zo goed in zijn eigen file had kunnen staan. Gevolg is dan wel dat je alleen nog maar bij de static methodes en fields van de outer class kan.

[Killemov]

.oisyn schreef op dinsdag 25 mei 2010 @ 15:14:
[...]

Even specifiek over inner classes, Java is een van de weinige talen waarbij de inner class instance een impliciete referentie heeft naar de outer class instance die 'm gemaakt heeft. De meeste andere OO talen, zeker de overige C-like talen als C++ en C#, kennen dit concept niet, al is het voor anonymous classes en methods vaak wel mogelijk om aan variabelen zichtbaar vanuit de huidige scope te refereren.

Bedoel je nou met een class instance een object van het type Class? Laten we het maar gewoon op objecten houden ipv class instances.
De compiler trekt alle classes uit een .java bestand uit elkaar. Dus tussen het maken van een anonieme, inner of top-level class zit aan de byte-code kant naast de eerder genoemde impliciete referentie geen verschil.
Wat ik veel tegenkomt in gui-code is een sloot aan anonieme classes die eigenlijk hetzelfde doen. Alle(?) gui-tools genereren er lekker op los. Je kunt hier ook een top-level class oplossing voor maken en dan de referentie naar bijvoorbeeld een window-object expliciet meegeven aan de constructor. Daarnaast wordt het factory-pattern niet ondersteund door gui-tools en daarom veel te weinig gebruikt.

[.oisyn]

Killemov schreef op woensdag 26 mei 2010 @ 10:27:
[...]

Bedoel je nou met een class instance een object van het type Class?

Als jij dat zo wilt interpreteren. Je kunt het ook gewoon interpreteren als een instance van de inner class. Niets mis met die formulatie. Hoe zou jij het noemen? Vergeet niet "inner class" in je zin te verwerken, want dat was het onderwerp.