Getter Methode

Bitte aktiviere JavaScript!
Hallo Zusammen,
ich möchte eine Get Methode erstellen,
hier die 2 relevanten Klassen
ArrayGenerator
https://pastebin.com/zmFDvT7s
Program01.java
https://pastebin.com/2QbiRM7B

im ArrayGenerator wuerde ich gerne eine methode erstellen mit der ich das "intArray" in program01.java aufrufen kann, jedoch gelingt mir dies einfach nicht..
was mache ich falsch?

edit1: glaube das problem zu gefunden haben, werde die methode ja nicht nehmen koennen ohne dass ich variablen verlange.. edit2 kommt sobald behoben
 
Zuletzt bearbeitet:
Du verwendest ein etwas komisches Vokabular. "Array [...] aufrufen" und "Variablen verlangen".
Was genau willst du tun? Möchtest du auf das intArray in der Klasse `ArrayGenerator` lesend innerhalb der Klasse `program01` zugreifen? Falls ja, kannst du - wie du schon sagtest - eine Getter-Methode in ArrayGenerator implementieren. Die aktuelle Methode:
Java:
public void getIntArray(int[] intArray) {
  this.intArray = intArray;
}
ist von der Semantik her eher ein "Setter", denn sie _setzt_ das intArray von `this` auf das per Parameter übergebene Array.
Ein _Getter_ würde so aussehen:
Java:
public int[] getIntArray() {
  return this.intArray;
}
 
Du verwendest ein etwas komisches Vokabular. "Array [...] aufrufen" und "Variablen verlangen".
Was genau willst du tun? Möchtest du auf das intArray in der Klasse `ArrayGenerator` lesend innerhalb der Klasse `program01` zugreifen? Falls ja, kannst du - wie du schon sagtest - eine Getter-Methode in ArrayGenerator implementieren. Die aktuelle Methode:
Java:
public void getIntArray(int[] intArray) {
  this.intArray = intArray;
}
ist von der Semantik her eher ein "Setter", denn sie _setzt_ das intArray von `this` auf das per Parameter übergebene Array.
Ein _Getter_ würde so aussehen:
Java:
public int[] getIntArray() {
  return this.intArray;
}
Hallo,
moechte im Endeffekt folgendes tun: das array intArray moechte ich in Program01 weiterverwenden, da dachte ich mir das sollte mit einer get methode klappen? soweit noch i.o?
habe nun probiert deinen code einzufuegen jedoch gibt´s leider folgende Meldung:
12247

bzgl verlangen meinte ich, ich habe eine methode test in der klasse ArrayGenerator erstellt, will ich diese von program01 aufrufen wird sie mir von intellij nicht angezeigt, setze ich allerdings in die condition irgendwas rein, sei es "int test" wird mir diese methode als moegliche auswahl in program01 angezeigt.
 
