[JAVA] Object in object zoeken

[huub8]

Ik heb een simpel programma dat ik voor mijn study moet maken, hierbij moet ik mij aan een bepaalde interface houden dus veel kan ik niet aanpassen.

Het probleem is nu dat ik een object als het onderstaande heb:
Formule formule = new Plus(new nummer(1), new Min(new Nummer(2), new Nummer(1)))

Is het nu mogelijk om als je alleen het object formule hebt, daarin te zoeken naar hoeveel verschillende Nummer objecten daarin zitten? (met verschillende Nummer objecten bedoel ik objecten die een ander nummer als parameter doorkregen)

[chime]

Jonge, jonge, jonge ... bekijk jij eerst maar eens even hoe methoden en variabelen werken.
Hint: List.

Meer woorden moet hier ook niet aan vuilgemaakt worden zou ik denken ... ah ja ... je antwoord op je vraag: ja, dat kan

En houden aan een interface is niet echt een beperking zou ik zo denken ... je kan nog altijd extenden, andere interfaces erop gooien, abstracte classes gebruiken ...

[huub8]

Volgens mij onderschat je me, ik mag niet extra interfaces gebruiken of abstracte classes, puur een aantal klassen die direct de interface implementeren. Een van deze klassen (van te voren niet bekend, namelijk de buitenste klasse van de formule) moet kunnen tellen hoeveel verschillende nummers erin zitten terwijl hij enkel de formule doorkrijgt. Als je mij wil uitleggen hoe ik dat met een list kan doen zou ik dat erg fijn vinden, ik kom er namelijk niet uit.

[Rigi]

Als ik het goed begrijp mag je binnen de Formule interface een methode maken die het aantal Nummer objecten terug geeft. In dat geval kan je natuurlijk recursief gaan tellen: Dus in jouw voorbeeld zou het Plus object kijken naar zijn twee Formule objecten, als het een Nummer is tel je 1 bij het aantal, zo niet dan vraag je dat Formule object (de Min dus) hoeveel nummers daarin zitten

[huub8]

je mag de interface niet aanpassen, alle klassen die erven van moeten de volgende functie emplementeren:
public int[] aantal()

Het is een beetje moeilijk uitleggen zonder de hele opdracht uit te leggen, maar recursief tellen lijkt mij niet erg makkelijk met een functie die enkel een int[] teruggeeft.

[Rigi]

public int[] aantal() voldoet toch prima?

aantal is dan de som van de .aantal() van de twee parameters (van Plus en Min) of 1 bij een Nummer (neem aan dat dat ook een Formule is?)

[huub8]

zo had ik er nog niet aan gedacht, dat moet inderdaad wel lukken. Het enige probleem is nu dat de buiteste klasse niet simpelweg het aantal moet returnen maar eerst daar wat dingen mee moet doen. Dit geld dus alleen voor de buiteste, hoe weet de buitenste dan dat hij de buitenste is?

[Macros]

Misschien kan je wat meer code snippets tonen. Ik denk hier eerder aan een Visitor oplossing. (Zie Wikipedia).

[Asator]

Macros schreef op vrijdag 27 januari 2012 @ 13:12:
Misschien kan je wat meer code snippets tonen. Ik denk hier eerder aan een Visitor oplossing. (Zie Wikipedia).

Ik denk hierbij eerder aan een decorator pattern, het boek Head First Design Pattern heeft hier ook een mooi voorbeeld van: http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf

De OP wil niet onderschat worden dus ik ga er van uit dat hij dat boek wel snapt

[huub8]

De opracht is eigenlijk niet met plus en min en dergelijke, maar met een logische formule.
Je hebt dus onder andere een En, Of, Desda, Niet klasse. Deze klassen implementeren allemaal een interface, een methode die ze dus allemaal hebben is de zogenaamde vervulbaar methode, die een bedeling in de vorm van een int[] teruggeeft, deze moet dus een bedeling vinden waarvoor de formule waar is. Daarvoor moet hij dus simpelweg alle combinaties van waarheidswaarden van de atomen uitproberen, maar daarvoor moet ik eerst weten welke atomen er allemaal in de formule zitten. Daar loop ik dus vast.

