Java: Faculteit functie in Rekenmachientje

[IkWeetGeenNaam]

Beste mensen..

Ik heb een simpele 'rekenmachine' gemaakt, maar wanneer ik de functie faculteit! wil toevoegen krijg ik het maar niet werkend.. Kan iemand aan de hand van mijn code zien wat ik verkeerd doe?

Alvast bedankttt voor de reacties!

Dit is mijn Rekenmachine.java

public class Rekenmachine{
	
	private Reken [] Functie = new Reken[4];{

		new RekenFaculteit();{
			
	        Functie[0] = new RekenDelen();
	        Functie[1] = new RekenKeer();
	        Functie[2] = new RekenMin();
	        Functie[3] = new RekenPlus();
		}
	
public class RekenFaculteit implements RekenFaculteit {
			
	private Reken [] Functie = new Reken[1];{
	
		new RekenFaculteit();{
		
			Functie[4] = new RekenFaculteit();{
				}
		[COLOR="Red"]}[/COLOR]

			public RekenFaculteit(){
			
			    int getal;
				int getal1;
				int getal2;{
				
			getal  = 4;
			getal1 = 4;
			getal2 = 2;
			for(int i = 0; i < Functie.length; i++);{
			System.out.println(Functie[4].bereken(getal1, getal2));{
			}
			}
				}
			}
	}
}
	}

Main.java

public class Main {
	public static void main(String[] args){
		Rekenmachine rk = new Rekenmachine();
	}
}

Reken.java

public interface Reken
{
	public double bereken (double g1, double g2);
}

RekenFaculteit.java

public class RekenFaculteit implements Reken{
	public RekenFaculteit()
	{
	}
	public int bereken(int g1, int g2)
	{
		return fac(g1);
	}
	public int fac(int g){
		if(g == 1){
			return 1;
		}
		else
		{
			return g * fac(g - 1);
		}
	}
	public double bereken(double g1, double g2)
	{
		 //TODO Auto-generated method stub
		return 0;
	}
}

RekenDelen.java

public class RekenDelen implements Reken
{
    public double bereken (double g1, double g2){
    
    return g1/g2;
}
}

RekenKeer.java, RekenMin.java en RekenPlus.java liggen voor de hand.. Ik wil nogmaals meedelen dat alles naar behoren werkt als ik de RekenFaculteit functie buitensluit.. dan is de Rekenmachine.java wel als hieronder:::

public class Rekenmachine {

