Comment changer les arguments dans la méthode [Java] (pour ceux qui sont confus en passant par valeur, passant par référence, passant par référence)

en premier

Transmettez la valeur à la méthode et traitez la valeur dans la méthode

Je ne savais pas quoi faire en Java, qui n'a pas de pointeurs ou de passage par référence comme C ++, donc j'étais confus lors de l'enquête et de l'enquête (principalement en passant par référence / passant par valeur de référence). Je vais résumer de telles choses.

Bien que j'écris un article, je suis en contact avec Java depuis environ 3 mois, je vous serais donc reconnaissant si vous pouviez signaler des erreurs.

Passer par valeur

Par exemple, écrivez le code ci-dessous qui double la valeur de la méthode en tant qu'argument dans la méthode. (Ce code ne fonctionne pas comme prévu)

java

public class Main{
    /*Double la valeur de la méthode*/
    public static void twice(int n){
        n *= 2;
    }
    /*Fonction principale*/
    public static void main(String[] args){
        int num = 2;
        twice(num);
        System.out.println(num);   //2
    }
}   

Par conséquent, la valeur de num n'est pas réécrite dans la méthode et le 2 déclaré à l'origine est sorti tel quel. Il semble que vous transmettez la variable num à la méthode telle quelle, mais seule la valeur à l'intérieur de ** num ** est transmise à la méthode. C'est ce qu'on appelle ** passer par valeur **.

Pour réécrire des valeurs en Java

Il n'y a pas de pointeur ou de passage par référence lorsque j'essaye de réécrire la valeur (je l'écris comme ça maintenant) Comment dois-je réécrire la valeur en Java? La méthode consiste à utiliser un tableau ou une variable de type classe.

Exemple d'utilisation d'un tableau

array

public class Main {
    /*Changé pour passer un tableau*/
	public static void twice(int[] n){
        n[0] *= 2;
    }
    /*Fonction principale*/
    public static void main(String[] args){
        int num[] = new int[1];
        num[0] = 2;
        twice(num);
        System.out.println(num[0]);   //4
    }  
}

Exemple d'utilisation d'une classe pour stocker des valeurs

Data.java

public class Data {
	int num;  //Champ pour le stockage des données
}

Main.java

public class Main {
    /*Modifié pour transmettre une instance de la classe de stockage de données*/
	public static void twice(Data ins){
        ins.num *= 2;
    }
    /*Fonction principale*/
    public static void main(String[] args){
        Data data = new Data();
        data.num = 2;
        twice(data);
        System.out.println(data.num);   //4
    } 
}

Alors pourquoi les tableaux et les instances peuvent-ils réécrire des valeurs dans des méthodes? Regardons maintenant les arguments des méthodes Java (pour ceux qui sont confus en passant par valeur, passant par référence, passant par référence).

Arguments de la méthode Java

C'est peut-être une expression trompeuse, mais je suis tombé ici, alors je vais le dire en premier. Il n'y a que ** passant par valeur ** en Java **. Oubliez de passer par référence et de passer par valeur.

Ce qui est passé à la méthode en Java

J'ai dit que Java n'existe que par valeur, mais il existe deux types de valeurs qui sont transmises en fonction du type de variable. Tout d'abord, les types de variables sont grossièrement divisés en deux en Java. ・ Type de base · Type de référence Il existe une variable de. Et ce qu'il faut passer lorsqu'il est défini dans l'argument de chaque méthode est différent.

Au moment du type de base

Tout d'abord, le type de base est

Ça fait référence à. Lors de leur transmission en tant qu'arguments de méthode, Java ne les transmet que par valeur. En d'autres termes, seule la valeur du contenu de la variable est transmise, donc changer la valeur de l'argument dans la méthode ne change pas la valeur de l'argument passé.

Lorsqu'il s'agit d'un type de référence

Puis pour le type de référence

・ Type de classe ・ Type de matrice

Etc. Ils transmettent leur ** valeur de référence ** lorsqu'ils deviennent des arguments de méthode. Maintenant, quelle est la valeur de référence ici?

Qu'est-ce qu'une valeur de référence?

La valeur de référence est une image ** Où la variable existe ** Ce sera. En langage C, c'est une image de quelque chose comme un pointeur.

Pourquoi la valeur est réécrite dans la méthode

Java ne vous permet pas de modifier les arguments au sein d'une méthode (sans surprise car il n'existe que par valeur). Cependant, la transmission d'une valeur de référence vous permet de réécrire la valeur via l'emplacement de cette valeur de référence.

Qu'est-ce qui diffère du passage par référence

Ici, ce qui est différent du passage par référence, mais en Java ** Passer en copiant la valeur de l'emplacement où existe la variable appelée valeur de référence (bien sûr, la valeur de référence ne peut pas être réécrite) ** Il fait l'opération. Passer par référence ** Transmettez l'emplacement de la variable tel quel ** Il fait l'opération. Le résultat est un comportement similaire, mais Java ne passe pas par référence, mais par valeur.

Un exemple montrant que vous passez une valeur de référence par valeur

Réécrivez le code qui réécrivait la valeur dans la méthode à l'aide de la classe de stockage de données précédemment comme suit.

Data.java

public class Data {
	int num;  //Champ pour le stockage des données
}

Main.java

public class Main {
	
    /*Passer une instance de la classe*/
	public static void twice(Data n){
		/*Créer une nouvelle instance dans une méthode*/
		Data inMethodInstance = new Data();
		/*Donner des données*/
		inMethodInstance.num = n.num * 2;  //4
		/*Réécriture de la valeur de référence*/
        n = inMethodInstance;
    }
	
    /*Fonction principale*/
    public static void main(String[] args){
        Data data = new Data();
        data.num = 2;
        twice(data);
        System.out.println(data.num);  //2
    }  
}

Si vous passez à un tel code et que vous l'exécutez, vous pouvez voir que 2 est sorti. Si le passage par référence est effectué, il se fait à la fin de la méthode

n = inMethodInstance

Dans la partie de, n doit être réécrit et 4 doit être affiché.

Au fait, si vous écrivez le code pour que le code écrit en Java soit passé par référence en C ++, ce sera comme suit.

data.h

#ifndef DATA_H_
#define DATA_H_
/*Classe de stockage de données*/
class data 
{
public:
	int num;
};

#endif

main.cpp

#include <iostream>
#include "data.h"

void twice(data &d) {
	/*Instancier dans une méthode*/
	data inMethodInstance;
	/*Donner une valeur à l'instance dans la méthode*/
	inMethodInstance.num = d.num * 2;
	/*Réécrire l'argument*/
	d = inMethodInstance;
}

int main(void)
{
	data ins;
	ins.num = 2;
    std::cout << ins.num << std::endl;  //2
	twice(ins);
	std::cout << ins.num << std::endl;  //4
}

En C ++ qui peut passer par référence de cette manière, la valeur de l'argument peut être réécrite.

Le passage par référence n'existe pas en Java

En fait, il n'y a pas de passage par référence en Java. Seul le passage par valeur existe. Cependant, vous pouvez modifier la valeur via une valeur de référence.

Je pense que vous pourriez penser à tort que le passage par référence existe dans la partie où vous pouvez changer la valeur via une valeur de référence, mais Java n'existe qu'en passant par valeur.

À la fin

Cette fois, j'ai résumé ce que j'ai étudié sur la façon de réécrire les valeurs dans les méthodes Java. Depuis que j'ai écrit l'article pour la première fois, il peut être difficile à lire, mais jetez un œil ...