Passaggio per valore e per riferimento in Java (domande comuni alle interviste)

Ecco una copia di una domanda di colloquio/proofreading:

Dopo che un oggetto è stato passato come parametro a un metodo, questo metodo può modificare le proprietà dell'oggetto e può restituire il risultato modificato, allora qui è un passaggio per valore o per riferimento?

Risposta:

È un passaggio per valore. La chiamata di metodo del linguaggio Java supporta solo il passaggio per valore. Quando un'istanza di oggetto viene passata come parametro a un metodo, il valore del parametro è un riferimento all'oggetto. Le proprietà dell'oggetto possono essere modificate durante la chiamata, ma le modifiche al riferimento all'oggetto non influenzeranno il chiamante. In C++ e C# è possibile modificare il valore passato tramite passaggio per riferimento o parametri di output. In C# è possibile scrivere il codice come mostrato di seguito, ma non è possibile farlo in Java.

Passaggio per valore e passaggio per riferimento (passaggio per indirizzo) in Java, per comprendere questi due concetti, è necessario comprendere il passaggio per valore e per riferimento.

Facciamo un esempio semplice per illustrare:

Ad esempio, se vai in viaggio all'estero e fai una foto eccezionale, e vuoi condividerla con i tuoi amici, ci sono due modi, il primo è mandare direttamente la foto ai tuoi amici, ovvero dare una copia della foto ai tuoi amici; il secondo modo è se carichi questa splendida foto su QQ (Weibo) o altro, otterrai un indirizzo di accesso alla foto (Url), quindi condividi questo url con i tuoi amici.
Come nell'esempio sopra, il primo può essere considerato un passaggio per valore, il secondo può essere considerato un passaggio per riferimento (passaggio per indirizzo). Conosciuta questa concezione, procediamo con un'analisi semplice.

Passaggio per valore:Solo quando il parametro è una variabile di tipo di base, Java passa in questo modo.

Se condividi la foto, l'amico riceve una copia della tua foto, quindi le modifiche dell'amico non influenzano la tua foto, e le tue modifiche non influenzano la foto condivisa con l'amico.

Passaggio per riferimento:Solo quando il parametro è una variabile di tipo riferimento, Java passa in questo modo.
Se condividi l'URL con un amico, se l'amico ha il permesso di modificare, quando l'amico esegue l'operazione sulla foto, la foto che lui vede è il risultato dell'operazione dell'amico.

Di seguito, esprimiamo questo esempio tramite codice:

package com.dufy.reforvalue;
import java.util.Arrays;
*/
 * Passaggio per valore e per riferimento in Java
 * Passaggio per valore: variabile di tipo di base - passaggio per valore, il passaggio per valore avviene tramite la copia dei parametri
 * Passaggio per riferimento: variabile di tipo riferimento - passaggio per riferimento, il passaggio per riferimento avviene tramite l'indirizzo di riferimento dell'oggetto
 * 
 * @autore dufy
 * @creazione 9 febbraio 2017
 */
public class ReferenceOrValue {
 */
  * Tipi di base, passaggio per valore
  * Esempio: condividere la tua foto con un amico, l'amico riceve una copia effettiva della tua foto:
  * Tu e il tuo amico eseguite operazioni separate sulle vostre foto, senza influenzare l'altra!
  */
 public static void testVal(int photo){
  photo++;//Il tuo amico modifica la foto
  System.out.println("Il mio amico vede la foto = " + photo);
 }
 */
  * Tipo di riferimento: passaggio per riferimento
  * Esempio: condividere la tua foto con un amico, condividi l'URL (indirizzo) di una foto che hai caricato su Internet:
  * Tu e il tuo amico possono accedere a questa indirizzo e eseguire un'operazione sulla foto!
  */
 public static void testRef(Photo photo){
  photo.setPhoto("Foto java, fantastica!");//Il tuo amico modifica la tua foto
  System.out.println("Il mio amico vede la foto = " + photo.getPhoto());
 }
 */
  * Tipo di riferimento: passaggio per riferimento
  * Poiché l'array è un tipo di riferimento. Quindi quello che si passa è il loro riferimento, quindi il loro valore viene scambiato nel metodo e influisce anche sui loro valori originali.
  */
 public static void testArrayRef(int[] array){
  for (int i = 0; i < array.length; i++) {
   array[i] = 0;
  }
  System.out.println("testArrayRef array è = "+Arrays.toString(array));
 }
 public static void main(String[] args) {
  //Un: passaggio per valore
  int photo = 10;//Definire la foto da inviare
  testVal(photo);//Inviare la foto al tuo amico, il tuo amico riceverà una copia
  System.out.println("Io vedo la foto = " + photo);
  //Due: passaggio per indirizzo
  Photo p = new Photo();//Definire un oggetto foto, che ho scattato io stesso java photo
  p.setPhoto("java photo");
  testRef(p);//Inviare l'oggetto foto (cioè l'indirizzo URL) al tuo amico, il tuo amico riceverà un URL (indirizzo), aprire l'URL è la foto
  System.out.println("Il mio amico vede la foto = " + p.getPhoto());
  //Tre: l'array è un oggetto, l'array è nella memoria heap. Il riferimento è nello stack.
  int array[] = {1,2,3,4,5};
  testArrayRef(array);
  System.out.println("array è = "+Arrays.toString(array));
 }
 */
  /* Fotografica classe
  */
 static class Photo{
  String photo;
  public String getPhoto() {
   return photo;
  }
  public void setPhoto(String photo) {
   this.photo = photo;
  }
 }
}

Il risultato dell'output è il seguente:

Il mio amico vede la foto = 11
Io vedo la foto = 10
Il mio amico vede la foto = java Photo,Grande!
Il mio amico vede la foto = java Photo,Grande!
testArrayRef array è = [0, 0, 0, 0, 0]
array è = [0, 0, 0, 0, 0]

Interruzione: ecco la domanda: come dovrebbe essere scritto questo metodo?

public static void main(String[] args) {
  int a = 10;
  int b = 20;
  method(a,b);//Deve stampare solo a=100,b=200 dopo che method è stato chiamato, scrivi il metodo method(a,b)!
  System.out.println("a = " + a);
  System.out.println("b = " + b);
 }

Certo, molte persone, come me prima, non hanno pensato due volte prima di scrivere il seguente codice:

private static void method(int a, int b) {
  a*=10;
  b*=10;
 }

Ma dopo aver eseguito il programma, scoprirai che non vengono stampati i risultati desiderati!

Se guardi attentamente la descrizione sopra, non dovrebbe essere difficile capire perché si ottiene questo risultato!

Ecco i risultati possibili di questa domanda:

private static void method(int a, int b) {
  System.out.println("a=100,b=200");
  System.exit(0);
 }

Come ha spiegato l'editor a tutti voi, spero che il passaggio di trasmissione per valore e per riferimento in Java (comune nelle interviste) sia utile a tutti voi. Se avete qualsiasi domanda, lasciate un commento, l'editor risponderà tempestivamente. In questo senso, ringrazio anche tutti i sostenitori del sito tutorial Yell.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta ai rispettivi autori, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente i contenuti sospetti di violazione del copyright.