Also was mir so auffällt:
- ArrayGenerator.arrayGenerieren ist statisch und hat daher keinen Zugriff auf eine Instanzvariable. (Du erzeugst ja auch keine Instanz von der Klasse ....(
- Die statische Method hat eine lokale Variable. Wenn die Funktion durch ist, ist der Inhalt der Variablen weg.

Tipp: Mach wirklich nur die main Methode statisch. Alles andere ist nicht statisch. Bei Anfängern ist das eigentlich zu 99,9% aller Fälle einfach nur ein schlechtes/falsches Design.....
 
Also was mir so auffällt:
- ArrayGenerator.arrayGenerieren ist statisch und hat daher keinen Zugriff auf eine Instanzvariable. (Du erzeugst ja auch keine Instanz von der Klasse ....(
- Die statische Method hat eine lokale Variable. Wenn die Funktion durch ist, ist der Inhalt der Variablen weg.

Tipp: Mach wirklich nur die main Methode statisch. Alles andere ist nicht statisch. Bei Anfängern ist das eigentlich zu 99,9% aller Fälle einfach nur ein schlechtes/falsches Design.....
Moment, ich probiers mal.. Dass mein Design noch grottenschlecht ist, ist mir (leider) auch bewusst ;)
 
Du solltest dein intArray auch irgendwo deklarieren, d.h. dem Compiler sagen daß du irgendwo ein intArray brauchst.
Java:
public class MyClass{
    private int intArray[];
   
    //Muß im Konstruktor erzeugt oder per Setter übergeben werden
    public MyClass(){
        intArray = new int[];
    }
}
 
habe nun probiert deinen code einzufuegen jedoch gibt´s leider folgende Meldung: [leider als Bild eingefügt...]
Der Code sieht ja nochmal anders aus als im pastebin. Dort hatte deine ArrayGenerator Klasse noch eine Instanzvariable `int[] intArray`:
Java:
import java.util.Arrays;
public class ArrayGenerator {
    private int[] intArray; // <- DAS IST DIE INSTANZVARIABLE, DIE ICH MEINE!
    public static void arrayGenerieren(int zahlenYesNo, int buchstabenYesNo, int intArrayHatStellen) {
        if (zahlenYesNo == 1) {
            /* Array mit Zahlen generieren*/
            int[] intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen ; i++){
                intArray[i] = (int) (Math.random() * 10000);
            }
            System.out.println(Arrays.toString(intArray));
        }
        if (buchstabenYesNo == 1) {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }
    // DAS HIER IST DER GETTER, DEN ICH MEINE!
    public int[] getIntArray() {
        return this.intArray;
    }
}
 
So,
danke an alle, vermute dass ich es herausgefunden habe,
ArrayGenerator ArrayGenerator01 = new ArrayGenerator();
ArrayGenerator01.getIntArray();

damit scheints zu klappen...
Designfrage: Wäre es besser nicht direkt aufzurufen sondern eine neue Instanz zu erzeugen und von der aus weiter arbeiten?
 
Kommt drauf an, was du genau mit "direkt aufrufen" und "eine neue Instanz" (wovon?) und "weiter arbeiten" meinst. Drücke dich bitte präziser aus.

Okay, ich probiers:

Ich meine: anstatt dass ich z.B ArrayGenerator.xyz tippe , wäre es besser wenn ich gleich am Anfang der Klasse
ArrayGenerator ArrayGenerator01 = new ArrayGenerator();
reintippe und dann mit ArrayGenerator01 weiterarbeite?
 
so mit Instanz Variablen:
Java:
import java.util.Arrays;

public class ArrayGenerator
{
    private int[] intArray;
    private String[] stringArray;

    public void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
        if (generiereZahlen)
        {
            /* Array mit Zahlen generieren*/
            intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen; i++)
            {
                intArray[i] = (int) (Math.random() * 10000);
            }
        }
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }

    public int[] getIntArray()
    {
        return this.intArray;
    }

    //zum testen
    public static void main(String[] args)
    {
        ArrayGenerator generator = new ArrayGenerator();
        generator.arrayGenerieren(true, false, 10);
        System.out.println(Arrays.toString(generator.getIntArray()));
    }
}
oder statisch
Java:
import java.util.Arrays;

public class ArrayGenerator
{
    private static int[] intArray;
    private static String[] stringArray;

    public static void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
        if (generiereZahlen)
        {
            /* Array mit Zahlen generieren*/
            intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen; i++)
            {
                intArray[i] = (int) (Math.random() * 10000);
            }
        }
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }

    public static int[] getIntArray()
    {
        return intArray;
    }

    //zum testen
    public static void main(String[] args)
    {

        ArrayGenerator.arrayGenerieren(true, false, 10);
        System.out.println(Arrays.toString(ArrayGenerator.getIntArray()));
    }
}
der unterschied ist, das es statisch die Werte nur einmal gibt und beim obigen Beispiel kannst du so viele ArrayGeneratoren machen wie du willst, oder ram hast ;-)

zahlenYesNo -> geil.. you made my day ;-)
 
@vogelspinne24 Und wenn wir schon dabei sind: verwende separate Methoden, die jeweils nur eine Aufgabe haben.
Java:
void generiereZahlen(int laenge) { ... }
void generiereBuchstaben(int laenge) { ... }
Noch was, bevor Du Dich wunderst: die Deklaration von stringArray innerhalb der Methode sorgt dafür, dass es innerhalb der Methode eine lokale Variable gibt, die den gleichen Namen trägt, wie die Klassen-/Instanzvariable.

Java:
public class ArrayGenerator
{
    private int[] intArray;
    private String[] stringArray; // <-- hier die Instanzvariable
// ...
    public void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
// ...
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen]; // <-- hier die lokale Variable
        }
    }
Dadurch wird innerhalb der Methode arrayGenerieren mit stringArray die lokale Variable und nicht die Klassen- oder Instanzvariable angesprochen. Sprich: wenn Du beim Aufruf der Methode für den Parameter generiereBuchstaben true einsetzt, wird die Klassen-/Instanzvariable stringArray nicht angetastet und bleibt null
 
