Finde meinen Fehler in einer Methode nicht, Java Karol

[marcelnedza]

Hi zusammen, ich habe mal wieder ein kleines Problem.
Ich habe die Aufgabe zwei Roboter zu generieren welche sich in einer kleinen Welt suchen, bei Sichtkontakt soll die Laufsequenz beendet werden und der Roboter der Sicht kontakt aufgenommen hat soll auf den anderen zulaufen und bei Kontakt eine Begrüßung ausgeben mitsamt der Kennung des anderen.
Funktioniert soweit auch gut und zuverlässig sofern der Roboter mit dem Indizes 0 (Roboter 1) im Array derjenige ist der Sichtkontakt aufgenommen hat.
Wenn Indizes 1 (Roboter 2) Sichtkontakt hat, läuft er auf den anderen zu aber sobald er vor ihm steht kommt anstatt einer Meldung und dem Programm stopp nichts und es geht weiter bis Roboter 1 ihn gefunden hat.

Ich vermute stark es hat was hiermit zu tun:

 while (programm.RoboterSuchen(arr) == false) {

                programm.RoboterSuchen(arr);

            }

Wenn Roboter 2 (also der zweite durchlauf der for-Schleife in der RoboterSuchen Methode) dran ist, wird bei direktkontakt vermutlich nicht auf true gesetzt trotz return true;


Hier die zwei Klassen die ich geschrieben habe:

import javakarol.*;

public class mainclass {

    public static void main(String[] args) {
        int x = 0;
        int y = 0;
        Welt welt1 = new Welt("E:/Abschlussaufgabe/bin/meeting.kdw");
        Roboter[] arr = new Roboter[2];

        int z = 0;

        while (z == 0) {

            try {
                for (;;) {
                    int i = 0;
                    while (i < 2) {

                        x = programm.positionxVergeben(x);
                        y = programm.positionyVergeben(y);

                        Roboter karol = new Roboter(x, y, 'S', welt1);
                        arr[i] = karol;
                        i++;

                    }

                    if (i == 2) {
                        break;
                    }

                }
                z = 1;
            } catch (java.lang.RuntimeException e) {
                System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
            }
        }

        try {
            while (programm.RoboterSuchen(arr) == false) {
                programm.RoboterSuchen(arr);
            }
        } catch (java.lang.NullPointerException a) {
            System.out.println("Bitte neu starten.");
        }

    }
}

import javakarol.*;

public class programm {

    public static int positionxVergeben(int x) {

        int i = 0;

        while (i < 1) {

            x = ((int) (Math.random() * 100)) % 20;

            if (x <= 20) {

                i++;

            }

        }
        return x;
    }

    public static int positionyVergeben(int y) {

        int i = 0;

        while (i < 1) {

            y = ((int) (Math.random() * 100)) % 20;

            if (y <= 20) {

                i++;

            }

        }
        return y;
    }

    public static boolean RoboterSuchen(Roboter[] arr) {

        for (int i = 0; i < 2;i++) {
            try {
                arr[i].Schritt();
                if (arr[i].IstRoboterInSicht() == true) {
                    while (arr[i].IstRoboter() == false) {
                        arr[i].Schritt();
                    }
                    arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
                    return true;

                }
            } catch (java.lang.RuntimeException e) {

                int x = (int) (Math.random() * 100);

                if (x % 2 == 0) {
                    arr[i].LinksDrehen();
                } else {
                    arr[i].RechtsDrehen();
                }
                if (arr[i].IstRoboterInSicht() == true) {
                    while (arr[i].IstRoboter() == false) {
                        arr[i].Schritt();
                    }
                    arr[i].RoboterVorneKennungGeben();
                    arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
                    return true;

                }
            }

        }
        return false;

    }

}

Ich hoffe man versteht was mein Problem ist

 

[marcelnedza]

Hier noch das Handbuch zu den verschiedenen Methoden aus der JavaKarol Klasse:

http://www.oppelt-help.de/infoprogs/JavaKarolHandbuch.pdf

 

[MarvinsDepression]

Sagt mal, ist das eine ernsthafte Sache hier. Ich kann mir beim besten Willen nicht vorstellen, das ein Anfänger so gezielt Code verkomplizieren kann und bei dem angegebenen Link bringt FF gleich mal eine Warnung.

 

[marcelnedza]

Sagt mal, ist das eine ernsthafte Sache hier. Ich kann mir beim besten Willen nicht vorstellen, das ein Anfänger so gezielt Code verkomplizieren kann und bei dem angegebenen Link bringt FF gleich mal eine Warnung.

