ArrayQueue mit Exceptions und Vererbung

[abcman]

Hallo allerseits,
seit einiger Zeit bastle ich an einer Aufgabe herum. Ich dachte bereits, das alles funktioniert, aber nun habe ich den Code wahrscheinlich doch vermurkst, sprich ich finde den Fehler nicht.
Das füllen, leeren und Inhaltabfragen der Queue funktioniert einwandfrei.

Aber wenn die Queue voll ist (Arrayinitialgrösse überschritten), müsste in einer Subklasse ein zweites Array angelegt und die Inhalte hinein kopiert werden. Ich habe auch bereits probiert die Exception auszuklammern, ohne Erfolg.


Kann mir jemand weiterhelfen?

public class ArrayQueue implements Queue {
 protected Object[] OA = new Object[2];
 protected int pos = 0; // nächste Einfügeposition
 public ArrayQueue(int size) {// Konstruktor bei dem man zusätzlich die Array-Grösse mitgibt
  super();
  OA = new Object[size];//Array wird mit dieser grösse erstellt  
 }
 public void put(Object obj) {//Daten ins Array einlesen  
  if (pos==OA.length) throw new QueueExeption("Überlauf");//Wenn das Array voll ist, Exeption auslösen (Fehlermeldung "Überlauf")
  OA[pos] = obj; // obj in OA aufnehmen
  pos++; // pos erhöhen
 }
 public  Object get() {//Objekt aus der Queue anzeigen und herausnehmen.
  if (pos==0){
   throw new QueueExeption("Leer");
  }  
  Object o = OA[0];
  pos--; //Position wieder um 1 reduzieren
  for (int i = 1; i < OA.length; i++) {
   
   Object object = OA[i];
   OA[i-1]=object;    
  }
  return o;  
  
  // Nachrücken der restlichen Elemente, Aktualisieren von pos 
 }
    protected void showArraySize() {//Zeigt die Arraygrösse an
         System.out.println("Arraygrösse: " + OA.length);
     }
 
 
 public Object peek() {
  return OA[0]; // noch keine Ausnahmebehandlung
 }
 
    protected Object[] getOA() {// Hier wird das Objekt OArry weitergegeben mit protected
        return OA;
    }
    
    protected void setOA(Object [] OA) {
        this.OA = OA;
    }
 
 public void clear() { // noch zu implementieren
  pos=0;
  
  for (int i = 0; i < OA.length; i++) { //Alle Stellen im Array durchgehen.
    OA[i]= null; //Entsprechende Arrayposition auf 0 setzen   
  }
 }
 public boolean isEmpty() {//Wahr/Falsch-Wert zurückliefern, ob Array leer ist oder nicht.
  return pos == 0;
 }
}

public class DynArrayQueue extends ArrayQueue {
 public DynArrayQueue(int size) {
  super(size);  
 }
 /*@Override
 public void put(Object obj) {
  // TODO Auto-generated method stub
  super.put(obj);
 }
*/ 
 
  public void put(Object obj){//Werte in Array eingeben      
   super.put(obj);
   System.out.println("Subklasse_TEST");
         if (pos == OA.length -1){
 //Wenn beim einfügen die Größe nicht ausreicht vergrößern
             Object [] newOArray = new Object[OA.length * 2];           // neue größe - hier doppelt so groß              
             CopyArrayItemsToNewArray(super.getOA(), newOArray);
             super.setOA(newOArray);
        }
         OA[pos] = obj; // obj in OA aufnehmen
         int i = pos++; // pos erhöhen
  
     }    
 
 private void CopyArrayItemsToNewArray(Object [] oldObjectArray, Object [] newObjectArray) {
        for (int i = 0; i < oldObjectArray.length; i++) {
            newObjectArray[i] = oldObjectArray[i];
        }
    } 
}
/*
protected void push(Object obj){//Werte in Array eingeben
    if (pos == OArry.length -1){
//Wenn beim einfügen die Größe nicht ausreicht vergrößern
        Object [] newOArray = new Object[OArry.length * 2];           // neue größe - hier doppelt so groß              
        CopyArrayItemsToNewArray(super.getOArry(), newOArray);
        super.setOArray(newOArray);
   }
    OArry[pos] = obj; // obj in OA aufnehmen
    int i = pos++; // pos erhöhen
}*/