[Janoz]

huub8 schreef op vrijdag 27 januari 2012 @ 12:35:
zo had ik er nog niet aan gedacht, dat moet inderdaad wel lukken. Het enige probleem is nu dat de buiteste klasse niet simpelweg het aantal moet returnen maar eerst daar wat dingen mee moet doen. Dit geld dus alleen voor de buiteste, hoe weet de buitenste dan dat hij de buitenste is?

Je moet echt de knop eens in je hoofd omzetten. Je trekt de scope veel te breed. Wat voor meer dingen moet je doen? Is dat nog steeds 'passend' in die 'aantal' methode? Zou je, als er meer gedaan moet worden, dat heel misschien niet in een andere methode moeten zetten die gebruik maakt van de aantal methode?


--edit ---

Oh wacht.. het gaat niet om aantal. Ik vond het array teruggeven al wat vreemd.

Maar wat is het probleem? Waarom moet je vooraf in de eerste aanvraag al compleet kunnen bepalen welke atomen je nodig hebt? Dat kun je toch keurig door alle losse delen zelf laten bepalen? Daar is het tenslotte recursie voor.

Heb je trouwens ook wat meer beschrijving wat die array van integers nu eigenlijk voorsteld?

[ Voor 23% gewijzigd door Janoz op 27-01-2012 13:22 ]

[huub8]

dat meer is dus het vinden van een bedeling waarvoor de formule waar is, daarvoor moet hij dus alle mogelijke combinaties van waarheidswaarden voor de atomen uitproberen en als er een combinatie is waarvoor de formule waar is dan moet hij deze dus in een int[] teruggeven. Dit moet de aantal methode doen volgens de opdracht.

[huub8]

die arrray aan integers bevat het nummer van de atomen, dat ofwel negatief is voor een onwaar atoom of positief is voor een waar atoom. Hoe zou ik een bedeling kunnen maken als ik niet weet welke atomen de formule bevat?

[ Voor 23% gewijzigd door huub8 op 27-01-2012 13:25 ]

[voodooless]

Kortom: je hebt een formule waar "atomen" in gaan. En wat jij nu moet doen, is uitvinden voor welke atoomwaardes er uit de gehele formule true komt?

[huub8]

ja, en deze waardes voor de atomen waarvoor de formule waar is worden dus teruggegeven door de vervulbaar methode. Mijn idee was dus om de buiteste klasse alle combinaties van de waarheidswaardes van de atomen uit te laten proberen, maar daarvoor moet hij eerst weten welke atomen de formule bevat.

[ctrlaltdelbe]

Als al die klassen nu een bepaalde klasse implementeren zeg nu maar eens 'TeltNummers' met de abstracte methode 'tel()' (ik vermoed dat elk van die klassen Formule implementeert, dus laat je gewoon Formule de klasse TeltNummers implementeren). Als je wil weten hoeveel nummers er in een Formule-object zitten, is het een kwestie van formule tel() op te roepen van het Formule-object.

Deze tel()-methode ziet er bij een Formule-object dan bijvoorbeeld zo uit

code:

return deel1.tel() + deel2.tel()

Voor een Nummer-object ziet het er dan zo uit:

code:

return 1;

Dat lijkt me de implementatie het eerder aangehaalde Decorator-pattern en doet wat je vraagt, niet?

[ Voor 9% gewijzigd door ctrlaltdelbe op 27-01-2012 13:32 ]

[Janoz]

Dat vermoede ik al. In de array staat niet het nummer van de atoom, maar de mogelijke waarden.

Recursie is in principe heel simpel. Maak een interface afspraak en binnen de implementatie kun je er vervolgens vanuit gaan dat deze werkt. Vervoglens ga je die voor elke class implementeren waarbij je weer gebruik mag maken van die methode. Als je er vervolgens voor zorgt dat binnen dat heel kleine stukje je zeker weet dat het resultaat juist is, uitgaande van het juiste resultaat van de aanroepen, dan werkt het dus voor het geheel ook.