Hallo zusammen, habe nochmals probiert das ganze ein bisschen konformer zu machen =)
Kann mir bitte wer sagen, ob
a) das Design so nun besser ist
b) warum ich in der klasse bubblesort folgende Fehlermeldung bekomme --> Operator '>' cannot be applied to 'java.lang.Object','java.lang.Object' (den Code von Bubblesort hab ich mir von http://www.javatechblog.com/java/java-program-to-sort-arraylist-without-using-collections/ kopiert)




Java:
import java.util.ArrayList;
class Main


{

    public static void main(String[] args) {
        Arraygenerator Arraygenerator01 = new Arraygenerator();
        // hier bool abfrage ob zahlen
        //hier bool abfrage ob Buchstaben
        // hier Abfrage wieviele Zahlen im Array sein sollen

        Arraygenerator01.setAnzahlZahlen(292); // anpassen mit scanner
        Arraygenerator01.generateList();
        //Bubblesort Bubblesort01 = new Bubblesort();
        ArrayList $Array01 = Arraygenerator01.getArray();
        // System.out.println("Dein Array befindet sich an folgender Stelle im RAM: " + Arraygenerator01.getArray());
        //Bubblesort01.Bubblesort($Array01);
        // Array an Bubblesort weitergeben
       // Bubblesort01.Bubblesort();
    }
}


Java:
import java.util.ArrayList;
import java.util.List;

class BubbleSort {

        public static void main(String[] args) {
            Arraygenerator Arraygenerator01 = new Arraygenerator();
            ArrayList $Array01 = Arraygenerator01.getArray();
            int $Array01Size = $Array01.size();
            System.out.println("Elements before sorting: ");
            System.out.println($Array01);
            for (int i = 0; i < $Array01.size(); i++) {
                for (int j = 0; j < $Array01.size() - i - 1; j++) {
                    if ($Array01.get(j) > $Array01.get(j + 1)) {
                        int temp = $Array01.get(j);
                        $Array01.set(j, $Array01.get(j + 1));
                        $Array01.set(j + 1, temp);
                    }
                }
            }
            System.out.println("Elements After sorting (in Ascending order): ");
            System.out.println($Array01);
        }
    }

Java:
import java.util.Collections;
import java.util.ArrayList;
/*public*/ class Arraygenerator {

    int $private_anzahlZahlen;
    ArrayList $Array01;
    //private ArrayList $Array01;

      void setAnzahlZahlen(int $anzahlZahlen) {
        $private_anzahlZahlen = $anzahlZahlen;
    }

    public  ArrayList getArray() {
        return $Array01;
    }

    void generateList(){

       
        ArrayList $Array01 = new ArrayList();
        for(int i = 0; i < $private_anzahlZahlen; i++)
        {
            $Array01.add(i+1);
            //$Array01.add('a');
        }
        Collections.shuffle($Array01);
        System.out.println($Array01);
    }

}
 
a) das Design so nun besser ist
Du solltest dir mal Generics und die Konventionen zur Variablenbenennung angucken ;)

b) warum ich in der klasse bubblesort folgende Fehlermeldung bekomme --> Operator '>' cannot be applied to 'java.lang.Object','java.lang.Object' (den Code von Bubblesort hab ich mir von http://www.javatechblog.com/java/java-program-to-sort-arraylist-without-using-collections/ kopiert)
Deine Liste enthält nur Objekte (dass da Integer drin liegen, weiß deine Bubblesort-Klasse nicht), und Objekte kann man eben nicht mit > vergleichen. Generics angucken ;)
 
Du solltest dir mal Generics und die Konventionen zur Variablenbenennung angucken ;)
mach ich sogleich, hast du vielleicht einen Link zu einer guten Erklärung (bzgl Generics)? bevor ich mich in den OracleDocs versenke :D?

Deine Liste enthält nur Objekte (dass da Integer drin liegen, weiß deine Bubblesort-Klasse nicht), und Objekte kann man eben nicht mit > vergleichen. Generics angucken ;)
Das heißt, ich muss die Listen in "reine" Arrays konvertieren, dann sortieren und dann in die ArrayList reingeben ;) ?
Oder wird mir das auch erst mit dem verstehen der Generics klar?
 
mach ich sogleich, hast du vielleicht einen Link zu einer guten Erklärung (bzgl Generics)? bevor ich mich in den OracleDocs versenke :D?

Das heißt, ich muss die Listen in "reine" Arrays konvertieren, dann sortieren und dann in die ArrayList reingeben ;) ?
Oder wird mir das auch erst mit dem verstehen der Generics klar?
Letzteres :)
 
So, Punkt 1 mit den Bennenungen sollte nun OK sein.
Punkt 2 ist mir immer noch nicht klar,
so wie ich es verstanden habe, kann ich in der ArrayList zb einen TypA-int und einen TypB-char machen?
und dann beim auffuellen der ArrayList den Eintrag mit dem passenden Typ hinzufuegen?
(siehe Listing 7.5 bei dem Link den du mir geschickt hast)


Edit: nach ein bisschen mehr einlesen, im Konstruktor den Typ reingeben den ich in der ArrayList verwenden will und dann z.B im Arraygenerator in der Schleife richtig anpassen?
 
Zuletzt bearbeitet:
Konnte leider nicht mehr editieren, somit schreibe ich es hier rein, so wie es aussieht war das ein recht arger Designfehler von mir, ich fahre wohl besser wenn ich einfach 2 arrayLists erstelle einmal mit zahlen, einmal mit buchstaben
die danach durch den Algorithmus laufen lasse, und danach in einer dritten ArrayList zusammenführe und ausgebe
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben