Scambia oggetti in java
Questo articolo dimostrerà le metodologie a "scambiare oggetti" usando Java.
Come "scambiare oggetti" in Java?
Gli oggetti in Java possono essere scambiati utilizzando la funzione definita dall'utente combinata con quanto segue:
- "Operatori aritmetici".
- "WrapperClasse "e"Operatore di assegnazione".
Approccio 1: scambiare oggetti in Java usando gli "operatori aritmetici"
In questo approccio, gli oggetti di classe possono essere scambiati eseguendo operazioni aritmetiche sugli oggetti creati tramite "definito dall'utente" funzione:
Classe SwappingObjEtà pubblica;
Public SwappingObj (int age)
Questo.età = età;
Classe pubblica Temp
swap di vuoto statico pubblico (valori scambiati1,
Swappingobj value2)
valore1.età = value1.età + valore2.età;
valore2.età = value1.Età - Valore2.età;
valore1.età = value1.Età - Valore2.età;
Secondo quanto sopra "classe"Codice, applica i seguenti passaggi:
- In primo luogo, definisci una classe chiamata "Scambiandobj".
- Nella sua definizione, specificare la variabile dichiarata.
- Inoltre, crea un costruttore di classe con il parametro dichiarato.
- Nella definizione del costruttore, fare riferimento alla variabile specificata e allocarla al valore del parametro tramite "Questo".
- Si noti che questo valore verrà passato in seguito come argomento tramite "principale()" metodo.
- Ora, definisci una funzione chiamata "scambio()"Avere i parametri forniti che si riferiscono agli oggetti che devono essere scambiati.
- Nella sua definizione, fare riferimento alla variabile di classe principale specificata, i.e., "età".
- Successivamente, conservare l'aggiunta del superato "età"Valori nel parametro della funzione precedente, i.e., "valore1".
- Allo stesso modo, restituire la sottrazione del superato "età"Valori in primo luogo negli oggetti indicati"valore2"E poi in"valore1".
- Nota: La sottrazione negli ultimi due casi non produrrà lo stesso risultato dal valore aggiornato dei parametri, i.e., "valore1" E "valore2"Sarà invocato nel secondo ultimo e ultimo calcolo, rispettivamente.
Ora, facciamo la panoramica del sotto fornito "principale()" metodo:
public static void main (string [] args)SwappingObj obj1 = new SwappingObj (18);
SwappingObj obj2 = nuovo SwappingObj (25);
Sistema.fuori.println ("prima di scambiare->");
Sistema.fuori.println ("Il primo oggetto è:" + obj1.età);
Sistema.fuori.println ("Il secondo oggetto è:" + obj2.età);
swap (obj1, obj2);
Sistema.fuori.println ("dopo lo scambio->");
Sistema.fuori.println ("Il primo oggetto è:" + obj1.età);
Sistema.fuori.println ("Il secondo oggetto è:" + obj2.età);
In questo frammento di codice:
- Crea due oggetti di classe chiamati "obj1" E "obj2"Tramite il"nuovo"Parola chiave e"Scambiandobj ()"Costruttore, rispettivamente.
- Nel parametro del costruttore, passa i due "età"Valori che devono essere scambiati e visualizzarli.
- Ora, invoca la funzione "scambio()"E passare gli oggetti di classe creati come argomenti.
- Ciò di conseguenza scambierà i valori degli oggetti passati tramite gli operatori aritmetici.
Intero codice
Classe SwappingObjEtà pubblica;
Public SwappingObj (int age)
Questo.età = età;
Classe pubblica Temp
swap di vuoto statico pubblico (valori scambiati1,
Swappingobj value2)
valore1.età = value1.età + valore2.età;
valore2.età = value1.Età - Valore2.età;
valore1.età = value1.Età - Valore2.età;
public static void main (string [] args)
SwappingObj obj1 = new SwappingObj (18);
SwappingObj obj2 = nuovo SwappingObj (25);
Sistema.fuori.println ("prima di scambiare->");
Sistema.fuori.println ("Il primo oggetto è:" + obj1.età);
Sistema.fuori.println ("Il secondo oggetto è:" + obj2.età);
swap (obj1, obj2);
Sistema.fuori.println ("dopo lo scambio->");
Sistema.fuori.println ("Il primo oggetto è:" + obj1.età);
Sistema.fuori.println ("Il secondo oggetto è:" + obj2.età);
Produzione
In questo risultato, si può analizzare che i valori degli oggetti vengono scambiati in modo appropriato.
Approccio 2: scambiare oggetti in Java usando la "classe wrapper" e "operatore di assegnazione"
In questo particolare approccio, l'oggetto di classe creato può essere scambiato con l'aiuto di una classe wrapper esterna facendo un riferimento alla classe principale e all'operatore di assegnazione "=":
Oggetto di classeEtà pubblica;
oggetto (int age)
Questo.età = età;
Classe Wrapper
Oggetto x;
Wrapper (oggetto interno)
Questo.x = interno;
classe pubblica temp2
STATICO STATICO SWAP (Wrapper Object1, Wrapper Object2)
temp oggetto;
temp = object1.X;
Oggetto1.X = Object2.X;
Oggetto2.x = temp;
Nelle righe precedenti del codice di classe, applica i seguenti passaggi:
- Ricorda gli approcci discussi per definire una classe e fare riferimento alla variabile specificata con l'aiuto del costruttore di classe.
- Dopodiché, dichiara una classe di avvolgimento chiamata "Wrapper".
- Nella sua definizione, fare riferimento alla classe principale denominata "oggetto"E specifica la variabile"X"Basato su questo.
- Inoltre, includi un costruttore di classe e assegna il valore dell'oggetto passato alla variabile specificata tramite "Questo".
- Ora, allo stesso modo, definisci una funzione di swap chiamata "scambio()"Dove i parametri della funzione indicano i valori degli oggetti che devono essere scambiati.
- Nella definizione della funzione, allo stesso modo, passare un riferimento della classe principale alla variabile "temp"E assegnalo il valore dell'oggetto precedente avvolto nella classe Wrapper.
- Nel passaggio successivo, allocare il valore di quest'ultimo oggetto all'oggetto precedente.
- Infine, assegna il valore aggiornato di "temp"A quest'ultimo oggetto avvolto, io.e., "Oggetto2".
Ora, procediamo a "principale()" metodo:
public static void main (string [] args)oggetto ob1 = nuovo oggetto (25);
oggetto ob2 = nuovo oggetto (30);
Wrapper swapobject1 = nuovo wrapper (ob1);
Wrapper swapobject2 = nuovo wrapper (OB2);
Sistema.fuori.println ("prima di scambiare -> \ nage1:" + swapobject1.X.età +
"\ n" + "age2:"
+ swapobject2.X.età + "\ n");
swap (swapObject1, swapObject2);
Sistema.fuori.println ("Dopo lo scambio -> \ nage1:" + swapobject1.X.età +
"\ n" + "age2:"
+ swapobject2.X.età);
Secondo quanto sopra "principale()"Metodo, applica i seguenti passaggi:
- Ripeti gli approcci spiegati per la creazione di oggetti di classe e passa il dichiarato "età"Valori come parametri del costruttore.
- Nel passaggio successivo, crea due oggetti di classe Wrapper e avvolgi gli oggetti della classe principale come parametri del costruttore.
- Inoltre, visualizza il risultato prima di scambiare gli oggetti.
- Ora, accedi al "scambio()"Funzionare e passare gli oggetti di classe avvolti come argomenti.
- Ciò comporterà lo scambio di "principale"Oggetti di classe.
Intero codice
Oggetto di classeEtà pubblica;
oggetto (int age)
Questo.età = età;
Classe Wrapper
Oggetto x;
Wrapper (oggetto interno)
Questo.x = interno;
classe pubblica temp2
STATICO STATICO SWAP (Wrapper Object1, Wrapper Object2)
temp oggetto;
temp = object1.X;
Oggetto1.X = Object2.X;
Oggetto2.x = temp;
public static void main (string [] args)
oggetto ob1 = nuovo oggetto (25);
oggetto ob2 = nuovo oggetto (30);
Wrapper swapobject1 = nuovo wrapper (ob1);
Wrapper swapobject2 = nuovo wrapper (OB2);
Sistema.fuori.println ("prima di scambiare -> \ nage1:" + swapobject1.X.età +
"\ n" + "age2:"
+ swapobject2.X.età + "\ n");
swap (swapObject1, swapObject2);
Sistema.fuori.println ("Dopo lo scambio -> \ nage1:" + swapobject1.X.età +
"\ n" + "age2:"
+ swapobject2.X.età);
Produzione
Questo output implicava che lo scambio viene eseguito in modo appropriato tramite la classe wrapper e la funzione definita dall'utente.
Conclusione
Gli oggetti in Java possono essere scambiati utilizzando la funzione definita dall'utente combinata con "Operatori aritmetici" o il "WrapperClasse "e"Operatore di assegnazione". Il primo approccio scambia gli oggetti ed esegue semplicemente i calcoli in base ai valori degli oggetti aggiornati in ogni fase. Quest'ultimo approccio applica lo scambio facendo riferimento agli oggetti della classe principale, avvolgendoli e utilizzando l'operatore di assegnazione nella funzione definita dall'utente. Questo articolo ha guidato sullo scambio di oggetti in Java.