# generischer stack



## tearsen (14. Mai 2007)

hi.. ich lerne java grade aufgrund meines informatik studiums und sitze vor folgendem problem.
wir sollen einen stack programmieren (an sich eigentlich kein problem), allerdings sollen die elemente des keller von einem generischem datentyp sein. ausserdem sollen wir keine fremden klassen importieren.

bislang habe ich drei klassen:
ein interface, vom prof vorgegeben:

```
interface ADTStack<T> {
	boolean isEmpty();
	int size();
	T top();
	void push(T x);
	void pop();	
	String toString();
}
```

Element.java (um die Elemente zu erstellen):

```
public class Element<T> { 

  public T daten;

  public void setValue(T daten) {
    this.daten = daten;
  }

  public T getValue() {
    return this.daten;
  }
}
```

und LinkedListStack.java (der Hauptteil, der ADTSack implementiert):

```
public class LinkedListStack implements ADTStack {
	public LinkedListStack next;
	public Element firstElement = new Element();
	public int size;
	
	public LinkedListStack() {
		firstElement = null;
		next = null;
		size = 0;
	}	
	
	public void push(T x){
		LinkedListStack l = new LinkedListStack();
		l.next = next;
		next = l;
		firstElement = next;
		size += size;
	}	
	
	public boolean isEmpty() {
		return firstElement == null;
	}
	
	public int size() {
		return size;
	}
	
	public T top() {
		return firstElement;
	}


	public void pop() {
		next = next.next;		
		firstElement = next;
		size -= size;
	}

	public String toString() {
		return daten + "";
	}
}
```

wenn ich das nun in den compiler schicke sagt er ich das push(T x) nicht überlagert wird. dabei ist das doch der fall so wie ich das sehe ?! danke schonmal für eure hilfe


----------



## SlaterB (14. Mai 2007)

deine Klassendefinition entspricht nicht dem Standard,

entweder du legst T fest
public class LinkedListStack implements ADTStack<String> {

oder reichst T weiter
public class LinkedListStack<T> implements ADTStack<T> {


----------



## Presi (20. Mai 2007)

size += size; 

was soll das bringen ;-)

++size bzw. --size soll das wohl heissen sonst wird es immer 0 bleiben.


mfg jemand der das gleiche wie du studiert an der gleichen uni wohl


----------



## Guest (20. Mai 2007)

Mach's einfach
	
	
	
	





```
final class LinkedListStack<T> implements ADTStack<T>
{
   private StackElement<T> top;
   private int size;
   
   public LinkedListStack()
   {
   }

   public void push(T x)
   {
      top = new StackElement<T>(top, x);
      size++;
   }

   public void pop()
   {
      if(top == null)
      {
         throw new IllegalStateException("Stack is empty");
      }
      top = top.next;
      size--;
   }

   public T top()
   {
      if(top == null)
      {
         throw new IllegalStateException("Stack is empty");
      }
      return top.value;
   }

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

   public int size()
   {
      return size;
   }

   private class StackElement<E>
   {
      StackElement<E> next;
      E value;
      
      public StackElement(StackElement<E> next, E value)
      {
         this.next = next;
         this.value = value;
      }
   }
   
}
```


----------

