Cannot invoke....

[Br4ve]

Hallo ich habe ein wahrscheinlich total banales Problem mit meinem JavaCode und zwar soll ich ein Programm schreiben mit 2 Konstruktoren und einer Methode zum Rausfinden der vollen Arrayplätze...
Hier mein Code:

package storage;


public class VarArray {


    private int leereplaetze;
    private int[] speicher;
                           
    
    public VarArray() {
        speicher = new int[10];
    }
    public VarArray(int speichergroesse) {
        speicher = new int[speichergroesse];
    }
    public int getSize() {
        leereplaetze = 0;
        int truegroesse;
        for (int i = 0; i < speicher.length; i++) {
            if (speicher[i] == 0) {
                leereplaetze++;
            }
        }
        truegroesse = speicher.length - leereplaetze;
        return truegroesse;
    }
    public static void main(String[] args) {
        VarArray[] newarray = new VarArray[3];
       

        System.out.println(newarray.getSize());
    

    }
    
    
}

jez zeigt mein Eclipse mir allerdings in Zeile 32 "Cannot invoke getSize() on the array type VarArray[]" an. Was mache ich falsch? Ich verzweifel da seit mehreren Stunden dran...

 

[javimka]

Array haben kein getSize(), sondern ein .length

 

[Br4ve]

Ja das sagt mein Eclipse auch. Aber ich will ja nich die Arraylänge wissen, sondern die Anzahl der tatsächlich gespeicherten Elemente... Beispielsweise hab ichn int array mit 3 plätzen also int array[3]. Wenn ich da jez aber nur 2 integerwerte reintue sollte getSize mir 2 ausgeben...Während ich über array.length wieder 3 bekommen würde....

 

[javimka]

So wie du dir das vorstellst, funktioniert das nicht. Wenn du ein Array hast, sind auch sofort alle Plätze besetzt, entweder mit 0 oder null.

 

[Br4ve]

Also meine genaue Teilaufgabe lautet:
"int getSize() gibt die tatsächliche Anzahl von Elementen zurück, die in dem
Array gespeichert werden. I.d.R. wird das unterliegende Array durch Aufruf der
Konstruktoren bzw. von addElement größer als die tatsächliche Anzahl
gespeicherter Elemente sein"

Oder hab ich das iwie falsch verstanden dann, wenn das wie ich mir das dachte nicht geht...?

 

[Gelöschtes Mitglied 5909]

Du legst ein Array deines Objekts an das ein Array kapselt

new VarArray();

und nicht new VarArray[3];

oder dann vararray[0].getSize();

 

[Br4ve]

 public static void main(String[] args) {
        VarArray array1 = new VarArray();
       

        System.out.println(array1.getSize());
    

    }

habe den Code jez so geändert...nach dem letzten Post(danke dafür)...Das funktioniert auch, ich bekomme also 0 ausgegeben. ist dann ein array der größe 5 entsprechend "VarArray array1 = new VarArray(5);"? Wie bekomme ich denn jez aber da auch werte rein!? Geht das ohne eine entsprechende Methode?

 

[hdi]

Du musst halt ein Array in deiner Klasse kapseln:

class VarArray{

 private Object[] array;

 public VarArray(Object[] array){ 
     this.array = array;
 }

 public int getSize(){ 
     int count = 0;
     for(Object o : array){
          if(o != null){
              count++;
          }
      }
      return count;
  }
}

edit: Ich seh grad du brauchst noch so ne add-Methode, ja dann musst du davor eine Größe angeben, wobei dann der Klassenname nicht mehr passt da es nicht Variabel ist. Aber egal:

class VarArray{

 private Object[] array;

 public VarArray(int size){ 
     array = new Object[size];
 }

 public void addElement(Object o){
     int index = // finde ersten leeren Platz
     array[index] = o;
 }

 public int getSize(){ 
     int count = 0;
     for(Object o : array){
          if(o != null){
              count++;
          }
      }
      return count;
  }
}

 

[Br4ve]

Hm ja also ich kenn den Arraytyp Object blos hatten wir das noch nicht...so dass ich das dummerweise net nutzen darf. Ist das denn anders garnicht zu realisieren? :bahnhof:

 

[hdi]

Es geht ja gar nicht um den Datentyp der Daten. Du kannst ja auch ein int-Array machen zB. Nur halt dass du bei primitiven Typen nicht auf "null" prüfen kannst. Du musst dir dann halt selber überlegen wie du feststellst ob ein Fach leer ist oder nicht, zB im Konstruktor jedes Fach mit -1 belegen. Wenn nur positive Zahlen da rein sollen wäre das ja ok.
...es geht hier ja nur darum, dass du 2 Methoden schreiben sollst (addElement und getSize). Da ein Array keine Klasse ist, und damit auch schon gleich zwei mal diese Methoden nicht hat, musst du dir eine eigene Klasse schreiben, die intern halt ein Array verwaltet und diese Methoden anbietet und sinnvoll implementiert.

 

[Br4ve]