Probeer telkens het oplossen zo klein mogelijk te houden. Waar je nu de mist in gaat is denken dat je in een enkele methode de verantwoordelijkheid draagt voor de implementatie van de gehele boom! Maar dat is helemaal niet zo. Je draagt enkel de verantwoordelijkheid voor dat ene stukje.

Ik neem aan dat er ook een classe atoom is? (ipv nummer in het oorspronkelijke voorbeeld)
Wanneer is die waar? De oplossing daarvan lijkt mij duidelijk. Die moet immers gewoon een array teruggeven gevuld met 1 positief getal.

Wanneer is de not waar?

Die wordt al wat moeilijker. Die is alleen waar wanneer de uitkomst van zijn parameter onwaar is. Maar is dat eigenlijk niet hetzelfde als het resultaat van zijn parameter nemen en daar alle elementen in de array vermenigvuldigen met -1?

De eerstvolgende hobbel zul je krijgen bij de desda, aangezien je daar eens uit moet zoeken hoe je omgaat met een atoom waarbij de waarde helemaal niet uit maakt.


--Edit---
@ hierboven. Het oorspronkelijke probleem blijkt helemaal niet relevant meer te zijn aangezien het een toch iets te versimpelde versie van het werkelijke probleem bleek te zijn.

[ Voor 12% gewijzigd door Janoz op 27-01-2012 13:38 ]

[huub8]

de waarheid bepalen van de formule werkt al wel in het programma, maar mij probleem is dat als ik stukje voor stukje oplos dat dan het volgnede kan gebeuren:

(a1 of a2) en (niet a1 en a2)

Nu geeft hij bijvoorbeeld door de linker kant als oplossing a1 = waar en a2 = waar , en de rechter kant geeft hij a1 = niet waar en a2 is waar. wat moet de buitenste en dan teruggeven? die weet niet hoe het zit dieper in de boom, dus hij weet niet dat de linker helft ook anders kan worden opgelost.

[ Voor 7% gewijzigd door huub8 op 27-01-2012 13:41 ]

[ctrlaltdelbe]

Ik heb even mijn post gekopieerd en aangepast naar de huidige situatie. Waarom zou je al dat werk doen als je het Java kan laten doen?

Als al die klassen nu een bepaalde klasse implementeren zeg nu maar eens ''WaarOfVals" met de abstracte methode 'isWaar()' (ik vermoed dat elk van die klassen Formule implementeert, dus laat je gewoon Formule de klasse WaarOfVals implementeren). Als je wil weten of een Formule waar is, is het een kwestie van formule isWaar() op te roepen van het Formule-object.

Deze isWaar()-methode ziet er bij een And-object dan bijvoorbeeld zo uit

code:

return deel1.isWaar() && deel2.isWaar()

Voor een Implicatie-object ziet het er dan zo uit (p->q = ~p v q):

code:

return !deel1.isWaar() || deel2.isWaar() ;

Voor een DESDA-object zo (p <=> q = (p => q) ^ (q=>p)) :

code:

return (!deel1.isWaar() || deel2.isWaar()) && (!deel2.isWaar() || deel1.isWaar());

Voor een atoom dat waar is ziet het er dan zo uit:

code:

return true;

Dat lijkt me de implementatie het eerder aangehaalde Decorator-pattern en doet wat je vraagt, niet? Of mis ik hier iets heel erg fundamenteels?

EDIT: ja dus, dat je de waarde van de atomen voorlopig niet ingevuld krijgt. Lijkt me niet zo moeilijk. Maar voor elk van die atomen op exact dezelfde manier als hierboven beschreven een klasse returnLijst(). Een atoom geeft gewoon zichzelf terug

code:

ArrayList<Atom> list = new ArrayList<Atom>();
list.add(this);
return list;

En bijvoorbeeld een AND-klasse maakt een nieuwe lijst aan als volgt

code:

ArrayList<Atom> list = new ArrayList<Atom>();
list.addAll(part1.getList());
list.addAll(part2.getList());

Dan heb je toch een lijst met alle atomen waarop je de bedeling kunt uitvoeren?

[ Voor 36% gewijzigd door ctrlaltdelbe op 27-01-2012 13:59 ]

[voodooless]