public class queueTest {
 public static void main(String[] args) {
  ArrayQueue q = new ArrayQueue(3);
 q.put("1hallo");
 q.put("2velo");
 q.clear();
 q.put("3auto");
 q.put("4auto"); 
 q.put("5auto"); 
 q.put("6auto"); 
 
 System.out.println(q.get());
 System.out.println(q.get());
 q.showArraySize();

 }
}

public class QueueExeption extends RuntimeException {
 public QueueExeption(String string) {
  super(string);
 }
}

public interface Queue {
 public void put(Object o);
 
 public Object get();
 
 public void clear();
 public boolean isEmpty();
}

 

[Flown]

Geschweige davon, dass man einiges anders/besser machen kann rufst du nur in deiner Kindsklasse super.put(obj); falsch auf:

Diese sollte so aussehen:

@Override
public void put(Object obj) {// Werte in Array eingeben
  if (pos == OA.length) {
    Object[] newOArray = new Object[OA.length * 2]; // neue größe - hier
    CopyArrayItemsToNewArray(super.getOA(), newOArray);
    super.setOA(newOArray);
  }
  super.put(obj);
}

 

[abcman]

Danke Flown für deine schnelle Antwort.
Ich habe die Kindsklasse nun angepasst. Aber es gibt immer noch den gleichen Fehler.

public class DynArrayQueue extends ArrayQueue {


    public DynArrayQueue(int size) {
        super(size);
        
    }


    /*@Override
    public void put(Object obj) {
        // TODO Auto-generated method stub
        super.put(obj);
    }
*/    
    
    /* public void put(Object obj){//Werte in Array eingeben
         
         
        super.put(obj);
         System.out.println("Subklasse_TEST");
         if (pos == OA.length -1){
 //Wenn beim einfügen die Größe nicht ausreicht vergrößern
             Object [] newOArray = new Object[OA.length * 2];           // neue größe - hier doppelt so groß              
             CopyArrayItemsToNewArray(super.getOA(), newOArray);
             super.setOA(newOArray);
        }
         OA[pos] = obj; // obj in OA aufnehmen
         int i = pos++; // pos erhöhen
  
     }
     */
    
    
         
         @Override
         public void put(Object obj) {// Werte in Array eingeben
           if (pos == OA.length) {
             Object[] newOArray = new Object[OA.length * 2]; // neue größe - hier
             CopyArrayItemsToNewArray(super.getOA(), newOArray);
             super.setOA(newOArray);
           }
           super.put(obj);
         }
    
    
    private void CopyArrayItemsToNewArray(Object [] oldObjectArray, Object [] newObjectArray) {
        for (int i = 0; i < oldObjectArray.length; i++) {
            newObjectArray[i] = oldObjectArray[i];
        }
    }
    
    
    
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
    at ArrayQueue.put(ArrayQueue.java:16)
    at queueTest.main(queueTest.java:13)

ArrayQueue: 16 => Superklasse put methode (siehe unten)
queueTest.java:13 => in der Test-Klasse wo man das Array zum überlaufen bringt




Muss ich in der Superklasse bei der If-Bedingung noch etwas anpassen?

      public void put(Object obj) {//Daten ins Array einlesen        
        if (pos==OA.length) //;//Wenn das Array voll ist, Exeption auslösen (Fehlermeldung "Überlauf")
        OA[pos] = obj; // obj in OA aufnehmen
        pos++; // pos erhöhen
        //throw new QueueExeption("Überlauf"); Exception ausgeklammert 
    }

 

[Flown]

Naja du solltest auch die Implementierung für die dynamisch große Queue auch nehmen.
In deiner main-Methode:

ArrayQueue q = new DynArrayQueue(3);