Hm ja die Methode addelement muss ich sowieso noch implementieren... nur erst sollten wir halt getsize machen wobei mir das jez wo ich drüber nachdenke iwie dumm vorkommt.
Also das mein Array keine Klasse ist, ist mir schon klar. Es istn Objekt von meiner Klasse VarArray... Und in den Konstruktoren sind es doch eig integer datentypen!? in dem Fall wäre es doch "eigentlich" richtig alle indexwerte auf == 0 zu prüfen, da dies die Standardbelegung ist, was wiederum auch nur Sinn macht, wenn man davon ausgeht, dass nie ein Wert selbst 0 ist.
Also wenn ich jetzt noch eine Methode schreibe die elemente (in dem fall integer werte hinzufügt) und ich davon ausgehe, dass 0 bedeutet dass Arrayfeld leer ist, sollte es doch funktionieren oder nicht?
Ich versteh jez auf jeden Fall schonmal deutlich mehr als vorher. DANKE!

 

[hdi]

Ja genau das ist alles richtig. Bei primitiven Typen ist es halt immer die Frage mit was man das initialisiert, wenn du sagst 0 soll kein "echter" Wert sein, dann sagst du das halt ^^

...was du aber dann tun solltest, zumindest wäre das schön (sprengt jetzt vllt die Aufgabenstellung oder dein Verständnis), in der addElement() auch aufpassen dass niemand von außen eine 0 setzen will:

public void addElement(int element) throws IllegalArgumentException{
    if(element == 0){
        throw new IllegalArgumentException();
    }
    // ansonsten passende Stelle suchen und einfügen, ein else ist nicht nötig da er nach dem throw rausgeht
}

Und der aufruf dann:

VarArray a = new VarArray(10);
int x = ...
try{
    a.addElement(x);
}
catch(IllegalArgumentException e){
    System.out.println("Der Wert "+x+" wird von dieser Methode nicht akzeptiert");
}

...und ich würde den Klassennamen ändern, denn deine Klasse repräsentiert ja gar nicht ein variables Array, die Länge ist ja nach wie vor fix. Also nenn sie lieber "EasyArray" oder sowas...

 

[Br4ve]

Hm Jain, es sprengt in dem Sinne mein Verständnis, weil wir die Befehle auch noch net kennen, aber kanns mir ungefähr vostellen was da passiert... Also der Klassenname ist in meiner Aufgabe vorgegeben. Und es soll noch Methoden geben später, die das Array erweitern...Aber damit hab ich mich nich net beschäftigt.
Dennoch vielen Dank, hast mi sehr geholfen.

 

[hdi]

Noch ne kleine Anmerkung, falls du die Klasse jetzt so lässt. Vergiss nicht die leeren Plätze im Konstruktor zu initialisieren, das haste im Code unten nicht getan:

public VarArray() {
// "delegiert" an den anderen Konstruktor, das macht man so wenn man mehrere Konstruktoren hat.
// Damit stellt man sicher dass man nicht in manchen Konstruktoren was anderes macht als in anderen.
     this(10); 
}
public VarArray(int speichergroesse) {
     speicher = new int[speichergroesse]; 
     leerePlaetze = speichergroesse; // !
}

 

[Br4ve]

Ist das denn zwingend notwendig? Also ich sehe grad nicht so recht warum das gemacht werden muss. Was hat das denn genau für Vorteile ?

 

[hdi]

Was meinst du jetzt? Das mit dem Initialisieren der leeren Plätze ist denke ich schon notwendig, zumindest sagt diese Variable ja genau das aus. Und anfangs sind doch alle leer. Ob es tatsächlich notwendig ist hängt von deiner Implementierung ab. Aber wenn du die Variable schon hast, dachte ich ist die halt auch genau dafür gut, und sollte immer den korrekten Wert haben, damit es nicht zu Fehlern kommt?!

Wenn du das mit den Konstruktoren meinst: Notwendig ist das nicht, der Vorteil ist dass man eben Fehler vermeidet und redundanten Code spart:

class ExtremeComplicatedClass{
   private Data data1, data2, data3;

   public ExtremeComplicatedClass(Data data1){
      this.data1 = data1;
      this.data2 = new Data();
      this.data3 = new Data();
      // hunderte von Methoden-Aufrufen hier...
   }

   public ExtremeComplicatedClass(Data data1, Data data2){
      this.data1 = data1;
      this.data2 = data2;
      this.data3 = new Data();
      // hunderte von Methoden-Aufrufen hier...
   }

   public ExtremeComplicatedClass(Data data1, Data data2, Data data3){
      this.data1 = data1;
      this.data2 = data2;
      this.data3 = data3;
      // hunderte von Methoden-Aufrufen hier...
   }
}

vs:

class ExtremeComplicatedClass{
   private Data data1, data2, data3;

   public ExtremeComplicatedClass(Data data1){
      this(data1, new Data(), new Data());
   }

   public ExtremeComplicatedClass(Data data1, Data data2){
      this(data1, data2, new Data());
   }

   public ExtremeComplicatedClass(Data data1, Data data2, Data data3){
      this.data1 = data1;
      this.data2 = data2;
      this.data3 = data3;
      // hunderte von Methoden-Aufrufen hier...
   }
}

Da haste dir halt jetzt 2x hunderte von Methoden-Aufrufen gespart, die eh immer gleich sind. Und es ist wie gesagt sehr schnell passiert dass du im Nachhinein in einen Konstruktor etwas hinzufügst oder was änderst, und es bei einem der anderen vergisst anzupassen. Mit so ner Delegation von Konstruktoren, wo nur einer die Logik macht, und alle weiteren diesen nur mit passenden (Default-)Parametern aufrufen, kann dir sowas halt nicht passieren.

 

[Br4ve]

Ok habs verstanden