Dat is de bedoeling niet. De input is niet gedefinieerd en dus "zwevend". Enkel de output staat vast (die moet true zijn). Het gaat er dus om om alle verschillende mogelijke input waardes te vinden die als output true geven. Toch?

[Janoz]

huub8 schreef op vrijdag 27 januari 2012 @ 13:40:
de waarheid bepalen van de formule werkt al wel in het programma, maar mij probleem is dat als ik stukje voor stukje oplos dat dan het volgnede kan gebeuren:

(a1 of a2) en (niet a1 en a2)

Nu geeft hij bijvoorbeeld door de linker kant als oplossing a1 = waar en a2 = waar , en de rechter kant geeft hij a1 = niet waar en a2 is waar. wat moet de buitenste en dan teruggeven? die weet niet hoe het zit dieper in de boom, dus hij weet niet dat de linker helft ook anders kan worden opgelost.

Oh, je kunt ook overal eventueel dezelfde atomen inzetten? Weet je dat zeker? Is het op dit niveau niet gewoon
(a1 of a2) en ((niet a3) en a4) ?

[ctrlaltdelbe]

voodooless schreef op vrijdag 27 januari 2012 @ 13:59:
Dat is de bedoeling niet. De input is niet gedefinieerd en dus "zwevend". Enkel de output staat vast (die moet true zijn). Het gaat er dus om om alle verschillende mogelijke input waardes te vinden die als output true geven. Toch?

Ik heb de opdracht dus helemaal volledig compleet verstaan In plaats van te kijken of een bedeling waar is, moet hij een alle bedelingen teruggeven waarvoor de formule waar is. Een lijst van arrays dus.

Is natuurlijk ook niet moeilijk meer met mijn code. Je maakt een permutatie van alle bedelingen, evalueert ze stuk voor stuk met behulp van de hieboven gemaakte code en als deze true terug geeft, voeg je de bedeling toe aan je lijst met bedelingen die 'waar' opleveren. Je doet tenslotte hetzelfde in een waarheidstabel.

[Janoz]

Nikolas schreef op vrijdag 27 januari 2012 @ 14:01:
[...]

Ik heb de opdracht dus helemaal volledig compleet verstaan In plaats van te kijken of een bedeling waar is, moet hij een alle bedelingen teruggeven waarvoor de formule waar is. Een lijst van arrays dus.

Is natuurlijk ook niet moeilijk meer met mijn code. Je maakt een permutatie van alle bedelingen, evalueert ze stuk voor stuk met behulp van de hieboven gemaakte code en als deze true terug geeft, voeg je de bedeling toe aan je lijst met bedelingen die 'waar' opleveren.

Ja, dat kan, maar in plaats van brute forcen kan het veel handiger en de bedoeling van deze opdracht is ook niet om te bruteforcen. Anders had er immers in de interface wel een 'isWaar()' methode gestaan.

[ctrlaltdelbe]

Janoz schreef op vrijdag 27 januari 2012 @ 14:03:
[...]

Ja, dat kan, maar in plaats van brute forcen kan het veel handiger en de bedoeling van deze opdracht is ook niet om te bruteforcen. Anders had er immers in de interface wel een 'isWaar()' methode gestaan.

Ja, inderdaad. Ik denk dat ik me maar beter terugtrek uit deze discussie, want ik lijk niet echt te helpen

[huub8]

ik wilde hem eigenlijk wel gaan brute forcen, omdat dit mij het gemakkelijkst leek, ik snap ook niet helemaal hoe je het anders wil doen?

[Janoz]

Misschien is het dan handiger om om wat hints te vragen van de begeleider of de docent.

[voodooless]

is het niet een soort van techter waar je je waarheidstabellen in gooit? Die moet je dan laag voor laag over elkaar heen leggen. Vervolgens hou je de tabellen over die voor de gehele formule true geven.

[huub8]

daar zat ik ook al aan te denken, maar dan zou een of dus 3 verschillende tabellen moeten teruggeven (voor beide kanten waar, en voor een van beide kanten waar), maar hoe doe ik dit met een int[], dan zou je toch een int[][] gebruiken?