myGully.com - [JAVA] Methodenaufruf und Integrationsproblem

myGully.com (https://mygully.com/index.php)

- Programmierung (https://mygully.com/forumdisplay.php?f=67)

- - [JAVA] Methodenaufruf und Integrationsproblem (https://mygully.com/showthread.php?t=2154392)

[JAVA] Methodenaufruf und Integrationsproblem

So nun wäre ich bei meinem 2ten Problem angekommen.

Folgende 2 Dateien hab ich Bereits.

Datei 1

Code:

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package bubblesortmarc;



/**

 *

 * @author Eike Ulrichs

 */

public class Bubblesort1 {



    public static void sortOptimal(int[] x) { //Erzeugen der Methode "sortOptimal"

        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung

        int temp; //temporäre Variable



        while (unsortiert) { //Prüfen der Abbruchbedingung

            unsortiert = false; //Setzen des neuen Boolschen-Wertes

            for (int i = 0; i < x.length - 1; i++) { //Während I kleiner Array-Länge

                if (x[i] > x[i + 1]) {//Wenn Elemant i vom Arrax größer als I+1

                    temp = x[i];// Kopieren von Wert i in temp

                    x[i] = x[i + 1];// Kopieren von Wert i+1 in i

                    x[i + 1] = temp; //Kopieren von Wert temp in i+1

                    unsortiert = true; //Setzen des neuen Boolschen-Wertes

                }

            }

        }

    }



    public static void initReverse(int[] x) {// Erzeugen der Methode "initReverse"

        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung

        int temp;// temporäre Variable



        while (unsortiert) { // Während unsortiert

            unsortiert = false;// Boolscher-Wert ist "False"

            for (int i = 0; i < x.length - 1; i++) {//Während Element I Des Arrays kleiner Element I-1

                if (x[i] < x[i + 1]) {// Wenn Element I von X kleiner Element I+1

                    temp = x[i];// KOpieren des Wertes XI auf temp

                    x[i] = x[i + 1];//Kopieren des Wertes XI+1 auf XI

                    x[i + 1] = temp;//Kopieren des Wertes temp auf XI+1

                    unsortiert = true;// Wahrheitswert auf "true" setzen

                }

            }

        }

    }



    public static void display(int[] x) { //Erzeugen der Methode "display"

        int i = 0;//Zählvariable



        while (i < x.length) // Während I kleiner Arraylänge

        {



            System.out.print(x[i] + " "); // Ausgabe Arrayelement I



            i = i + 1; //Inkrementieren von I



        }

        System.out.println(" ");// Zeilenumbruch

    }



    public static void while1(int[] x) { // Erzeugen der Methode "While"



        int swa = 0;//Variable zum Zählen des Vertauschen

        int inner = 0;//Variable zum Zählen der inneren Schleife

        int i; // Variable zur abarbeitung der Schleife



        i = 1;                              // Deklaration der i variable mit Wert 1

        while (i < x.length) {              //1. While_Schleife mit Bedingung i kleiner Arraylänge

            int j = x.length - 1;           //Initialisierung und Deklaration der Variable j mir größe Arraylänge -1

            while (j >= i) {                // Während j größer gleich i

                if (x[j] < x[j - 1]) {      // wenn F[j] kleiner F[j-1]

                    int temp = x[j];        // Initialisierund und Wertezuweisung Variable Temp = F[j]

                    x[j] = x[j - 1];        //Kopieren von Wert F[j-1] auf Wert F[j]

                    x[j - 1] = temp;        // Kopieren von Wert Temp auf F[j-1]

                    swa++;                  //Inkrementieren der Variable swa

                }

                inner++;                    //Inkrementieren der Variable inner

                j = j - 1;                  //Dekrementieren der Variable J

            }

            i = i + 1;                      //Inkrementieren der Variable I

        }





    }

}

Datei 2

Code:

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package bubblesortmarc;



/**

 *

 * @author Eike Ulrichs

 */

public class Main {



    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // TODO code application logic here

        Bubblesort1 b1 = new Bubblesort1();// Erstellen eines neuen Objektes von Bubblesort

        int[] liste = {1, 2, 3, 5, 9, 8, 7};//Array mit Werten





        System.out.println("Array vor Bubblesort"); //Ausgabe

        b1.display(liste);// Aufrufen der Methode display von Objekt b1 Übergabe der Liste



        b1.sortOptimal(liste);//Aufrufen der Methode sortOptimal von Objekt b1 Übergabe der Liste

        {

            System.out.println("Array nach Bubblesort");

        }



        b1.display(liste);// Aufrufen der Methode display von Objekt b1 Übergabe der Liste



        b1.initReverse(liste);// Aufrufen der Methode initReverse von Objekt b1 Übergabe der Liste

        {

            System.out.println("Umgekehrter Bubblesort");

        }



        b1.display(liste);// Aufrufen der Methode display von Objekt b1 Übergabe der Liste



        b1.while1(liste); //Aufrufen der Methode While1 von Objekt b1 Übergabe der Liste

        {

            System.out.println("Array nach While-Bubblesort");

        }



        b1.display(liste);// Aufrufen der Methode display von Objekt b1 Übergabe der Liste





    }

}

So mein Problem ist jetzt,
dass das Array von der 2ten Datei eig in der 1ten stehen soll
und die Länge des Arrays beim Erstellen eines Objektes übergeben werden soll.

Danach soll das Array mit Zufallszahlen gefüllt werden.

Leider hab ich absolut keine Ahnung wie ich das bewerkstelligen soll v.v

Ich hoffe Ihr könnt mir ein paar Denkanstöße oder Hilfen geben.

Grüße Belenus

Ein paar JAVA-Grundlagen musst Du Dir noch aneignen:

[Link nur für registrierte und freigeschaltete Mitglieder sichtbar. Jetzt registrieren...]

Du übergibst immer den gleichen primitiven Datentyp.
Und wozu die Klammern?

(Denke mal hier liegt das Problem...)

So habs jetzt fertig.

Wäre nett wenn einer von euch noch mal kurz drüber schaut,
ob ich noch was verbessern kann.

Datei 1

Datei 2

Code:

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package bubblesorte4;



/**

 *

 * @author Eike Ulrichs

 */

public class Bubblesort1 {



    static int F[];

    static int swap;

    static int inner;



     void init(int laenge, int X[]) {

        F = new int[laenge];

        F = X;

        swap = 0;

        inner = 0;

}

    public static void sortOptimal() { //Erzeugen der Methode "sortOptimal"

        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung

        int temp; //temporäre Variable



        while (unsortiert) { //Prüfen der Abbruchbedingung

            unsortiert = false; //Setzen des neuen Boolschen-Wertes

            for (int i = 0; i < F.length - 1; i++) { //Während I kleiner Array-Länge

                if (F[i] > F[i + 1]) {//Wenn Elemant i vom Arrax größer als I+1

                    temp = F[i];// Kopieren von Wert i in temp

                    F[i] = F[i + 1];// Kopieren von Wert i+1 in i

                    F[i + 1] = temp; //Kopieren von Wert temp in i+1

                    unsortiert = true; //Setzen des neuen Boolschen-Wertes

                    swap++;

                }

            }

            inner++;

        }

    }



    public static void initReverse() {// Erzeugen der Methode "initReverse"

        boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung

        int temp;// temporäre Variable

         swap = 0;

         inner = 0;

        while (unsortiert) { // Während unsortiert

            unsortiert = false;// Boolscher-Wert ist "False"

            for (int i = 0; i < F.length - 1; i++) {//Während Element I Des Arrays kleiner Element I-1

                if (F[i] < F[i + 1]) {// Wenn Element I von X kleiner Element I+1

                    temp = F[i];// KOpieren des Wertes XI auf temp

                    F[i] = F[i + 1];//Kopieren des Wertes XI+1 auf XI

                    F[i + 1] = temp;//Kopieren des Wertes temp auf XI+1

                    unsortiert = true;// Wahrheitswert auf "true" setzen

                    swap++;

                }

            }

            inner++;

        }

    }



    public static void display() { //Erzeugen der Methode "display"

        System.out.println(java.util.Arrays.toString(F));

        System.out.println("Die Variablen wurden " + swap + " mal vertauscht" );

        System.out.println("Die innere Schleife wurde " + inner + " mal durchlaufen");

        System.out.println();

    }



    public static void while1() { // Erzeugen der Methode "While"



        int i; // Variable zur abarbeitung der Schleife

        swap = 0;

        inner = 0;

        i = 1;                              // Deklaration der i variable mit Wert 1

        while (i < F.length) {              //1. While_Schleife mit Bedingung i kleiner Arraylänge

            int j = F.length - 1;           //Initialisierung und Deklaration der Variable j mir größe Arraylänge -1

            while (j >= i) {                // Während j größer gleich i

                if (F[j] < F[j - 1]) {      // wenn F[j] kleiner F[j-1]

                    int temp = F[j];        // Initialisierund und Wertezuweisung Variable Temp = F[j]

                    F[j] = F[j - 1];        //Kopieren von Wert F[j-1] auf Wert F[j]

                    F[j - 1] = temp;        // Kopieren von Wert Temp auf F[j-1]

                    swap++;                  //Inkrementieren der Variable swa

                }

                inner++;                    //Inkrementieren der Variable inner

                j = j - 1;                  //Dekrementieren der Variable J

            }

            i = i + 1;                      //Inkrementieren der Variable I

        }





    }

}

Habs jetzt mal in Spoiler gepackt damit das nicht die Seite sprengt.

Funktional mag es ok sein.

Ich weiß nicht inwiefern die Code-Qualität eine Rolle spielt, aber die ist nicht so dicke.
An ner Uni würde die Annahme schon scheitern.

1. Ein paar sinnlose Kommentare ...

2. ... und fehlende . Ehrlich gesagt sind mehr sinnlose Kommentare vorhanden als notwendige.
Dass Du mit Sysout ne Ausgabe machst oder ne Methode aufrufst ist vollkommen klar und braucht nicht
kommentiert werden. Was aber eine Methode bewerkstelligt ist gar nicht kommentiert.
An der Uni könntest Du damit schon durchfallen.

z.B. " // Erzeugen der Methode "While"

// Wahrheitswert auf "true" setzen

//Array mit Werten

???

3. void init(int laenge, int X[])
--> sollte nur das Array als Parameter haben: init(int array[])

4. Unnötige Klammern

{System.out.println("Array nach Bubblesort");}

5. Die Methode display() hat in der statischen Klasse BubbleSort nichts zu suchen

6. Ineffizienter Code: Du initialisiert eine Variable auf "true" und setzt diese danach auf "false"
Außerdem setzt Du unsortiert bei jedem Schleifendurchgang erneut.
Sollte genau andersrum sein (also while(!sortiert) ...)

boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung
while (unsortiert) { // Während unsortiert
unsortiert = false;// Boolscher-Wert ist "False"

7. Was macht die Methode "while1"? Wieso "while1"? Weil while-Schleifen vorhanden sind?

8. Packagenamen entsprechen nicht der Konvention

9. Fehlende private-Deklarationen

10. Statt "for (int i = 0; i < F.length - 1; i++)" verwende "for (int i: F)"

11. swap und inner werden in zwei verschiedenen Methoden initialisiert

11. Keine direkte Initialisierung:
int i;
i = 1;

12. Statt i = i + 1
verwende i++;

Zitat:

10. Statt "for (int i = 0; i < F.length - 1; i++)" verwende "for (int i: F)"

kann man nicht generalisieren.
richtig, und gut lesbar, wenn man lesend über ein array (oder ein Collections) iteriert.
nicht zu gebrauchen, wenn man die elemente des arrays/der Collections in der for verändern möchte.

Zitat:

Zitat von urga (Beitrag 21486652)

Stimmt. Macht der Gewohnheit. Hier nicht anwendbar da primitiver Datentyp.