Stack mit Oberklasse, wieso funktioniert es nicht?

[xyt4n]

Hallo,

ich hab eine Aufgabe auf, die ich auch schon fast fertig habe, aber beim testen habe ich eine riesige Fehlermeldung bekommen, die ich nicht verstehe.

Ich schätze das irgendwie ein "loop" im Konstruktor ausversehen eingebaut wurde.

Wäre super nett, wenn ihr drüber schauen würdet, ich muss es morgen abgeben :/

Erstellen Sie eine abstrakte Klasse Stack mit den abstrakten Methoden

• public abstract Stack push(short x)
• public abstract short top()
• public abstract int size()

und den /nicht abstrakten) Methoden

• public Stack pop(Stack x),
• public boolean isEmpty(),
• public boolean isEntry()

Der Stack hat ebenfalls die Methoden

• int compareTo(Stack x), die den Stack und den Stack x lexikofrafisch vergleicht, < (Ausgabe -1), gleich (Ausgabe 0), > (Ausgabe 1)
• int equals(Stack x) testet die bei compareTo definierte Gleichheit.
Erstellen Sie die abgeleitete Klasse EntryStack extends Stack (Stack aus short-Entries).

public class EntryStack extends Stack {

	private short value;
	private EntryStack next;

	public EntryStack(short value) {
		super(value);
	}

	public Stack push(short value) {
		EntryStack e = new EntryStack(value);
		setValue(value);
		setNext(null);
		if (getLast() == null)
			setLast(e);
		getFirst().next = e;
		setFirst(e);
		return getFirst();
	}

	public short top() {
		return (short) getFirst().value;
	}

	public int size() {
		int i = 1;
		EntryStack zeiger = new EntryStack((short) 0);
		if (getLast() == null)
			return 0;
		for (zeiger = getLast(); zeiger.getNext() != null; zeiger = zeiger
				.getNext())
			i += 1;
		return i;
	}

	public short getValue() {
		return value;
	}

	public void setValue(short value) {
		this.value = value;
	}

	public EntryStack getNext() {
		return next;
	}

	public void setNext(EntryStack next) {
		this.next = next;
	}

}

public abstract class Stack {

	private EntryStack first;
	private EntryStack last;

	public Stack(short value) {
		push(value);
	}

	public abstract Stack push(short x);

	public abstract short top();

	public abstract int size();

	public Stack pop(Stack x) {
		EntryStack zeiger;
		if (getLast() == null)
			return getFirst();
		for (zeiger = getLast(); zeiger.getNext().getNext() != null; zeiger = zeiger
				.getNext())
			setFirst(zeiger);
		zeiger.setNext(null);
		return getFirst();
	}

	public boolean isEmpty() {
		return last == null;
	}

	public boolean isEntry() { // fehlt
		return false;
	}

	public int compareTo(Stack x) { // nicht fertig

		EntryStack zeiger1;
		EntryStack zeiger2 = x.getLast();
		int i = 0;
		for (zeiger1 = getLast(); zeiger1.getNext() != null; zeiger1 = zeiger1
				.getNext()) {
			if (zeiger1 == null && zeiger2 == null)
				return 0; // Notwendig? Testen!
			if (zeiger1.getValue() < zeiger2.getValue())
				return -1;
			else if (zeiger1.getValue() == zeiger2.getValue()) {
				i += 1;
			} else if (zeiger1.getValue() > zeiger2.getValue())
				return 1;
		}
		return 0;
	}

	public int equals(Stack x) { // fehlt
		return 0;
	}

	public EntryStack getFirst() {
		return first;
	}

	public void setFirst(EntryStack first) {
		this.first = first;
	}

	public EntryStack getLast() {
		return last;
	}

	public void setLast(EntryStack Last) {
		this.last = last;
	}

}

public class MainS {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		EntryStack b = new EntryStack((short) 5);
		b.push((short) 1);
	}
}

Fehler:

Exception in thread "main" java.lang.StackOverflowError
	at Kevin.Programmieraufgabe.Stack.<init>(Stack.java:8)
	at Kevin.Programmieraufgabe.EntryStack.<init>(EntryStack.java:9)
	at Kevin.Programmieraufgabe.EntryStack.push(EntryStack.java:13)
	at Kevin.Programmieraufgabe.Stack.<init>(Stack.java:9)
	at Kevin.Programmieraufgabe.EntryStack.<init>(EntryStack.java:9)
	at Kevin.Programmieraufgabe.EntryStack.push(EntryStack.java:13)
	at Kevin.Programmieraufgabe.Stack.<init>(Stack.java:9)