Wieso verkomplizieren? Klär mich bitte auf 😅
Grüße

 

[marcelnedza]

Sagt mal, ist das eine ernsthafte Sache hier. Ich kann mir beim besten Willen nicht vorstellen, das ein Anfänger so gezielt Code verkomplizieren kann und bei dem angegebenen Link bringt FF gleich mal eine Warnung.

Und tatsächlich ist das Handbuch unvollständig, muss den Link später updaten da fehlen sehr viele Seiten

 

[MarvinsDepression]

hier wird programm.RoboterSuchen(arr) zwei mal aufgerufen, zuerst im Schleifenkopf, dann nochmals im Schleifenkörper (ohne den Ergebniswert abzufragen).

while (programm.RoboterSuchen(arr) == false) {
    programm.RoboterSuchen(arr);
}

Es reicht also ganz einfach ein while (!programm.RoboterSuchen(arr)) {}, der Methodenkörper bleibt leer.

Zudem entspricht die Namengebung nicht dem Reglement: Klassennamen beginnen mit einem Großbuchstaben, Methoden-/Variablennamen werden klein geschrieben. -> Erwarten würde man also Programm.roboterSuchen(arr)


dann weiter:

int z = 0;
while (z == 0) {
    try {
        for (;;) {
            int i = 0;
            while (i < 2) {
                x = programm.positionxVergeben(x);
                y = programm.positionyVergeben(y);

                Roboter karol = new Roboter(x, y, 'S', welt1);
                arr[i] = karol;
                i++;
            }
            if (i == 2) {
                break;
            }
        }
        z = 1;
    } catch (java.lang.RuntimeException e) {
        System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
    }
}

ganz ehrlich, wie kommt man auf dermaßen umständlichen Code:

try {
    for (int i = 0; i < 2; i++) {
        x = programm.positionxVergeben(x);
        y = programm.positionyVergeben(y);

        arr[i] = new Roboter(x, y, 'S', welt1);
    }
} catch (Exception e) {
    System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

macht genau dass, was Dein Code macht und ist lesbar.
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

weiter:

public static int positionxVergeben(int x) {
    int i = 0;

    while (i < 1) {
        x = ((int) (Math.random() * 100)) % 20;
        if (x <= 20) {
            i++;
        }
    }
    return x;
}

Wozu der Parameter im Methodenkopf? Wozu die Schleife? Wozu mit Modulo??
Es genügt schlicht

public static int positionxVergeben() {
    return (int) (Math.random() * 20);
}

Und auch der Methodename. Das x sieht man fast nicht, daher vielleicht lieber xPositionVergeben()
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

und hier :

} catch (java.lang.RuntimeException e) {
    int x = (int) (Math.random() * 100);
    if (x % 2 == 0) {
        arr[i].LinksDrehen();
    } else {
        arr[i].RechtsDrehen();
    }
    if (arr[i].IstRoboterInSicht() == true) {
        while (arr[i].IstRoboter() == false) {
            arr[i].Schritt();
        }
        arr[i].RoboterVorneKennungGeben();
        arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
        return true;
    }
}

Solcher Code gehört nicht einen catch-Block. Der chatch-Block (catch { ... }) ist nur zur Fehlerbehandlung da, aber nicht zum Steuern des Programm-Ablaufes. Überlege Dir, was eintreten muss, dass eine Drehung nötig wird und wie Du es testen kannst.

zudem:

int x = (int) (Math.random() * 100);
if (x % 2 == 0) {
    arr[i].LinksDrehen();
    ...

Es genügt if (Math.random()*2 < 1) {

 

[temi]

positionxVergeben() und positionyVergeben() sind identisch, da reicht eine

Zudem benötigt die Methode keinen Parameter, denn sie nutzt ihn ja nicht, und sie ist ebenfalls unnötig kompliziert. Um eine Zufallszahl in einem bestimmten Bereich zu erzeugen, reicht eine Zeile.

EDIT: Weiterlesen hätte geholfen, es wurde alles bereits gesagt.

 

[temi]

try {
for (int i = 0; i < 2; i++) {
x = programm.positionxVergeben(x);
y = programm.positionyVergeben(y);

arr[i] = new Roboter(x, y, 'S', welt1);
}
} catch (Exception e) {
System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

macht genau dass, was Dein Code macht und ist lesbar.

Noch besser wäre es auch hier auf die Exception zur Programmsteuerung zu verzichten und vor der Erzeugung des Roboters zu prüfen, ob die gewünschte Position frei ist. In diesem Fall würde man genau eine Schleife benötigen, die solange läuft, bis zwei Roboter platziert wurden.

EDIT: Es kann allerdings sein, dass dies nicht möglich ist, weil "Welt" keine passende Methode dafür anbietet.

 

[KonradN]

EDIT: Es kann allerdings sein, dass dies nicht möglich ist, weil "Welt" keine passende Methode dafür anbietet.

Ja, ich fürchte, da gibt es keine Methdoe. https://docplayer.org/125937835-Jav...l-zur-programmierung-in-java-version-3-0.html zeigt da zumindest nichts.

 

[temi]

int robot = 0;
while (robot < 2) {
    x = programm.positionVergeben();
    y = programm.positionVergeben();

    try {
        arr[robot] = new Roboter(x, y, 'S', welt1);;
        robot++;
    }
  
    catch (java.lang.RuntimeException e) {
        System.out.println("Diese Stelle ist bereits besetzt, eine neue Position wird ermittelt.");
    }
}

 

[temi]

Methoden-/Variablennamen werden klein geschrieben.

Blöd ist, dass auch JavaKarol völlig gegen diese Konventionen verstößt. Das ist bedauerlich.

 

[marcelnedza]

hier wird programm.RoboterSuchen(arr) zwei mal aufgerufen, zuerst im Schleifenkopf, dann nochmals im Schleifenkörper (ohne den Ergebniswert abzufragen).

while (programm.RoboterSuchen(arr) == false) {
    programm.RoboterSuchen(arr);
}

Es reicht also ganz einfach ein while (!programm.RoboterSuchen(arr)) {}, der Methodenkörper bleibt leer.

Zudem entspricht die Namengebung nicht dem Reglement: Klassennamen beginnen mit einem Großbuchstaben, Methoden-/Variablennamen werden klein geschrieben. -> Erwarten würde man also Programm.roboterSuchen(arr)


dann weiter:

int z = 0;
while (z == 0) {
    try {
        for (;;) {
            int i = 0;
            while (i < 2) {
                x = programm.positionxVergeben(x);
                y = programm.positionyVergeben(y);

                Roboter karol = new Roboter(x, y, 'S', welt1);
                arr[i] = karol;
                i++;
            }
            if (i == 2) {
                break;
            }
        }
        z = 1;
    } catch (java.lang.RuntimeException e) {
        System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
    }
}

ganz ehrlich, wie kommt man auf dermaßen umständlichen Code:

try {
    for (int i = 0; i < 2; i++) {
        x = programm.positionxVergeben(x);
        y = programm.positionyVergeben(y);

        arr[i] = new Roboter(x, y, 'S', welt1);
    }
} catch (Exception e) {
    System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

macht genau dass, was Dein Code macht und ist lesbar.
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

weiter:

public static int positionxVergeben(int x) {
    int i = 0;

    while (i < 1) {
        x = ((int) (Math.random() * 100)) % 20;
        if (x <= 20) {
            i++;
        }
    }
    return x;
}

Wozu der Parameter im Methodenkopf? Wozu die Schleife? Wozu mit Modulo??
Es genügt schlicht

public static int positionxVergeben() {
    return (int) (Math.random() * 20);
}

Und auch der Methodename. Das x sieht man fast nicht, daher vielleicht lieber xPositionVergeben()
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

und hier :

} catch (java.lang.RuntimeException e) {
    int x = (int) (Math.random() * 100);
    if (x % 2 == 0) {
        arr[i].LinksDrehen();
    } else {
        arr[i].RechtsDrehen();
    }
    if (arr[i].IstRoboterInSicht() == true) {
        while (arr[i].IstRoboter() == false) {
            arr[i].Schritt();
        }
        arr[i].RoboterVorneKennungGeben();
        arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
        return true;
    }
}

Solcher Code gehört nicht einen catch-Block. Der chatch-Block (catch { ... }) ist nur zur Fehlerbehandlung da, aber nicht zum Steuern des Programm-Ablaufes. Überlege Dir, was eintreten muss, dass eine Drehung nötig wird und wie Du es testen kannst.

zudem:

int x = (int) (Math.random() * 100);
if (x % 2 == 0) {
    arr[i].LinksDrehen();
    ...

Es genügt if (Math.random()*2 < 1) {

Hi, erstmal danke für die wirklich sehr ausführliche Antwort!

Es reicht also ganz einfach ein while (!programm.RoboterSuchen(arr)) {}, der Methodenkörper bleibt leer.

Bedeutet die Methode wird auch ohne sie im Körper aufzurufen aufgerufen?

int z = 0;
while (z == 0) {
    try {
        for (;;) {
            int i = 0;
            while (i < 2) {
                x = programm.positionxVergeben(x);
                y = programm.positionyVergeben(y);

                Roboter karol = new Roboter(x, y, 'S', welt1);
                arr[i] = karol;
                i++;
            }
            if (i == 2) {
                break;
            }
        }
        z = 1;
    } catch (java.lang.RuntimeException e) {
        System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
    }
}

ganz ehrlich, wie kommt man auf dermaßen umständlichen Code:

try {
    for (int i = 0; i < 2; i++) {
        x = programm.positionxVergeben(x);
        y = programm.positionyVergeben(y);

        arr[i] = new Roboter(x, y, 'S', welt1);
    }
} catch (Exception e) {
    System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

macht genau dass, was Dein Code macht und ist lesbar.
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

Nun, im Fall, dass der catch ausgelöst wird noch bevor die beiden Roboter platziert wurden, würde das Programm ohne while(z==0) ja einfach weitergehen, ohne die Roboter zu platzieren, das habe ich damit umgehen wollen da ich bei jedem Start garantieren will, dass alles klappt.

Die zwei Positions Methoden sind natürlich vollkommener schwachsinn, da gebe ich dir absolut recht!

public static int positionxVergeben(int x) {
    int i = 0;

    while (i < 1) {
        x = ((int) (Math.random() * 100)) % 20;
        if (x <= 20) {
            i++;
        }
    }
    return x;
}

Wozu der Parameter im Methodenkopf? Wozu die Schleife? Wozu mit Modulo??
Es genügt schlicht

public static int positionxVergeben() {
    return (int) (Math.random() * 20);
}

Und auch der Methodename. Das x sieht man fast nicht, daher vielleicht lieber xPositionVergeben()
(P.S.: positionxVergeben() und positionyVergeben() sind identisch, da reicht eine)

Die fertige Welt die ich für meine Aufgabe bekommen habe hat numal die Maße 20x20, deshalb muss die Zahl die an den Konstruktor übergeben wird im Wertebereich 1 bis 20 liegen, deshalb die Schleife!

Zum Methodennamen kann ich nichts sagen, wie o.g., ich werde das korrigieren xD

Es genügt if (Math.random()*2 < 1) {

Ist natürlich smart, wird so übernommen!


Nochmal danke für die vielen Tipps und entschuldige wenn es dich aufgeregt hat, schien ein wenig so. Versuche dich nur ein bisschen in Nachsicht zu üben, ich bin nur ein Mechatronik Student der ein Semester lang mit Java überrollt wurde und dem jetzt ein Programm abverlangt wird von dem er nicht weiß wo hinten und vorne ist!

 

[marcelnedza]

Ja, ich fürchte, da gibt es keine Methdoe. https://docplayer.org/125937835-Jav...l-zur-programmierung-in-java-version-3-0.html zeigt da zumindest nichts.

Danke für die Doku Konrad, muss mir den Link mal für dieses Forum speichern. Per Google Recherche finde ich das irgendwie nie.

 

[MarvinsDepression]

Bedeutet die Methode wird auch ohne sie im Körper aufzurufen aufgerufen?

Ja, unbedingt. Das ist sogar gängige Praxis. Auch wenn man (nur) den Rückgabewert wissen will, wird die Methode trotzdem komplett abgearbeitet. Der Methode ist es schlicht egal, ob der Returnwert interessiert.

---

try {
    for (int i = 0; i < 2; i++) {
        x = programm.positionxVergeben(x);
        y = programm.positionyVergeben(y);

        arr[i] = new Roboter(x, y, 'S', welt1);
    }
} catch (Exception e) {
    System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

Richtig, hier habe ich selber einen Fehler eingebaut und sie Hierarchie des for- und try-Blocks vertauscht.
Richtig ginge es mit dem Beispiel aus dem Post #10

---

Die fertige Welt die ich für meine Aufgabe bekommen habe hat numal die Maße 20x20, deshalb muss die Zahl die an den Konstruktor übergeben wird im Wertebereich 1 bis 20 liegen, deshalb die Schleife!

Nun, aber x modulo 20 liefert bei positiven x stets ein Ergebnis von 0 bis 19 (beides inclusive), aber niemals 20.
(int) (Math.random() * 20) liefert genau das selbe Intervall, also einen Integerwert [0 .. 19]. In der Mathematik spricht man auch von einem rechts offenen Intevall [0 ..20[. Die offene Klammer rechts besagt, das diese Grenze nicht mehr zur Menge dazugehört. In Java ist dieses Prinzip sehr häufig umgesetzt und sollte stets beachtung finden.

---

und entschuldige wenn es dich aufgeregt hat, schien ein wenig so

Ja sorry. Tut mir leid. Ich schiebe es mal auf meine Tabletten 🤣

 

[marcelnedza]

Ja, unbedingt. Das ist sogar gängige Praxis. Auch wenn man (nur) den Rückgabewert wissen will, wird die Methode trotzdem komplett abgearbeitet. Der Methode ist es schlicht egal, ob der Returnwert interessiert.

---

try {
    for (int i = 0; i < 2; i++) {
        x = programm.positionxVergeben(x);
        y = programm.positionyVergeben(y);

        arr[i] = new Roboter(x, y, 'S', welt1);
    }
} catch (Exception e) {
    System.out.println("An dieser Stelle steht schon ein Quader, neue Position wird ermittelt.");
}

Richtig, hier habe ich selber einen Fehler eingebaut und sie Hierarchie des for- und try-Blocks vertauscht.
Richtig ginge es mit dem Beispiel aus dem Post #10

---

Nun, aber x modulo 20 liefert bei positiven x stets ein Ergebnis von 0 bis 19 (beides inclusive), aber niemals 20.
(int) (Math.random() * 20) liefert genau das selbe Intervall, also einen Integerwert [0 .. 19]. In der Mathematik spricht man auch von einem rechts offenen Intevall [0 ..20[. Die offene Klammer rechts besagt, das diese Grenze nicht mehr zur Menge dazugehört. In Java ist dieses Prinzip sehr häufig umgesetzt und sollte stets beachtung finden.

---


Ja sorry. Tut mir leid. Ich schiebe es mal auf meine Tabletten 🤣

Keine Sorge, verstehe die Aufregung absolut, ich denk mir würde es nicht anders gehen wenn mir einer was grenzdebiles vorlegen würde.
Ich habe jetzt alles korrigiert und auch einen Weg gefunden, den Programmlauf ohne try-catch Block zu steuern, das schien mir in "V1" einfach einfacher!


Hier nochmal die beiden fertigen Codes die ich so auch bei meinem Prof einsende, wenn es doch noch was zu korrigieren gibt dann nur her damit, ich will ja lernen!

import javakarol.*;

public class mainclass {

    public static void main(String[] args) {
        int x = 0;
        int y = 0;
        Welt welt1 = new Welt("E:/Abschlussaufgabe/bin/meeting.kdw");
        Roboter[] arr = new Roboter[2];

        int robot = 0;
        while (robot < 2) {
            x = programm.positionVergeben(x);
            y = programm.positionVergeben(x);

            try {
                arr[robot] = new Roboter(x, y, 'S', welt1);
                ;
                robot++;
            }

            catch (java.lang.RuntimeException e) {
                System.out.println("Diese Stelle ist bereits besetzt, eine neue Position wird ermittelt.");
            }
        }

        try {
            while (programm.roboterSuchen(arr) == false) {
            }
        } catch (java.lang.NullPointerException a) {
            System.out.println("Bitte neu starten.");
        }

    }
}

---------------------------------------------------------------------------------------------------

public class programm {

    public static int positionVergeben(int x) {

        int i = 0;

        while (i < 1) {

            x = ((int) (Math.random() * 20));

            if (x <= 20) {

                i++;

            }

        }
        return x;
    }

    public static boolean roboterSuchen(Roboter[] arr) {

        for (int i = 0; i < 2; i++) {

            if (arr[i].IstWand() == false) {

                arr[i].Schritt();
                if (arr[i].IstRoboterInSicht() == true) {
                    while (arr[i].IstRoboter() == false) {
                        arr[i].Schritt();
                    }
                    arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
                    return true;
                }

            } else {

                if (Math.random() * 2 < 1) {
                    arr[i].LinksDrehen();
                } else {
                    arr[i].RechtsDrehen();
                }
                if (arr[i].IstRoboterInSicht() == true) {
                    while (arr[i].IstRoboter() == false) {
                        arr[i].Schritt();
                    }
                    arr[i].RoboterVorneKennungGeben();
                    arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
                    return true;
                }

            }

            // Alte Version

            /*
             *
             * try { arr[i].Schritt(); if (arr[i].IstRoboterInSicht() == true) { while
             * (arr[i].IstRoboter() == false) { arr[i].Schritt(); }
             * arr[i].MeldungAusgeben("Hab dich Roboter " +
             * arr[i].RoboterVorneKennungGeben() + "!"); return true;
             *
             * } } catch (java.lang.RuntimeException e) {
             *
             * int x = (int) (Math.random() * 100);
             *
             * if (x % 2 == 0) { arr[i].LinksDrehen(); } else { arr[i].RechtsDrehen(); } if
             * (arr[i].IstRoboterInSicht() == true) { while (arr[i].IstRoboter() == false) {
             * arr[i].Schritt(); } arr[i].RoboterVorneKennungGeben();
             * arr[i].MeldungAusgeben("Hab dich Roboter " +
             * arr[i].RoboterVorneKennungGeben() + "!"); return true;
             *
             * } }
             */

        }
        return false;

    }

}

Danke nochmal an alle beteiligten, ich habe einiges gelernt und hoffe ihr werdet auch in Zukunft trotz meiner dummen Fehler hilfsbereit sein!

 

[MarvinsDepression]

Ein paar Dinge sind noch immer unschön bzw. unnötig kompliziert. Ich habe Deine Zeilen mal abgeändert und an den entscheidenden Stellen kommentiert.
Natürlich finden sich noch mehr Sachen, die ich anders machen würde und andere ganz anders...
Wichtig ist, das der Code a) funktioniert und b) lesbar ist.

import javakarol.*;

public class MainClass { // Klassen schreibt man groß !!
    
    
    public static void main(String[] args) {
        // int x = 0; // kannst Du weiter unten deklarieren, wird ja nur innerhalb
        // int y = 0; // der Schleife verwendet.
        Welt welt1 = new Welt("E:/Abschlussaufgabe/bin/meeting.kdw");
        Roboter[] arr = new Roboter[2]; // "arr" ist nichtssagend. Wähle sprechende Namen,
                    // hier z.B. "roboter", dann wird im nachfolgenden Code auch verstanden,
                    // was "roboter[i]" bedeutet
        
        int robot = 0;
        while (robot < 2) {
            // hier wird x und y deklariert
            int x = Programm.positionVergeben(20); // 20 als Breite
            int y = Programm.positionVergeben(20); // 20 als Höhe
            
            try {
                arr[robot] = new Roboter(x, y, 'S', welt1);
                ; // ;  leeres Statement, kann weg
                robot++;
            }
            
            catch (java.lang.RuntimeException e) {
                System.out.println("Diese Stelle ist bereits besetzt, eine neue Position wird ermittelt.");
            }
        }
        
        try {
            while (Programm.roboterSuchen(arr) == false) {}
        } catch (java.lang.NullPointerException a) {
            System.out.println("Bitte neu starten.");
        }
    }
    
}

import javakarol.*;

public class Programm { // Klassen schreibt man groß !!

    // hier habe ich dem Parameter einen Sinn gegeben. Die Methode wird dadurch flexibler und
    // und kann in Abhängigkeit von "obergrenze" verschieden große Intervalle abdecken
    public static int positionVergeben(int obergrenze) {
        return (int) (Math.random() * obergrenze); // Ergebnismenge -> [0 .. obergrenze-1]
    }
    
    public static boolean roboterSuchen(Roboter[] arr) {

        for (int i = 0; i < 2; i++) {
            
            // doppelten Code vermeiden.
            
            // zuerst gehen oder drehen,
            if (arr[i].IstWand() == false) {
                arr[i].Schritt();
            }
            else {
                if (Math.random() * 2 < 1) {  // noch kürzer "if (Math.random() < 0.5)"
                    arr[i].LinksDrehen();
                } else {
                    arr[i].RechtsDrehen();
                }
            }
            
            // dann ausschau halten
            if (arr[i].IstRoboterInSicht() == true) {
                while (arr[i].IstRoboter() == false) {
                    arr[i].Schritt();
                }
                arr[i].MeldungAusgeben("Hab dich Roboter " + arr[i].RoboterVorneKennungGeben() + "!");
                return true;
            }
        }
        return false;
    }
}

// Warum diese beiden Methoden in eine eigene Klasse???
// Sie könnten genausogut in der "mainclass" Platz finden und wären dort auch gut
// aufgehoben. 
// Aber ich kenne auch die genaue Aufgabenstellung nicht.