Mehrere Methoden in einer Schleife Java

Question

Ich möchte mehrere Methoden mit der gleichen Schleife ausführen, aber ich habe ein Problem.

Lassen Sie uns sagen, ich habe die folgende Methode:

void xy1() { 
int y1 = 0; 
    for (int x = 0; x < 10; x++){ 
    y1 += x; 
    } 
} 

feine Arbeiten, alles, was ich tun müssen, ist Anruf es im Konstruktor.

Nun lassen Sie uns sagen, ich möchte auch eine andere Methode verwenden, aber mit einem anderen Anfangswert von y:

void xy2() { 
int y2 = 1; 
    for (int x = 0; x < 10; x++){ 
    y2 += x; 
    } 
} 

funktioniert auch gut.

Was ich will, ist jedoch, beide Methoden zur gleichen Zeit in der gleichen Schleife laufen zu lassen. Eine naheliegende Lösung wäre sie in ein Verfahren zu verschmelzen:

void xy(){ 
int y1 = 0; 
int y2 = 1; 

for (int x = 0; x < 10; x++){ 
y1 += x; 
y2 += x; 
    } 
} 

Diese chaotisch schnell bekommt aber, wenn mehr und mehr Variablen eingeführt werden. Also, was ich versucht zu tun war die Schleife im Konstruktor setzen, und haben es auf die Methoden in jedem Zyklus nennen: Suche

Constructor(){ 
int y1 = 0; 
int y2 = 1; 

for (int x = 0; x < 10; x++){ 
xy1(y1, x); 
xy2(y2, x); 
    } 
} 

Mit den Methoden wie folgt aus:

void xy1(int y1, int x) { 
y1 += x; 
} 

void xy2(int y2, int x) { 
y2 += x; 
} 

Das Problem dabei ist, von natürlich, dass jedes Mal, wenn der Konstruktor die Methoden aufruft, einfach die Anfangswerte von y1 und y2 übergeben werden, nicht die Werte, die sie aktuell haben sollten. Das Definieren der Anfangswerte in den Methoden würde dazu führen, dass sie in jedem Zyklus auf die gleiche Weise zurückgesetzt werden.

Also was ich brauche, ist für die Methoden irgendwie den letzten Wert von y für die neue Berechnung zu erinnern. Ich habe das Gefühl, dass es eine offensichtliche Lösung gibt, die ich vermisse ... Ich habe versucht, mit Google, aber ich weiß nicht wirklich, welche Suchbegriffe zu verwenden.

Und während wir dabei sind, da die von den Methoden durchgeführten Berechnungen die gleichen sind, wäre es großartig, wenn ich einfach eine einzige Methode xy definieren könnte und der Konstruktor sie mit verschiedenen Anfangswerten y (in die gleiche Schleife). Das Problem dabei wäre, dass es separate Instanzen von y geben müsste, also verhindere, dass man von zwei Instanzen der Methode manipuliert wird. (Hat das irgendeinen Sinn ergeben? Dies ist ein Problem, das ich erwarten werde.) Ich bin nicht ganz sicher, welche Form es nehmen wird.Ich kann immer eine neue Frage erstellen.)

Vielen Dank für jede Hilfe!

Answer 1

Sie müssten die Signatur der Methode so ändern, dass der berechnete Wert wie folgt zurückgegeben wird.

Danach müsste der Konstruktor geändert werden, um die berechneten Werte wie folgt den lokalen Variablen zuzuweisen.

Constructor(){ 
    int y1 = 0; 
    int y2 = 1; 

    for (int x = 0; x < 10; x++){ 
     y1 = Calc(y1, x); 
     y2 = Calc(y2, x); 
    } 
} 

Answer 2

Zunächst einmal ein einziges += eines anderes Verfahren zum Delegieren ist nicht notwendig, gelinde gesagt, aber ich werde einfach zu handeln, wie es eine weitere Bedeutung Operation innerhalb des Verfahrens erfolgt ist.

Code:

Constructor(){ 
    int y1 = 0; 
    int y2 = 1; 

    for (int x = 0; x < 10; x++){ 
     y1 = xy(y1, x); 
     y2 = xy(y2, x); 
    } 
} 

int xy(int y, int x) { 
    return y + x; 
} 

Wert wie xy(y1,x) Passing wird eine Kopie sowohl für die xy Methode, also in Ihrer zweiten Methode erstellen erhalten Sie den += Betrieb auf lokale Kopien durchführen, nicht der tatsächliche Wert, den Sie möchte erhöhen.

Answer 3

Sie deklarieren und instanziieren die Variablen y1 und y2 am Anfang der Methode, bevor Sie in die for-Schleife eintreten. Wenn Sie die for-Schleife eingeben, ist der Wert von y1 und y2 daher 0, aber danach wird der aktualisierte Wert von y1 und y2 verwendet, da Sie ihn nicht erneut deklarieren.

Wenn Sie die Methoden xy1 und xy2 innerhalb der for-Schleife aufrufen, weil Sie die Variablen innerhalb der Methoden xy1 und xy2 deklarieren, sind die Werte von y1 und y2 die ersten, da die Variablen immer wieder deklariert werden Jedes Mal, wenn die Schleife ausgeführt wird.

wird Eine mögliche Lösung dieses sein:

public void calculate() { 

    int y1 = 0; 
    int y2 = 1; 

    for(int i = 0; i < 10; i++) { 
     y1 += i; 
     y2 += i; 
     System.out.printf("y1: %d, y2: %d \n", y1, y2); 
    } 

} 

Answer 4

Ich bin ein Neuling in der Programmierung, aber ich fühle, dass es um ein Objekt zu verwenden und beschreiben, jedes Ereignis für das Objekt, das wird der Code, indem Sie besser ist kürzer und klarer.