Variablenwerte ändern ohne return Statement?

[javapingu]

Hallo liebe Community,

Ich möchte einige Variablen aus der main Methode ändern, mithilfe einer anderen Methode. Dabei soll die genutzte Methode void sein und die Ausgabe der neuen Variablen-Werte soll auch in der main Methode selbst erfolgen.

Zum Beispiel:
[CODE lang="java" title="Beispiel"]public class Aendern {
public static void main(String[] args) {
int a= 1;

// ...code

System.out.println("Ausgabe des veränderten Wertes von a");
}

// methode ohne return
}[/CODE]

Aber im Grunde funktioniert doch Java genau so nicht, oder? Deshalb gibt es doch Parameterübergabe und return in Java?
Leider ist das beste, was mir nach Recherchen eingefallen ist, die Nutzung eines AtomicIntegers, der das Problem vermeidet, dass eine Kopie erstellt wird.
Mein Lösungsvorschlag:

package testUmgebung;

import java.util.concurrent.atomic.AtomicInteger;

public class Aendern {
    public static void main(String[] args) {
        int x = 1;

        AtomicInteger a = new AtomicInteger(x);
        int faktor1 = x + 1;

        aendere(a, faktor1);
        System.out.println("a: " + a);
    }

    static void aendere(AtomicInteger xToa, int faktor1) {
        xToa.set(faktor1);
    }

}

Leider muss ich dazu jedoch diesen Importieren...und ich glaube nicht das, dass im Sinne der Lösung ist :/
Leider fehlt mir auch jegliche Idee wie ich das ohne Konstante Felder, return oder Output in der aendere Methode realisieren könnte >.< Stehe leider total im Wald...

Über Hilfe würde ich mich riesig freuen

Vielen Dank!

 

[Oneixee5]

Du kannst auch ein Array mit a als einziges Element übergeben. Dann kannst du das einzige Element ändern und in der Main weiterverenden.

 

[javapingu]

Du kannst auch ein Array mit a als einziges Element übergeben. Dann kannst du das einzige Element ändern und in der Main weiterverenden.

Autsch. 🤦‍♂️Ohhjjeee - das ich bei soetwas mit irgendwelchen AtomicIntegern um mich werfe Dankeschön Ich bin einfach nicht darauf gekommen 🤦‍♂️🤦‍♂️🤦‍♂️😅
Vielen Dank - es läuft jetzt

 

[mihe7]

Naja, ob AtomicInteger oder Array: Du brauchst halt eine Referenz auf den Wert - der dann auch veränderbar sein muss. Da bietet sich also AtomicInteger durchaus an. Natürlich könnte man auch selbst eine Klasse (z. B. IntValueHolder) einführen.

 

[javapingu]

Naja, ob AtomicInteger oder Array: Du brauchst halt eine Referenz auf den Wert - der dann auch veränderbar sein muss. Da bietet sich also AtomicInteger durchaus an. Natürlich könnte man auch selbst eine Klasse (z. B. IntValueHolder) einführen.

Ich verstehe. Im Endeffekt könnte ich auch einen Pointer nehmen.
Hauptsache es ist etwas was eine Referenz zu dem Wert direkt hat - denn so wird auch der Wert aufgrund der Referenz tatsächlich geändert. Also so ungefähr könnte es ja auch mit einem Pointer (und wahrscheinlich noch zig anderen Lösungsmöglichkeiten?) aussehen:

import java.awt.Point;
//main
Point zuAendern = new Point(x, 1);

public static void aendere(Point zuAendern) {
    int newPoint = zuAendern.x * zuAendern.y;
    zuAendern.setLocation(newPoint, zuAendern.y);
}

Was mich jetzt interessiert: In so einer Klasse IntValueHolder müsste ich die Referenz zu den Variablen herstellen richtig?

Vielen Dank - jetzt verstehe ich das ganze auch viel besser

 

[mihe7]

Im Endeffekt könnte ich auch einen Pointer nehmen.

Ja, wenn es den in Java geben würde

In so einer Klasse IntValueHolder müsste ich die Referenz zu den Variablen herstellen richtig?

Im einfachsten Fall besteht die Klasse einfach aus einem Attribut, das eben den int-Wert speichert.

Kleines Beispiel:

public class Test {
    static class IntValueHolder {
         int value;
    }

    public static void main(String[] args) {
        IntValueHolder holder = new IntValueHolder();
        holder.value = 5;
        
        updateValue(holder);
        System.out.println(holder.value);
    }

    private static void updateValue(IntValueHolder holder) {
        holder.value = (int)(Math.random() * 1000);
    }    
}

Hinweis: das ist keine Best Practice. Sinnvollerweise erstellt man von vornherein geeignete Abstraktionen (Klassen), die das Problem modellieren. Dann hat man die Attribute eben gleich dort, wo sie hingehören

 

[mrBrown]

Also so ungefähr könnte es ja auch mit einem Pointer (und wahrscheinlich noch zig anderen Lösungsmöglichkeiten?) aussehen:

Point != Pointer – Point ist ein Punkt in einem zwei-dimensionalen Koordinaten-System


Generell kann man alle Klassen/Typen, die veränderlich sind, für sowas missbrauchen. Am sinnvollsten ist aber, einen expliziten Typ dafür zu nutzen oder selbst einen passenden zu erstellen. Alles andere hat nur Nachteile, sei es beim Array die fehlende Typsicherheit (das Array kann auch 0 oder 5 Elemente enthalten, statt dem genau einem erwarteten) oder der völlig nichtssagenden Typen bei Point (wie soll irgendwer drauf kommen, dass Point kein Punkt ist, sondern beide Werte als Parameter und der eine Wert dann zur Rückgabe genutzt werden soll?).


AtomicInteger bietet sich an, einfach weil es schon da ist und häufig dafür benutzt wird. Besser wäre es aber, einen expliziten Typen dafür zu modellieren, zB MutableInt oä, was dann auch nur Methoden zum ändern des Wertes bietet.

 

[javapingu]

Ein riesen großes Dankeschön @mihe7 für den Code
Und auch richtig großes Danke an @mrBrown =) MuteableInt klingt echt cool
p.s.: und ich werde aufpassen präziser zu formulieren Ich meinte natürlich Point aus java.awt.*

Schönen Abend noch Allen