Exception

[Waterman]

Hallo ich bearbeite gerade eben diese Aufgabe:

Vervollständigen Sie die Methode int evenInts( IntNode n ).
Die Methode evenInts soll die Summe aller geraden Werte im Teilbaum mit der Wurzel n
zurückgeben.
Enthält der Teilbaum keinen geraden Wert, soll eine Ausnahme der Klasse NoResultException
geworfen werden.

Hier ist ist die Klasse zu den Knoten des Baumes und die Ausnahmeklasse:

public class NoResultException extends Exception {}



public class IntNode {
    private int value;
    private IntNode leftChild, rightChild;
    public IntNode( int i ) {
        value = i; leftChild = rightChild = null;
    }
    public IntNode( int i, IntNode left, IntNode right ) {
        value = i; leftChild = left; rightChild = right;
    }
    public int getValue() { return value; }
    public void setValue(int i) { value = i; }
    public IntNode getLeftChild() { return leftChild; }
    public IntNode getRightChild() { return rightChild; }
    public void setLeftChild( IntNode node ) { leftChild = node; }
    public void setRightChild( IntNode node ) { rightChild = node; }
    public boolean isLeaf() { 
        return leftChild == null && rightChild == null;
    }
}

Wie ich die Summe der gerade Werte bekomme habe ich bereits implementiert. Jedoch weiß ich nicht wie ich die Exception thrown/werfen soll bzw.wie ich abfrage ob ich nun gerade Werte habe oder ob ich sie nicht habe und eben die Exception werfen muss.

public class IntSearchTree{
    private int evenInts( IntNode n ) throws NoResultException{
        if(n==null){
            return 0;
        }else{
            if(n.getValue()%2==0){
                return n.getValue() + evenInts(n.getLeftChild()) + evenInts(n.getRightChild());
            }else{
                return evenInts(n.getLeftChild()) + evenInts(n.getRightChild());
            }
        }
    }
}

 

[geqoo]

Eine Exception von Hand werfen tust du mit

throw new Exception(args)

Also in deinem Falle:

throw new NoResultException();

Und zwar an der Stelle, wo kein gerader Wert vorhanden ist, also in deiner Moduloabfrage.

 

[Waterman]

mmmm könntest du das vielleicht in meinen Code implementieren ?
Ich weiß nicht wirklich welche Stelle du meinst. Denn wenn ich die Abfrage im else Teil meiner Modulo-Abfrage platziere bricht die Exeption dann nicht meine Methode ab ?


Oder ich habe zuerst die Aufgabenstellung falsch verstanden. Wenn also ein ungerader Wert gefunden wurde sollen dann seine Kinder nicht kontrolliert werden ?

Dann wäre das ja:

public class IntSearchTree{
    private int evenInts( IntNode n ) throws NoResultException{
        if(n==null){
            return 0;
        }else{
            if(n.getValue()%2==0){
                return n.getValue() + evenInts(n.getLeftChild()) + evenInts(n.getRightChild());
            }else{
                throw new NoResultException();
            }
        }
    }
}

 

[geqoo]

Eigentlich geht das mit continue.

Ich würde eine Klasse machen, die von NoResultException abgeleitet ist und dann die Exception Methode überschreiben und dort eben continue mit reinschreiben. Dann fährt er mit der Ausführung deines Programms fort.
Und dann kannst du auch den return Wert dahinter einbauen.

Sieh dir mal das hier dazu an.

 

[Waterman]

"Ergänzen Sie die Klasse IntSearchTree, die einen binären Suchbaum von Werten des Typs int
realisiert. Gehen Sie bei der Implementierung der geforderten Methoden davon aus, dass Ihnen in der
Klasse IntSearchTree keine Methoden zur Verfügung stehen und Sie auch nur genau die geforderten
Methoden hinzufügen dürfen. Änderungen und Ergänzungen außerhalb der jeweils geforderten Methode
sind bei keiner Teilaufgabe erlaubt. Beachten Sie, dass bei allen Methoden auch der leere Teilbaum als
Parameter vorkommen kann. "

Ich darf leider keine zusätzliche Methoden implementieren.

Habe mir dir Aufgabenstellung nochmal richtig durchgelesen, wenn ich das richtig verstehe soll die Exception auch nur geworfen werden wenn in dem Teilbaum (je nachdem welchen Parameter man der Funktion übergibt) gar kein gerader Wert vorkommt sprich die Summe der geraden Wert 0 ist.