Werte bei Rekursion viel höher als erwartet

[Guest]

Hallo alle zusammen,
Ich arbeite an der Ausgabe eines rekursiven Bildes mithilfe von SVG, weil ich an awt/swing erstmal gescheitert bin...
soweit ist mein Code ganz simpel, nur liefert er mir unglaublich abartige Werte aus. Wo liegt der Fehler?
Die Werte für alle double- bzw int-Zahlen sollten sich zwischen -200 und +200 bewegen
Anscheinend aber liegen sie im Bereich von 10^9

Ich bin total verzweifelt und bitte um Hilfe

import java.awt.Graphics;


public class SVG {
	static int schrittweite = 1;
	public static void rekurs(int xx1, int xx2, int yy1, int yy2, int schritt ) 
	  { 
			 if (schritt<=schrittweite){
				double rechtsobenX, rechtsobenY, linksobenX, linksobenY, vorzeichen, laenge, anstieg;
				//laenge		= Math.sqrt((xx1-xx2)*(xx1-xx2)+(yy1-yy2)*(yy1-yy2));
				//anstieg		= Math.abs(yy1-yy2)/Math.abs(xx1-xx2);
				linksobenY  = yy1 - (xx2-xx1)*0.5;
				linksobenX  = xx1 - (yy2-yy1)*0.5;
				rechtsobenY = 0.75 * yy2 - (xx2-xx1)* 0.5 * 0.75;
				rechtsobenX = 0.75 * xx2 - (yy2-yy1)* 0.5 * 0.75;
				System.out.println("<polygon points=\""+xx1+","+yy1+" "+linksobenX+","+linksobenY+" "+rechtsobenX+","+rechtsobenY+" "+xx1+","+yy2+"\" style=\" fill:#cccccc;stroke:#000000;stroke-width:1\"/>");
				rekurs((int) Math.round(linksobenX),(int) Math.round(rechtsobenX),(int) Math.round(linksobenY),(int) Math.round(rechtsobenY),schritt++);
				rekurs((int) Math.round(rechtsobenX),(int) Math.round(xx2),(int) Math.round(rechtsobenY),(int) Math.round(yy2),schritt++);
			 }
	  }
	public static void main(String[] args) {
		int width=1024;
		int height=768;
		rekurs(10,20,10,20,1);
	    /*rekurs(width/2-21,width/2-20,height/2-20,height/2+20,1);
	    rekurs(width/2+21,width/2+20,height/2-20,height/2+20,1);
	    rekurs(width/2-20,width/2+20,height/2-20,height/2-20,1);
	    rekurs(width/2-20,width/2+20,height/2+20,height/2+20,1);*/

	}

}

vielen Dank schonmal im Voraus, Gruß, Sauerkraut

 

[Murray]

Ich weiß ja nicht, was der Code eigentlich machen soll, aber das

   public static void rekurs(int xx1, int xx2, int yy1, int yy2, int schritt ) {
          if (schritt<=schrittweite){
            /* .. */
            rekurs((int) Math.round(linksobenX),(int) Math.round(rechtsobenX),(int) Math.round(linksobenY),(int) Math.round(rechtsobenY),schritt++);
          }
   }

ist eine Endlosrekursion, die irgendwann zu einem StackOverflowError führt: wenn die Bedingung schritt <= schrittweite erfüllt ist, dann wird sie es auch im nächsten Aufruf noch sein, denn das Konstrukt schritt++ legt ja den unveränderten Wert von Schritt als Argument für den Methodenaufruf auf den Stack und inkrementiert den Wert erst danach - es wird also rekurs mit dem gleichen Wert für schritt nochmal aufgerufen. Und beim nächsten Mal ändert sich wieder nichts und immer so weiter, bis die maximale Rekursionstiefe erreicht ist.

 

[Gast]

eine Kleinigkeit fehlt in Murrays schöner Erklärung:
statt dessen:

++schritt

 

[Murray]

eine Kleinigkeit fehlt in Murrays schöner Erklärung:
statt dessen:

++schritt

Das hatte ich absichtlich nicht geschrieben. Denn dann könnte man ja auf die Idee kommen, es so zu schreiben:

public rekurs( ... int schritt) {
  if ( ...) {
    rekurs( ... ++schritt);
    rekurs( ... ++schritt);
  }
}

Und das ist womöglich nicht das, was mit der Methode bezweckt wird, da der Wert dann ja zweimal erhöht wird.
Vermutlich wäre eher das gemeint:

public rekurs( ... int schritt) {
  if ( ...) {
    rekurs( ... ++schritt);
    rekurs( ... schritt);
  }
}

Ich persönlich würde ohnehin versuchen zu vermeiden, das Methodenargument im Laufe der Methode zu verändern.
Also lieber so:

public rekurs( ... [b]final[/b] int schritt) {
  if ( ...) {
    final int naechsterSchritt = schritt+1;
    rekurs( ... naechsterSchritt);
    rekurs( ... naechsterSchritt);
  }
}

Aber das ist sicher Geschmackssache.