Échanger des objets en java
Cet article démontrera les méthodologies pour «échanger des objets» en utilisant Java.
Comment «échanger des objets» en Java?
Les objets de Java peuvent être échangés à l'aide de la fonction définie par l'utilisateur combinée avec les éléments suivants:
- "Opérateurs arithmétiques".
- "Emballage"Classe et"Opérateur d'assignation".
Approche 1: échange d'objets en Java en utilisant les «opérateurs arithmétiques»
Dans cette approche, les objets de classe peuvent être échangés en effectuant des opérations arithmétiques sur les objets créés via le «défini par l'utilisateur" fonction:
classe swappingoBjL'âge public;
public swappingObj (int age)
ce.âge = âge;
classe publique Temp
Échange de void statique public (SwappingObj Value1,
SwappingoBj value2)
valeur 1.Âge = valeur1.Âge + valeur2.âge;
valeur2.Âge = valeur1.Âge - Valeur2.âge;
valeur 1.Âge = valeur1.Âge - Valeur2.âge;
Selon ce qui précède "classe»Code, appliquez les étapes suivantes:
- Tout d'abord, définissez une classe nommée «Swappingobj".
- Dans sa définition, spécifiez la variable indiquée.
- Créez également un constructeur de classe ayant le paramètre déclaré.
- Dans la définition du constructeur, reportez-vous à la variable spécifiée et allouez-la à la valeur du paramètre via «ce".
- Notez que cette valeur sera transmise plus tard en tant qu'argument via le «principal()" méthode.
- Maintenant, définissez une fonction nommée «échanger()«Avoir les paramètres fournis se référant aux objets qui doivent être échangés.
- Dans sa définition, reportez-vous à la variable de classe principale spécifiée, i.e., "âge".
- Après cela, stockez l'ajout du passé "âge»Valeurs dans l'ancien paramètre de fonction, i.e., "valeur 1".
- De même, renvoyez la soustraction du passé «âge«Valeurs d'abord dans les objets référés«valeur2"Et puis dans"valeur 1".
- Note: La soustraction dans les deux derniers cas ne donnera pas le même résultat depuis la valeur mise à jour des paramètres, i.e., "valeur 1" et "valeur2"Sera invoqué dans les deuxième et derniers derniers calculs, respectivement.
Maintenant, présentons-nous le ci-dessous "principal()" méthode:
public static void main (String [] args)SwappingObj obj1 = new swappingObj (18);
SwappingObj obj2 = new swappingObj (25);
Système.dehors.println ("avant d'échanger->");
Système.dehors.println ("Le premier objet est:" + obj1.âge);
Système.dehors.println ("Le deuxième objet est:" + obj2.âge);
swap (obj1, obj2);
Système.dehors.println ("After Swapping->");
Système.dehors.println ("Le premier objet est:" + obj1.âge);
Système.dehors.println ("Le deuxième objet est:" + obj2.âge);
Dans cet extrait de code:
- Créer deux objets de classe nommés «obj1" et "obj2"Via le"nouveau»Mot-clé et«SwappingObj ()”Constructeur, respectivement.
- Dans le paramètre du constructeur, passez les deux "âge”Des valeurs qui doivent être échangées et les afficher.
- Maintenant, invoquez la fonction "échanger()»Et passez les objets de classe créés comme ses arguments.
- Cela échangera en conséquence les valeurs d'objet passées via les opérateurs arithmétiques.
Code entier
classe swappingoBjL'âge public;
public swappingObj (int age)
ce.âge = âge;
classe publique Temp
Échange de void statique public (SwappingObj Value1,
SwappingoBj value2)
valeur 1.Âge = valeur1.Âge + valeur2.âge;
valeur2.Âge = valeur1.Âge - Valeur2.âge;
valeur 1.Âge = valeur1.Âge - Valeur2.âge;
public static void main (String [] args)
SwappingObj obj1 = new swappingObj (18);
SwappingObj obj2 = new swappingObj (25);
Système.dehors.println ("avant d'échanger->");
Système.dehors.println ("Le premier objet est:" + obj1.âge);
Système.dehors.println ("Le deuxième objet est:" + obj2.âge);
swap (obj1, obj2);
Système.dehors.println ("After Swapping->");
Système.dehors.println ("Le premier objet est:" + obj1.âge);
Système.dehors.println ("Le deuxième objet est:" + obj2.âge);
Sortir
Dans ce résultat, il peut être analysé que les valeurs d'objet sont échangées de manière appropriée.
Approche 2: échanger des objets en Java à l'aide de la «classe wrapper» et de «l'opérateur d'affectation»
Dans cette approche particulière, l'objet de classe créé peut être échangé à l'aide d'une classe de wrapper externe en faisant référence à la classe principale et à l'opérateur d'affectation "=»:
classe objetL'âge public;
objet (int age)
ce.âge = âge;
Classe Wrapper
objet x;
Wrapper (objet intérieur)
ce.x = intérieur;
classe publique temp2
Swap de void statique (wrapper object1, wrapper object2)
tempor d'objet;
temp = object1.X;
objet1.x = objet2.X;
objet2.x = temp;
Dans les lignes de code de classe ci-dessus, appliquez les étapes suivantes:
- Rappelez-vous les approches discutées pour définir une classe et se référer à la variable spécifiée à l'aide du constructeur de classe.
- Après cela, déclarez une classe d'emballage nommée «Emballage".
- Dans sa définition, reportez-vous à la classe principale nommée «objet"Et spécifiez la variable"X" basé sur cela.
- Incluez également un constructeur de classe et attribuez la valeur d'objet passée à la variable spécifiée via "ce".
- Maintenant, de même, définissez une fonction de swap nommée «échanger()”Lorsque les paramètres de fonction pointent vers les valeurs d'objet qui doivent être échangées.
- Dans la définition de la fonction, de même, passez une référence de la classe principale à la variable "temp»Et attribuez-le l'ancienne valeur d'objet enveloppé dans la classe de wrapper.
- À l'étape suivante, allouer la valeur de ce dernier objet à l'ancien objet.
- Enfin, attribuez la valeur mise à jour de "temp«À ce dernier objet emballé, je.e., "objet2".
Maintenant, passons au «principal()" méthode:
public static void main (String [] args)objet ob1 = nouvel objet (25);
objet ob2 = nouvel objet (30);
Wrapper swapObject1 = nouveau wrapper (ob1);
Wrapper swapObject2 = nouveau wrapper (ob2);
Système.dehors.println ("Avant d'échanger -> \ nage1:" + swapObject1.X.âge +
"\ n" + "Age2:"
+ swapobject2.X.âge + "\ n");
swap (swapObject1, swapObject2);
Système.dehors.println ("après échange -> \ nage1:" + swapObject1.X.âge +
"\ n" + "Age2:"
+ swapobject2.X.âge);
Selon ce qui précède "principal()«Méthode, appliquez les étapes suivantes:
- Répétez les approches expliquées pour créer des objets de classe et passer le indiqué «âge»Valeurs en tant que paramètres du constructeur.
- Dans l'étape suivante, créez deux objets de classe en wrapper et enveloppez les objets de classe principale comme paramètres du constructeur.
- Aussi, affichez le résultat avant d'échanger les objets.
- Maintenant, accédez au «échanger()”Fonctionne et passez les objets de classe enveloppés comme ses arguments.
- Cela entraînera l'échange du «principal»Objets de classe.
Code entier
classe objetL'âge public;
objet (int age)
ce.âge = âge;
Classe Wrapper
objet x;
Wrapper (objet intérieur)
ce.x = intérieur;
classe publique temp2
Swap de void statique (wrapper object1, wrapper object2)
tempor d'objet;
temp = object1.X;
objet1.x = objet2.X;
objet2.x = temp;
public static void main (String [] args)
objet ob1 = nouvel objet (25);
objet ob2 = nouvel objet (30);
Wrapper swapObject1 = nouveau wrapper (ob1);
Wrapper swapObject2 = nouveau wrapper (ob2);
Système.dehors.println ("Avant d'échanger -> \ nage1:" + swapObject1.X.âge +
"\ n" + "Age2:"
+ swapobject2.X.âge + "\ n");
swap (swapObject1, swapObject2);
Système.dehors.println ("après échange -> \ nage1:" + swapObject1.X.âge +
"\ n" + "Age2:"
+ swapobject2.X.âge);
Sortir
Cette sortie impliquait que l'échange est effectué de manière appropriée via la classe wrapper et la fonction définie par l'utilisateur.
Conclusion
Les objets de Java peuvent être échangés à l'aide de la fonction définie par l'utilisateur combinée avec le «Opérateurs arithmétiques" ou la "Emballage"Classe et"Opérateur d'assignation". L'ancienne approche échange les objets et effectue simplement les calculs en fonction des valeurs d'objets mises à jour à chaque étape. Cette dernière approche applique l'échange en se référant aux objets de classe principale, en les emballant et en utilisant l'opérateur d'affectation dans la fonction définie par l'utilisateur. Cet article a guidé sur l'échange d'objets en java.