Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo aller seits
Ich habe meiner Klasse LinkedStack implementiert ich soll es so erweitern um generische Typen so das es mit meine andere Klasse Animal typisiert ist.
Das problem ich weiss nicht wie ich vorgehen? was muss ich in meiner Klasse ändern
Bin sehr dankbar für jede Hilfe:
Java:
public class LinkedStack {
private List<Object> stack;
public LinkedStack(){
stack = new LinkedList<Object>();
}
/**
* push bekommt ein object und speichert es in das Stack
* of pages of the book.
*
* @param value
*/
public Object push (Object value){
stack.add(value);
return value;
}
/**
* pop liefert das Element am obersten und entfernt es aus dem Stack
*
*/
public Object pop(){
int i = stack.size();
if(isEmpty())
throw new EmptyStackException();
Object top = stack.get(i-1);
stack.remove(i-1);
return top;
}
/**
* peek liefert das Element am obersten Also "TOP"
*
*
*
*/
public Object peek(){
int i = stack.size();
if(isEmpty())
throw new EmptyStackException();
Object top = stack.get(i-1);
return top;
}
/**
* isEmpty liefert "true" wenn es leer ist!!
*
*/
public boolean isEmpty(){
int i = stack.size();
if (i== 0){
return true;
}
else{
return false;
}
}
/**
* toString ein leeren String
*
*/
public String toString(){
return "";
}
}
Die Klasse Animal
Java:
public class Animal {
/** Der Name des Tieres. */
private String name;
/**
* Custom-Konstruktor zur Erzeugung eines Tieres.
*
* @param name der Name des Tieres
*/
public Animal(String name) {
this.name = name;
}
/**
* Liefert den Namen des Tieres.
*
* @return der Name des Tieres
*/
public String getName() {
return name;
}
/**
* Liefert das Tier als String.
*
* @return das Tier als String
*/
@Override
public String toString() {
return this.getName();
}
}
soll der Stack fest mit Animal verdrahtet sein ? oder soll die Klasse LinkedStack noch generisch bleiben.
2. loesung waere dann in etwa
Java:
public class LinkedStack<T> {
private List<T> stack;
public LinkedStack(){
stack = new LinkedList<T>();
}
/**
* push bekommt ein object und speichert es in das Stack
* of pages of the book.
*
* @param value
*/
public T push (T value){
stack.add(value);
return value;
}
/**
* pop liefert das Element am obersten und entfernt es aus dem Stack
*
*/
public T pop(){
int i = stack.size();
if(isEmpty())
throw new EmptyStackException();
T top = stack.get(i-1);
stack.remove(i-1);
return top;
}
/**
* peek liefert das Element am obersten Also "TOP"
*
*
*
*/
public T peek(){
int i = stack.size();
if(isEmpty())
throw new EmptyStackException();
T top = stack.get(i-1);
return top;
}
/**
* isEmpty liefert "true" wenn es leer ist!!
*
*/
public boolean isEmpty(){
int i = stack.size();
if (i== 0){
return true;
}
else{
return false;
}
}
/**
* toString ein leeren String
*
*/
public String toString(){
return "";
}
}
aufruf waere dann fuer Animal:
Java:
LinkedStack<Animal> stack = new LinkedStack<Animal>();
ansonsten ueberdenk nochmal deine implementierung... z.b. benutzt du eine LinkedList, sprichst die elemente dann aber ueber get(index) an, was sehr ungut (unperfomant) ist - LinkedList bietet hierfuer methoden (getFirst / getLast etc)
Danke für die Schnelle Antwort,
Ich habe einer Frage wie würde die Deklaration der LinkedStack aussehen, wenn die Klasse Animal der Upper Bound für mögliche Typen sein soll, die in den formalen Typparameter eingesetzt werden dürfen?
