Stack programmieren -> Unklarheiten

[abcman]

Hallo allerseits

Ich komme bei einer Aufgabe nicht weiter, wo es darum geht einen Stack zu programmieren.
Die eigentliche Frage findet ihr ganz unten. Aber ich muss etwas ausholen um die Ausgangslage zu erklären.
Am besten zeige ich euch kurz die vorherige Aufgabe. Hier war mir noch alles klar:

public class stack {
    private Object[] oA = new Object[5];
    private int pos = 0; // nächste Einfügeposition

    public void push(Object obj) {

        if (pos == oA.length) {
            Object[] oATemp = new Object[2 * oA.length]; // 1) neues Array
            for (int i = 0; i < oA.length; i++) { // 2) alte Referenzen Sichern
                oATemp[i] = oA[i];
                oA = oATemp; // 3) in Klasse neuen Array verwenden
                System.out.println("Länge des neuen Array; " + oA.length);

            }
        }

        oA[pos] = obj; // obj in oA aufnehmen
        pos++; // pos erhöhen

    }

    public Object pop() {
        Object o = oA[pos - 1]; // 3-Zeiler ist als ...
        pos--; // 1-Zeiler formulierbar
        return o;
    }

    public Object peek() {
        return oA[pos - 1]; // noch keine Ausnahmebehandlung
    }

    public void clear() { // noch zu implementieren
    }

    public boolean isEmpty() {
        return pos == 0;
    }
}

public class stackTest {

    public static void main(String[] args) {
        stack s = new stack();
        s.push("1Hallo");
        s.push("2Huhu");
        s.push("3sfdf");
        s.push("4aslfjl");
        s.push("5sdfsd");
        s.push("6sdfsd");
        
    
        System.out.println(s.peek());

        System.out.println( s.isEmpty());
        //Test der anderen Methoden ...

    }

}

Bei der jetzigen Aufgabe muss ich aber mit weiteren Klassen, Expections und Interfaces arbeiten, was mich etwas verwirrt. Ich habe euch die Aufgabe etwas zusammengefasst:


1. Methoden im Interface Stack zusammenfassen und dieses Interface durch die Klasse ArrayStack implementieren.
2. Beim Stack-Überlauf soll eine StackException ausgelöst werden, ebenso, wenn mittels pop() oder peek() auf einen leeren Stack zugegriffen wird.
3.Neben dem parameterlosen Konstruktor auch einen zur Verfügung, mit dem die initiale Grösse des Arrays angegeben werden kann.
4. Eine weitere Implementierung ArrayDynStack erstellen, in der der interne Array neu angelegt wird, falls die ursprünglich gewählte Grösse nicht
ausreicht.
5. um nicht alle Methoden neu implementieren zu müssen, das Prinzip der vererbung einsetzen (ArrayDynStack ist Subklasse von ArrayStack,
um von abgeleiteten Klassen Zugriff auf Attribute zu ermöglichen, werden diese als protected spezifiziert).

Tipp: Die einzig kritische Stelle bei der nicht-dynamischen Implementierung besteht in der Methode push(), so dass lediglich diese Methode zu
überschreiben ist. Falls der Array vollständig belegt ist, legen Sie einen neuen (z.b. um 10 grösseren) an, kopieren die ‚alten’ Werte und stellen die interne
Referenzvariable auf den neu angelegten Array um.
Testen Sie die erstellten Klassen intensiv innerhalb einer Klasse StackTest.



Und hier ist mein aktueller Code:

ArrayStack

class ArrayStack implements Stack{
    private Object[] arr = new Object[1]; //Array-Objekt erstellen
    private int pos = 0; //Einfügeposition für push()

    public void clear(){ //Array leeren
        pos = 0;
    }
    public boolean isEmpty(){ //Überprüfen ob Array leer ist, falls ja "true" zurückgeben
        return pos==0;
    }
    public void push( Object o ){
        if( pos==arr.length){ //Wenn Arraygrösse erreicht...
            if( pos==arr.length ) throw new StackException("Überlauf"); //Erwartung "Überlauf" an StackException weiterleiten
        }
        arr[pos++] = o; //Arrayposition um 1 erhöhen
    }
    public Object pop(){ //Obersten Eintrag anzeigen und wegnehmen
        pos--;
        return arr[pos];
    }
    public Object peek(){
        return arr[pos-1]; //Obersten Eintrag anzeigen
    }
    
}

DynArrayStack

public class DynArrayStack extends ArrayStack implements Stack {
    
public DynArrayStack(){ }

public DynArrayStack( int size ){ super(size); }
public void push(Object obj) { //einzige zu überschreibende Methode
    Object[] neu = new Object[ arr.length*2 ];   //1
    for( int i=0; i<arr.length; i++ )             //2
      neu[i] = arr[i];                          //2
   arr = neu;                                   //3
}
}

Stack (interface)

interface Stack {

    public void clear();

    public boolean isEmpty();

    public void push(Object o);

    public Object pop();

    public Object peek();

}

StackException

public class StackException extends RuntimeException {
public StackException( String s ) { super( s ); }


public StackException(){}
}

StackTest

public class StackTest {
    public static void main(String[] args) {
        Stack s = new ArrayStack();
        s.push("1.Hallo");
        s.push("2.Test");
        s.push("3.Berlin");
        s.push("4.Helikopter");
        System.out.println( s.peek() );
        System.out.println( s.pop() );
        System.out.println( s.peek() );
        System.out.println( s.isEmpty() );
        System.out.println( s.pop() );        
        System.out.println( s.isEmpty() );
    }

}

Zur Zeit stecke ich beim Punk 2 fest.
Auf einer Turorialseite habe ich gesehen, dass die Exceptions für Erwartete Fehler gedacht sind. Also wäre für mich logisch, wenn man in der Array Stack bei der methode "push" die StackException ankicken würde.Dies mit der Anweisung "throw new StackException("Überlauf")"

In der StackExeption wäre dann definiert wie der Überlauf funktioniert und, dann müsste man das per Catch in die Array Stack zurückholen.
Sehe ich das richtig? Hatt mir jemand einen Tipp?

 

[Gucky]

Eine Exception ist nur eine Meldung dass da etwas schief gelaufen ist. Diese Information ist für den Aufrufer gedacht und der hat damit fertig zu werden. Nicht der Stack selber.