	private Reken [] Functie = new Reken[4];{
	    			
	    	        Functie[0] = new RekenDelen();
	    	        Functie[1] = new RekenKeer();
	    	        Functie[2] = new RekenMin();
	    	        Functie[3] = new RekenPlus();
	        
	        for(int i = 0; i < Functie.length; i++);{
	         System.out.println(Functie[2].bereken(10, 5 ));
	        }

}
}

Als jullie de hele package willen omdat dat overzichtelijker is, is het ook hieronder te downloaden:
http://s4.yousendit.com/d.aspx?id=2X1IBDR1CVB101RTN67IDV346N

Waarschijnlijk gaat het om iets heel erg simpels, maar ben nog maar een hele erge beginner, dus neem het me aub niet kwalijk

 

[dropl]

public int fac(int g){
		if(g == 1){
			return 1;
		}
		else
		{
			return g * fac(g - 1);
		}
	}

Hij eindigt bij return 1. Geeft deze functie niet altijd 1 terug dan?
return g lijkt me meer voor dan hand liggen.

Overigens denk ik dat je bij grote getallen een stack overflow krijgt.

int f=g;
while(g>1)
 f*=--g;
return f;

Even snel uit het hoord op de gok.
Kan zijn dat het aan de forumsoftware ligt, maar ik vin je code redelijk onleesbaar.

 

[IkWeetGeenNaam]

Ehm.. ik snap niet wat er onleesbaar aan zou moeten zijn.. heb ook een link geplaatst naar het hele pakket trouwens..

als het 1 is, dan geeft ie 1 trg ja.. anders berekent ie verder op de faculteit manier.. maar daar ligt de fout niet aan.. het ligt hem aan de 'verbinding' tussen RekenFaculteit.java en Rekenmachine.java denk ik...

 

[snabbi]

De code in RekenFaculteit is gewoon in orde. Dit heet recursief programmeren dropl. Er is eigenlijk in mijn ogen geen betere methode om dit uit te programmeren. Als je de methode met 3 aanroept dan gebeurt het volgende:

Bij de if krijg je 3 == 1, dus hij gaat naar de else en rekent daar uit:
3 * fac(2)
fac(2) levert op
2 * fac(1)
fac(1) is 1, want hij gaf altijd 1 terug, dus nu teruglopend
fac(2) = 2*1
fac(3) = 3 * 2

Die methode is dus prima.
Het is mij wel werkelijk een raadsel waarom je dit doet in je eerste code blok:
public class RekenFaculteit implements RekenFaculteit

Je hebt hierdoor behalve een aanroep op een interface die je hier niet noemt, ook nog 2 keer dezelfde classe aangemaakt. Dit aangezien je ook een RekenFaculteit.java hebt. Ik zal maandag wel eens kijken, vanaf hier kan ik geen java dingen uitvoeren

 

[IkWeetGeenNaam]

De code in RekenFaculteit is gewoon in orde. Dit heet recursief programmeren dropl. Er is eigenlijk in mijn ogen geen betere methode om dit uit te programmeren. Als je de methode met 3 aanroept dan gebeurt het volgende:

Bij de if krijg je 3 == 1, dus hij gaat naar de else en rekent daar uit:
3 * fac(2)
fac(2) levert op
2 * fac(1)
fac(1) is 1, want hij gaf altijd 1 terug, dus nu teruglopend
fac(2) = 2*1
fac(3) = 3 * 2

Die methode is dus prima.
Het is mij wel werkelijk een raadsel waarom je dit doet in je eerste code blok:
public class RekenFaculteit implements RekenFaculteit

Je hebt hierdoor behalve een aanroep op een interface die je hier niet noemt, ook nog 2 keer dezelfde classe aangemaakt. Dit aangezien je ook een RekenFaculteit.java hebt. Ik zal maandag wel eens kijken, vanaf hier kan ik geen java dingen uitvoeren

Dat heb ik gedaan omdat ik dacht dat ik op de één of andere manier RekenFaculteit.java (de code ervan) erbij zou moeten betrekken..
Waar ik ook niet uit kom is het getal, getal1, getal2.. Bij Faculteit heb ik alleen getal nodig, maar bij de overige methoden heb ik getal1 en getal2 nodig.. Ik weet ook niet hoe ik dat zou moeten aangeven. Dat ie de één gebruikt en dan weer de ander etc..
Ik heb het nu op de volgende manier gedaan:

System.out.println(Functie[4].bereken(getal1, getal2));{

Maar wat nu als ik de faculteit wil berekenen? hoe laat ik dat uitrekenen?

 

[snabbi]

Tja dat is ook een lastige, ik heb nu je code zo verandert dat je dus inderdaad alleen het eerste getal gebruikt en niet meer het tweede wanneer je de faculteit aanroept. Daarnaast heb ik je code uit Rekenmachine over RekenFaculteit verwijderd. Wellicht vind je het handig om eerst uit mijn code de namen package weg te halen, maar ik vond het wel zo makkelijk om hem in een subdir te zetten.

Enige waar ik dus op fout ging was de code in Rekenmachine zelf, kijk maar wat ik er van gemaakt heb. Succes

 

[dropl]

De code in RekenFaculteit is gewoon in orde. Dit heet recursief programmeren dropl. Er is eigenlijk in mijn ogen geen betere methode om dit uit te programmeren.

Je hebt gelijk, de functie werkt wel en een recursieve functieaanroep is mij niet onbekend. In dit geval lijkt me dat dit niet de beste oplossing is. Een simpele loop kan helemaal via cpu registers lopen terwijl een functieaanroep altijd geheugenbewerkingen oplevert, al is het alleen maar push en pops op/van de stack. Laat dan nog staan de jvm die de stack moet checken en andere overhead aan het aanroepen van een functie in een classe. En dan ben ik nog benieuwd wat hij bij hele grote getallen doet, of je dan geen StackOverflowError krijgt.

 

[IkWeetGeenNaam]

Tja dat is ook een lastige, ik heb nu je code zo verandert dat je dus inderdaad alleen het eerste getal gebruikt en niet meer het tweede wanneer je de faculteit aanroept. Daarnaast heb ik je code uit Rekenmachine over RekenFaculteit verwijderd. Wellicht vind je het handig om eerst uit mijn code de namen package weg te halen, maar ik vond het wel zo makkelijk om hem in een subdir te zetten.

Enige waar ik dus op fout ging was de code in Rekenmachine zelf, kijk maar wat ik er van gemaakt heb. Succes

Ja, nu werkt ie !! dank je wel.. Ik heb het langer gemaakt dan dat het nodig was blijkbaar

om aparte berekeningen te laten uitvoeren werkt ie trouwens zo alleen:

for (int i = 0; i < Functie.length; i++);{

dus met punt komma voor de acculade.. d8 nog even melden

thnxxx again !!!

 

[snabbi]

Sorry maar een for loop met een ; voor de accolade is mij onbekend en levert ook een error op.
Voor dropl, ik denk dat je eerder een overflow krijgt op je double, dan op de stack voor het recursief programmeren. (Ik kreeg mijn stack overflow rond de 9993 recursieve aanroepen)