Array in Subklasse - Werte aus Superklasse

[abcman]

Hallo
Ich versuche eine Aufgabe zu lösen, und bin mir bei einem Teil nicht ganz sicher, ob ich es richtig verstanden habe:

"Erstellen Sie eine weitere Implementierung ArrayDynStack, in der der interne Array neu angelegt wird, falls die ursprünglich gewählte Grösse nicht
ausreicht. Setzen Sie das Prinzip der Vererbung ein, um nicht alle Methoden neu implementieren zu müssen (ArrayDynStack ist Subklasse von ArrayStack,
um von abgeleiteten Klassen Zugriff auf Attribute zu ermöglichen, werden diese als protected spezifiziert)"

Ich verstehe das so:
1. In der SuperKlasse ArrayStack befindet sich das erste Array mit einer fixen grösse.
2. Wenn, dieses Array überfüllt wird, wird in der SubKlasse ein zweies Array erstellt (z.B. doppelt so gross wie Array1)

Ich habe mal versucht, die Arraygrösse mit dem prinzip der Vererbung anzugeben.

public class vSubKlasse extends vSuperKlasse {

    public vSubKlasse(int i){
        super(i);
        Object[] myArray = new Object[i]; //Array erstellen    
         System.out.println("Länge des neuen Array; " + myArray.length);
        int pos;
        
        
}


}

public class vSuperKlasse {

    public vSuperKlasse(int i){
        this.i = i+1;

    }
    public int i;
}

Bin ich auf dem richtigen Weg oder habe ich grundsätzlich etwas falsch verstanden?
Danke für eure Antworten...

 

[knilch]

Hi,

1. In der SuperKlasse ArrayStack befindet sich das erste Array mit einer fixen grösse.

Ich denke schon, ja.

2. Wenn, dieses Array überfüllt wird, wird in der SubKlasse ein zweies Array erstellt (z.B. doppelt so gross wie Array1)

wäre eine variante, aber ist nicht immer Sinnvoll, wenn du z.b. ein Array von 10000 Objects als Initial hast und dann nur vielleicht ein Array für 12000 Objects brauchst, dann ist das neue Array einfach zu gross. Damit hast du immer ein Lineares Wachstum von der Array-Grösse.

Du schreibst:

...werden diese als protected spezifiziert...

und deklarierst i in der Superklasse als public..

Hier mal eine mögliche Implementation.
In der Superklasse deklarierst du ein Object-Array mit einer Initial-Grösse.
Falls die Grösse vom ArrayDynStack- Array grösser als die Initial-Grösse wird ein neues Object-Array angelegt.
In etwa so etwas:

public class SuperKlasse {
    private Object[] oArry;
    private int initialSize = 10;
    
    public SuperKlasse() {
        oArry = new Object[initialSize];
    }
    
    public SuperKlasse(int size) {
        oArry = new Object[size];
    }
    
    protected Object[] getoArry() {
        return oArry;
    }
    
    protected void setOArray(Object [] oArry) {
        this.oArry = oArry;
    }
    
    protected int getInitialSize() {
        return initialSize;
    }
    
    protected void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }
    
    protected void showArraySize() {
        System.out.println(oArry.length);
    }

    protected void showItems() {
        for (Object object : oArry) {
            System.out.println(object.toString());
        }
    }
    
    protected void methode1() {
        System.out.println("mach etwas anderes ");
    }
    
    /**
     * weitere Methoden...
     */
    
}

public class SubKlasse extends SuperKlasse{

    public SubKlasse(int size) {    
        if(size > super.getInitialSize()) {
            Object [] newOArray = new Object[size];
            // event. muss noch eine Logik implementiert werden um den Inhalt vom bisherigen Array in das neue, grössere Array zu kopieren.                            
            CopyArrayItemsToNewArray(super.getoArry(), newOArray);
            super.setOArray(newOArray);
        }
    }
    
    private void CopyArrayItemsToNewArray(Object [] oldObjectArray, Object [] newObjectArray) {
        for (int i = 0; i < oldObjectArray.length; i++) {
            newObjectArray[i] = oldObjectArray[i];
        }
    }
    
    /**
     * hier können noch methoden erstellt werden die nur auf Instanzen von SubKlasse ausgeführt werden sollen, 
     * oder Methoden von SuperKlasse werden hier überschrieben, falls notwendig
     */
}

 

[abcman]