.
.
.
.

 

[bone2]

EntryStack(v) ruft super(v) auf und Stack() ruft dann push(v) auf. Die erste Zeile im Push(v) ist new Entrystack(v).
Da ist dein loop.

 

[SlaterB]

> Wäre super nett, wenn ihr drüber schauen würdet, ich muss es morgen abgeben :/

viel wertvoller wäre, wenn du es selber erkennst, woran hapert es?
direkt aus dem Code ist eine Sache, aber der Fehler gibt doch genaue Anleitung:
> Stack.<init>(Stack.java:9)
<init> steht für Konstruktor, aber reicht ja auch die Zeilennummer, was passiert in Zeile 9?
der Konstruktor ruft push() auf,

was macht push() von EntryStack, Zeilennummer ist ja wieder angegeben?
erzeugt einen neuen EntryStack,
also wieder Stack-Konstruktor, wieder push() usw.

nicht klar?
wie der Loop zu durchbrechen ist musst du wissen, besser in Konstruktoren nichts machen, aber ok, einen Wert speichern will man wohl schon,
nur scheint push() dafür nicht geeignet, damit wird ja eher ein Nachfolger angelegt, der Wert soll doch wohl im eigenen Element bleiben?

natürlich kann man auch alles auf den ersten Nachfolger schieben,
> public short top() { return (short) getFirst().value; }
geht ja auch in die Richtung,
aber der erste Nachfolger muss dann nun wirklich was machen, nicht auch wieder auf seinen ersten Nachfolger schieben usw.,
du siehst den Loop bisher?

kann ich jetzt auf die Schnelle nicht lösen, da musst du grundsätzlich planen was wo passieren soll, Gesamtkonzept bedenken,
idealerweise erst auf Papier statt in Java,
was passiert beim Anlegen, wie viele Objekte sollen erstellt, wo der erste Value abgelegt werden?

 

[xyt4n]

Vielen Dank!

Ich dachte mein Konstruktor und der Oberklassen Konstruktor sei der loop, da ich mich mit vererbung noch nicht so gut auskenne. Hab es nicht gesehen, dass durch push es erst zum loop wurde.

Vielen Dank euch beiden!! Ich konnte das Problemganz einfach durch einen weiteren Konstruktoren für jeweils eine Klasse lösen.

 

[Timothy Truckle]

Vielen Dank euch beiden!! Ich konnte das Problemganz einfach durch einen weiteren Konstruktoren für jeweils eine Klasse lösen.

Ich stelle jetzt mal die Frage, die Du Dir hättest stellen sollen:

Warum wir in der Methode

push

ein neuer Stack erstellt?:idea:

Statt den die Fehrlerursache zu beseitigen hast Du 'ne Lösung gefrickelt...;(

bye
TT

 

[SlaterB]

es ist ja ein Verknüpfung von Elementen, so wie von LinkedList,
irgendwann muss durchaus ein neues Element erstellt werden, jeder kann nur einen Wert speichern

 

[Timothy Truckle]

es ist ja ein Verknüpfung von Elementen, so wie von LinkedList,
irgendwann muss durchaus ein neues Element erstellt werden, jeder kann nur einen Wert speichern

Ja, aber doch von den Elementen, nicht von der Liste selbst, die braucht man nur ein mal...

bye
TT

 

[SlaterB]

die Elemente sind Entrys, EntryStack, davon wird ein neues erzeugt, was anderes ist nicht da,
heißt in Listen auch ListEntry

ob von Stack geerbt werden muss und insgesamt alles gut durchdacht ist, das steht noch aus

 

[Landei]

[OT]

• int equals(Stack x) testet die bei compareTo definierte Gleichheit.

So eine Aufgabenstellung sollte man dem Urheber um die Ohren hauen. Wer equals-Methoden mit falscher Signatur schreibt, frisst auch kleine Kinder. Auch wenn es "geht", sollte so eine Stolperfalle von Anfang an vermieden werden.[/OT]