[Java] UI aanpassen vanuit andere classes

[Verwijderd]

Ik heb een vraag, waar meerdere antwoorden op mogelijk zijn. Ik ben op zoek naar de beste/netste manier om vanuit verschillende classes aanpassingen te kunnen doen in de grafische user interface.

Bijvoorbeeld het updaten van een scoreboard bij een spelletje. Een mogelijkheid is om de nieuwe score iedere keer te returnen door alle lagen van het programma heen en deze dan te updaten, maar dat kan in een hoop gevallen flink rommelig staan.

Misschien dat jullie hier je idee eens over heen kunnen laten gaan wat nou wel de beste manier is (is natuurlijk afhankelijk van de situatie).

[Feyd-Rautha]

Misschien dat jullie hier je idee eens over heen kunnen laten gaan wat nou wel de beste manier is (is natuurlijk afhankelijk van de situatie).

Waarom zouden wij dat moeten doen en jij niet ?

[Gerco]

Op vrijdag 26 juli 2002 13:47 schreef -Avalanche- het volgende:
Waarom zouden wij dat moeten doen en jij niet ?

Omdat dit een discussie forum is? Neemt niet weg dat 'ie wel zelf moet meedoen aan de discussie

[Alarmnummer]

Het antwoord op jouw vraag is MVC. Hierdoor breng je een scheiding aan tussen data (model) en je ui (view) dmv een controller (bridge tussen model en view en communicatie mbv events), vandaar de naam MVC (Model View Controller). Door gebruik van deze design pattern te maken, begint ui eigelijk een bijzaak te worden, want je werkt alleen met de model (de info die voor de logica van het spel interessant is). Je code blijft mbv MVC zeer clean. Je moet maar even kijken op GoT naar een voorbeeldje, en anders kan je genoeg vinden op Google, of op java.sun.com.

[edit]
[url="http://www.javaworld.com/javaworld/jw-04-1998/jw-04-howto.html"]Hier[/url] staat nog een artikel over MVC op javaworld.

Je hebt nog een variant op MVC en dat is PAC, maar ik denk niet dat je daar iets mee wil doen. Ik vind MVC een schonere oplossing omdat je allerlei aspecten van je programma gaat scheiden (namelijk logica van je view) en dat is altijd een goeie zaak. Op javaworld kun je ook nog wel een stuk vinden over PAC, en er staat ook nog wel iets over AOP (Aspect Oriented Programming(.

[Verwijderd]

-Avalanche-,
natuurlijk heb ik er zelf over nagedacht en als je mijn post goed had gelezen had je gezien dat ik zelf een oplossing aandraag (waar ik zelf niet tevreden over ben overigens). Bij ontwerpproblemen is het vinden van een goede oplossingsmethode in je eentje vaak moeilijk, en de visie van andere mensen zeer welkom.

Bedankt voor de informatie over MVC Alarmnummer. Ik heb hier al eerder over gelezen en het artikel kwam mij ook heel bekend voor Ik dacht in eerste instantie niet dat het nut zou hebben bij dit probleempje.

Ik heb er even over nagedacht en mee gespeeld en kom er niet uit. De theorie begrijpen is één, maar toepassen is twee (en ik ben geen geweldige programmeur ). View en controller heb ik volgens mij weinig mee te maken, omdat het in mijn voorbeeldje alleen een standaard JTextField betreft. Vervolgens komt er een model klasse (eventueel geschikt voor alle JTextFields) die de text van het textveld moet kunnen wijzigen. Deze klasse wordt in de main-klasse geinstantieerd en krijgt als parameter een textfield mee.
En eigenlijk heb ik dan een mooi cirkeltje gelopen en heb hetzelfde probleem. In de klasse waar ik in het voorbeeld de score wil updaten 'kent' deze instantie niet, dus zou ik door het hele programma de instantie rond moeten spelen.

Waar zit mijn denkfout?

[edit]
ik kan de klasse static maken ... maar das volgens mij ook geen nette oplossing.

[Feyd-Rautha]

Op vrijdag 26 juli 2002 17:20 schreef Lanfear het volgende:
-Avalanche-,
natuurlijk heb ik er zelf over nagedacht en als je mijn post goed had gelezen had je gezien dat ik zelf een oplossing aandraag (waar ik zelf niet tevreden over ben overigens). Bij ontwerpproblemen is het vinden van een goede oplossingsmethode in je eentje vaak moeilijk, en de visie van andere mensen zeer welkom.

ja, sorry , had het niet goed gelezen

[Alarmnummer]

Omdat een stukje code mij meestal meer helpt dan een lap tekst

ps: geen commentaar op het ontwerp aub, dit is alleen ter demonstratie

code:

public class ScoreBord{

    public final static String PUNTEN_PLAYER_1 = "puntenPLayer1";
    public final static String PUNTEN_PLAYER_2 = "puntenPLayer2";

    private int _puntenSpeler1;
    private int _puntenSpeler2;
    private PropertyChangeSupport _pcs = new PropertyChangeSupport(this);

    public ScoreBord(){
    }

    public void setPuntenPlayer1(int punten){
        int oldPuntenSpeler1 = _puntenSpeler1;
        _puntenSpeler1 = punten;
        _pcs.firePropertyChange(PUNTEN_PLAYER_1,oldPuntenSpeler1,_puntenSpeler1);
    }

    public int getPuntenSpeler1(){
        return _puntenSpeler1;
    }

    public void setPuntenPlayer2(int punten){
        int oldPuntenSpeler2 = _puntenSpeler2;
        _puntenSpeler2 = punten;
        _pcs.firePropertyChange(PUNTEN_PLAYER_2,oldPuntenSpeler2,_puntenSpeler2);
    }

    public void addListener(String property, PropertyChangeListener l){
        _pcs.addChangeListener(property,l); 
    }
}

public class ScoreSpeler1Label extends JLabel{

    public ScoreSpeler1Label(ScoreBord scoreBord){
        super(""+scoreBord.getPuntenSpeler1());
        scoreBord.addListener(ScoreBord.PUNTEN_PLAYER_1,new PropertyChangeListenerImpl());
    }

    //dit is de controller class.. 
    private class PropertyChangeListenerImpl implements PropertyChangeListener{
        public void propertyChange(PropertyChangeEvent pce){
            setText(pce.getNewValue());
        }
    }
}

Zoals je zit kan je nu gewoon met het ScoreBord object gaan praten, en alle gui die veranderd automatisch mee. Hierdoor kan jij je bezig houden met de logica van het spel (dus met objecten zoals ScoreBord) en later kan je er een view over plakken (objecten zoals ScroreBordSpeler1). Je kan ook heel eenvoudig meere grafische componenten maken die luisteren naar die scorebord en daar heb je in die scoreBord zelf niets mee te maken Ik hoop dat je hier een beetje mee uit de voeten kan.

[bazzs2001]

hmm ja wat alarmnummer zegt klopt en is zeker het netste en ook zeker aan te raden,

Maarrrr als je heel snel even iets wil maken en het niet net wil doen kan je ook gewoon een pointer naar een gui object meegeven.

voorbeeld

public class GUI extends Frame {
protected TextField score;

public GUI () {
score = new TextField;
Blaat blaat = new Blaat(score);
}
}

class Blaat {
protected Textfield t;

public Blaat (TextField t) {
this.t = t;
t.setText("blaat");
}
}

Dit is dus ook een mogelijkheid, maar die van Alarmnummer is VEEEEEEEEEEEL beter

[Alarmnummer]

Ik ben op dit moment bezig met een systeem waar je veel makkelijker gebruik kan maken van MVC.

[topic=544446/1/50]

Dit is intussen al weer zwaar verouderde code, maar ik ben er zo nu en dan weer even mee aan het spelen. Ik zal binnenkort even wat code gaan posten.

[Verwijderd]

bazzs2001, de oplossing waar jij mee komt heb ik ook zeer regelmatig gebruikt. maar in wat grotere projecten merk ik vaak dat ik een paar lagen dieper in mijn code de pointer naar bijvoorbeeld een textveld nodig heb. dat was eigenlijk ook de aanleiding voor mijn vraag want je blijft dan die pointers maar doorschuiven of returnvalues rondgoochelen.

Alarmnummer, je bent een held! Bedankt voor de heldere uitleg. Ik had zo'n gevoel van "tsjeezes, wat een hoop extra code" toen ik wat aan het lezen was over MVC, maar dankzij je uitleg (en zeker het stukje code!) is het helemaal duidelijk. Ik ga gelijk eens een paar oude projecten uit het stof trekken en aanpakken.

[Alarmnummer]

MVC kan nog een stuk handiger dan de huidige manier van aanpak. Je loopt op dit moment altijd zelf controllers en views(integer labels en textfields, boolean checkboxen en labels etc etc) te schrijven terwijl je meestal toch gebruik maakt van standaard model objecten (integer, strings, booleans, collections zoals list en map).

Ik vond het herhalen van code zo irritant dat ik die model een stuk intelligenter en herbruikbaarder wou maken. Als je dat stuk van mij even doorleest dan begrijp je misschien wat ik bedoel. Je moet daarbij eigelijk alleen letten op de Persoon class en op het component waar alles getekend wordt. Verder zijn de rest van de classes herbruikbare classes en hoef je dus lang niet zoveel code meer te schrijven dan met de huidige aanpak.

Je hoeft dus alleen een model object te maken (bv persoon) die gebruik maakt van allerlei basis model objecten (stringmodel voor voornaam, achternaam, en listmodel voor kinderen)en views ed die kan je er supereenvoudig overheen plakken, omdat het dus kan en klare objecten zijn. Je hoeft dus alleen nog een model object te schrijven en bijna geen gui meer en helemaaal geen event code.

[Verwijderd]

Ik heb hier nog een mooi ander voorbeeld gevonden:
[url="http://genome-www.stanford.edu/~sac/java/mvc/"]http://genome-www.stanford.edu/~sac/java/mvc/[/url]