StackOverflowError

[greece57]

Wir programmieren in der Schule gerade ein Programm was sich die Türme von Hanoi nennt.
Nun ich habe jetzt das Programm zwar fertig aber jetzt kommt ein komplett unerwarteter StackOverFlowError

Tschuldigung für soviel Code aber den Error zeigt er mir so ungefähr je nach kleiner veränderung des Codes (System.out.println einbauen/ausbauen) in insgesamt allen Klassen an (je nach dem mit oder ohne ein paar Sys.out.pr)

Code:

Das Kompositum:

Listenelement:

abstract class Listenelement
{

    public abstract Listenelement naechsterGeben ();
    public abstract Datenelement inhaltGeben();    

}

Abschluss:

class Abschluss extends Listenelement
{
    public Listenelement naechsterGeben () {
        return this;
    }

    public Datenelement inhaltGeben() {
        return null;
    }

}

Datenknoten:

class Datenknoten extends Listenelement
{

    private Listenelement naechster;
    private Datenelement inhalt;

    /**
     * Konstruktor für Objekte der Klasse Datenknoten
     */
    public Datenknoten(Listenelement n, Datenelement i)
    {
        naechster = n;
        inhalt = i;
    }

    public void naechsterSetzen (Listenelement n){
        naechster =n;
    }

    public void inhaltSetzen (Datenelement i) {
        inhalt = i;
    }

    public Listenelement naechsterGeben() {
        return naechster;
    }

    public Datenelement inhaltGeben() {
        return inhalt;
    }

}

Datenelement:

class Datenelement
{
    int größe;
    /**
     * Konstruktor für Objekte der Klasse Datenelement
     */
    Datenelement(int gr)
    {
        größe = gr;        
    }

    public int größeGeben() {
        return größe;
    }

    public void datenAusgeben () {
        System.out.println ("Datenwert: "+größe);
    }
}

Stapel:

class Stapel
{

    public Listenelement erster;
    /**
     * Konstruktor für Objekte der Klasse Stapel
     */
    Stapel()
    {
        erster = new Abschluss();
    }

    public void einfügen (Datenelement knoteninhalt){
        Datenknoten neuerKnoten = new Datenknoten (erster, knoteninhalt);
        erster = neuerKnoten;
    }

    public Datenelement entnehmen (){
        Datenelement alterKnoteninhalt = erster.inhaltGeben();
        erster = erster.naechsterGeben();
        return alterKnoteninhalt;
    }

    public Listenelement ersterGeben() {
        return erster;
    }

    public boolean istLeer() {
        if (erster.naechsterGeben() == erster)
            return true; // Wenn der erste sich selbst zurückgibt -> erster = Abschluss -> leer
        else
            return false;
   }

   public Listenelement letzterGeben() {
       Listenelement letzter;
       letzter = ersterGeben();
       while (letzter.naechsterGeben().naechsterGeben() != letzter.naechsterGeben())
       // sonst krieg ich den abschluss raus = scheiße
       {
            letzter = letzter.naechsterGeben();
       }
       return letzter;
    }

    public Listenelement vorherigerGeben( Listenelement l) {
        Listenelement letzter;
        letzter = ersterGeben();
        while (letzter.naechsterGeben() != l)
       // sonst krieg ich den abschluss raus = scheiße
       {
            System.out.println("...schleife...");
            letzter = letzter.naechsterGeben();
            if (letzter.naechsterGeben() == letzter)
            System.out.println("WARUNUNG WARNUNG SELBSTZERSTÖRUNG");
       }
       return letzter;
    }
}

Algorithmus:

class Algorithmus
{

    /**
     * Konstruktor für Objekte der Klasse Algorithmus
     */
    Algorithmus()
    {

    }

    public void verschieben (Stapel quelle, Stapel hilf, Stapel ziel, Listenelement d)
    {
        if ( d.inhaltGeben().größeGeben() != 
        quelle.ersterGeben().inhaltGeben().größeGeben() ) // Also wenn d ungleich erster ist weil letzter is ja mom. der erste
        {
            verschieben(quelle, hilf, ziel, quelle.vorherigerGeben(d));
            verschieben(quelle, hilf, ziel, d);
        }else{
            if (ziel.istLeer())
            {
                steinverschieben(quelle, ziel);
            }
            else
            {
                if (ziel.ersterGeben().inhaltGeben().größeGeben() > d.inhaltGeben().größeGeben()) // wenn der Stein draufpasst
                {
                    steinverschieben(quelle, ziel);
                }else{ // wenn er nicht passt
                    verschieben(ziel, quelle, hilf, ziel.letzterGeben()); // also ziel ist die quelle, quelle der hilfsstapel und der hilfsstapel das ziel
                    steinverschieben(quelle, ziel); // Nichtpassender kommmt aufs leere ziel
                    verschieben(hilf, quelle, ziel, hilf.letzterGeben());
                }
            }

        }

    }

    public Stapel steinverschieben (Stapel quelle, Stapel ziel)
    {

        ziel.einfügen(quelle.entnehmen());
        return ziel;
    }
}

Main:

class Main
{
    public Stapel S1;
    public Stapel S2;
    public Stapel S3;
    public Algorithmus a;

    /**
     * Konstruktor für Objekte der Klasse main
     */
    Main(int anzahlSteine)
    {
        S1 = new Stapel();
        S2 = new Stapel();
        S3 = new Stapel();
        a = new Algorithmus();

        /*for (int i = anzahlSteine + 1; i > 1; i--)
        {
            S1.einfügen(new Datenelement(i));
        }*/

        S1.einfügen(new Datenelement(3));
        S1.einfügen(new Datenelement(2));
        S1.einfügen(new Datenelement(1));
    }

    public void main()
    {
        a.verschieben(S1, S2, S3, S1.letzterGeben());
    }

}

[rekursion]

StackOverFlow deutet normalerweise auf eine endlosrekursion hin. vermutlich fehlt dir also eine abbruchbedingung für deine rekursion (ohne deinen code genauer angeschaut zu haben)

also eventuell einfach mal debugen?

[greece57]

Ja damn wir verwenden blueJ
aber ich werde es mal auf Eclipse übertragen und debuggen
schon mal danke