hallo knilch, vielen Dank für deine ausführliche Antwort.
Dein Beispiel sieht sehr interessant aus!
Ich habe nun daran noch weiter herumexperimentiert.
Fürs Testen habe ich die "TestKlasse" erstellt.

Um werte ins Array einzubauen, habe ich das Programm mit der Push-Methode ergänzt.

Beim Testen habe ich ein Array mit Intialgrösse 3 erstellt und dann 4 Werte eingegeben.
Dies gab jedoch einen Fehler.

3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at SuperKlasse.push(SuperKlasse.java:46)
at TestKlasse.main(TestKlasse.java:12)

Irgendwie kapiert es das mit dem Array-Vergrössert noch nicht.
Müsste ich bei der SubKlasse die If-Abfrage noch mit dem Attribut "pos" ergänzen?

public class SuperKlasse {
    private Object[] oArry;
    private int initialSize = 3;
    private int pos; //gibt beim Einfügen neuer Werte, die Position an
 
    public SuperKlasse() { //Konstruktor: Kein Grössenwert wird mitgeliefert, also erstellt es ein Array mit der Initialgrösse
        oArry = new Object[initialSize];
    }
 
    public SuperKlasse(int size) {//Konstruktor: Hier wird ein Grössenwert mitgeliefert und ein Array mit dieser Grösse erstellt
        oArry = new Object[size];
    }
 
    protected Object[] getoArry() {// Hier wird das Objekt oArry weitergegeben mit protected
        return oArry;
    }
 
    protected void setOArray(Object [] oArry) {
        this.oArry = oArry;
    }
 
    protected int getInitialSize() {//Initialgrösse wird witergegeben (an SubKlasse)
        return initialSize;
    }
 
    protected void setInitialSize(int initialSize) {//InitialSize Wert von dieser Klasse weitergegeben
        this.initialSize = initialSize;
    }
 
    protected void showArraySize() {//Zeigt die Arraygrösse an
        System.out.println(oArry.length);
    }
 
    protected void showItems() {//Zeigt den Intalt des Arrays
        for (Object object : oArry) {
            System.out.println(object.toString());
        }
    }
 
    protected void methode1() {
        System.out.println("mach etwas anderes ");
    }
    
    
    protected void push(Object obj){//Werte in Array eingeben
        oArry[pos] = obj; // obj in oA aufnehmen
        pos++; // pos erhöhen
        
    }
    
    
    protected Object peek() {
        return oArry[pos - 1]; // noch keine Ausnahmebehandlung
    }
 
    /**
     * weitere Methoden...
     */
 
}

public class SubKlasse extends SuperKlasse{
 
    public SubKlasse(int size) {    
        if(size > super.getInitialSize()) {
            Object [] newOArray = new Object[size];
            // event. muss noch eine Logik implementiert werden um den  Inhalt vom bisherigen Array in das neue, grössere Array zu kopieren.                             
            CopyArrayItemsToNewArray(super.getoArry(), newOArray);
            super.setOArray(newOArray);
        }
    }
 
    private void CopyArrayItemsToNewArray(Object [] oldObjectArray, Object [] newObjectArray) {
        for (int i = 0; i < oldObjectArray.length; i++) {
            newObjectArray[i] = oldObjectArray[i];
        }
    }
 
    /**
     * hier können noch methoden erstellt werden die nur auf Instanzen von SubKlasse ausgeführt werden sollen, 
     * oder Methoden von SuperKlasse werden hier überschrieben, falls notwendig
     */
}

public class TestKlasse {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SubKlasse object = new SubKlasse(3);
        object.setInitialSize(3);
        System.out.println(object.getInitialSize());
        object.push("hallo1");
        object.push("hallo2");
        object.push("hallo3");
        object.push("hallo4");
        System.out.println(object.peek());
        
        
        object.showArraySize();

    }
    

}

 

[AntiMuffin]

Hallo,
du musst deine push Methode in der Subklasse überschreiben, die sollte dann ca. so aussehen:

@Override
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[oArray.length * 2];           // neue größe - hier doppelt so groß              
            CopyArrayItemsToNewArray(super.getoArry(), newOArray);
            super.setOArray(newOArray);
       }
        oArry[pos] = obj; // obj in oA aufnehmen
        pos++; // pos erhöhen
        
    }

P.S. Evtl noch in eigene private Methode auslagern da im Konstruktor das gleiche passiert.
Gruß,
AntiMuffin

 

[abcman]

Cool! Funkioniert. Besten Dank!