Fehler: inkompatible Typen: java.lang.Object kann nicht in E konvertiert werden

Question

Völlig fest auf diesem Fehler. Hier ist die Klasse, von der der Fehler kommt.

/** An array-based Stack. */  
public class ArrayStack<E> implements Stack { 

/** Array of items in this Stack. */ 
private E[] data; 

/** Number of items currently in this Stack. */ 
private int size; 

/** The Stack is initially empty. */ 
public ArrayStack() { 
data = (E[])(new Object[1]); // This causes a compiler warning 
size = 0; 
} 

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

public Object pop() { 
if (isEmpty()) { 
throw new EmptyStructureException(); 
} 
size--; 
return data[size]; 
} 

public Object peek() { 
if (isEmpty()) { 
throw new EmptyStructureException(); 
} 
return data[size - 1]; 
} 

/** Return true if data is full. */ 
protected boolean isFull() { 
return size == data.length; 
} 

public void push(Object target) { 
if (isFull()) { 
stretch(); 
} 
data[size] = target; 
size++; 
} 

/** Double the length of data. */ 
protected void stretch() { 
E[] newData = (E[])(new Object[data.length * 2]); // Warning 
for (int i = 0; i < data.length; i++) { 
newData[i] = data[i]; 
} 
data = newData; 
} 
} 

Hier ist die Stack-Klasse nur für den Fall es gebraucht wird:

/** A last-in, first-out stack. */ 
public interface Stack<E> { 

/** Return true if this Stack is empty. */ 
public boolean isEmpty(); 

/** 
* Return the top item on this Stack, but do not modify the Stack. 
* @throws EmptyStructureException if this Stack is empty. 
*/ 
public E peek(); 

/** 
* Remove and return the top item on this Stack. 
* @throws EmptyStructureException if this Stack is empty. 
*/ 
public E pop(); 

/** Add target to the top of the Stack. */ 
public void push(E target); 

} 

Der Fehler ist in Bezug auf die Linie data[size] = target; in der ArrayStack Klasse, in der Push (Object target) Methode.

Answer 1

Try this: 


/** 
* An array-based Stack. 
*/ 
public class ArrayStack<E> implements Stack<E> { 

/** 
* Array of items in this Stack. 
*/ 
private E[] data; 

/** 
* Number of items currently in this Stack. 
*/ 
private int size; 

/** 
* The Stack is initially empty. 
*/ 
public ArrayStack() { 
    data = (E[]) (new Object[1]); // This causes a compiler warning 
    size = 0; 
} 

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

public E pop() { 
    if (isEmpty()) { 
     throw new RuntimeException(); 
    } 
    size--; 
    return data[size]; 
} 

public E peek() { 
    if (isEmpty()) { 
     throw new RuntimeException(); 
    } 
    return data[size - 1]; 
} 

/** 
* Return true if data is full. 
* 
* @return 
*/ 
protected boolean isFull() { 
    return size == data.length; 
} 

public void push(E target) { 
    if (isFull()) { 
     stretch(); 
    } 
    data[size] = target; 
    size++; 
} 

/** 
* Double the length of data. 
*/ 
protected void stretch() { 
    E[] newData = (E[]) (new Object[data.length * 2]); // Warning 
    for (int i = 0; i < data.length; i++) { 
     newData[i] = data[i]; 
    } 
    data = newData; 
} 
} 

Answer 2

Ziel und Daten sind nicht vom selben Typ. Sie können E verwenden, wo immer Sie einen Typ benötigen. Dies macht Ihren Code typsicherer.

ändern der Push-Methode:

public void push(E target) { 
if (isFull()) { 
    stretch(); 
} 
data[size] = target; 
size++; 
} 

Answer 3

data[size] = target; 

1) Hier bezieht sich auf E arraydata und target bezieht sich auf Object.
Generics bringt Typ Sicherheit. So können Sie nicht nicht von konvertieren Objekt zu E.

2) public class ArrayStack<E> implements Stack {

ist nicht korrekt, weil Sie nicht den parametrisierte Typen für die Schnittstelle zur Verfügung stellen Sie Sie implementieren.
Schreiben public class ArrayStack<E> implements Stack<E> { wäre sicherer und wird Sie zwingen, die Stack Methoden zu implementieren, indem Sie den parametrisierten Typ in den Stack Methoden verwendet. Zum Beispiel: public void push(E target);

3) Um zu erklären parametrisierte Typen in ArrayStack entsprechen sollten Sie den parametrisierte Typen in Ihrer Methode statt Object verwenden sollten.

so sollten Sie

public void push(Object target) { 

von

public void push(E target) { 

ersetzen Und Sie sollten in allen Methoden das gleiche tun Sie, dass die angegebene Typ deklarieren manipulieren Object statt E. Zum Beispiel:

public Object peek() 

und

public Object pop() { 

Answer 4

Da Ihre Daten Array vom Typ E ist:

private E[] data; 

Sie müssen ändern:

public void push(Object target) { 

Parametertyp haben E.

E kann String, Integer usw. zur Laufzeit bestimmt werden. Das Objekt entspricht nicht dem Laufzeittyp.