Cambiar objetos en Java
Este artículo demostrará las metodologías a "intercambiar objetos" usando Java.
Cómo "intercambiar objetos" en Java?
Los objetos en Java se pueden intercambiar utilizando la función definida por el usuario combinada con lo siguiente:
- "Operadores aritméticos".
- "EnvolturaClase "y la"Operador de asignación".
Enfoque 1: Cambiar objetos en Java utilizando los "operadores aritméticos"
En este enfoque, los objetos de clase se pueden cambiar realizando operaciones aritméticas en los objetos creados a través del "usuario definido" función:
SwapingBoBj de clasePublic int Age;
público intercambioBJ (int Age)
este.edad = edad;
Templ de clase pública
Swap vacío estático público (intercambio de valor1,
Intercambio de valor2)
valor1.edad = valor1.edad + valor2.edad;
valor2.edad = valor1.Edad - Valor2.edad;
valor1.edad = valor1.Edad - Valor2.edad;
Según lo anterior "clase"Código, aplique los siguientes pasos:
- En primer lugar, defina una clase llamada "Intercambio".
- En su definición, especifique la variable establecida.
- Además, cree un constructor de clase que tenga el parámetro establecido.
- En la definición del constructor, consulte la variable especificada y asigne al valor del parámetro a través de "este".
- Tenga en cuenta que este valor se pasará más adelante como argumento a través del "principal()" método.
- Ahora, defina una función llamada "intercambio()"Tener los parámetros proporcionados que se refieren a los objetos que deben intercambiarse.
- En su definición, consulte la variable de clase principal especificada, i.mi., "edad".
- Después de eso, almacene la adición de la aprobación "edad"Valores en el parámetro de la función anterior, i.mi., "valor1".
- Del mismo modo, devuelva la resta del aprobado "edad"Valores en primer lugar en los objetos referidos"valor2"Y luego en"valor1".
- Nota: La resta en los dos últimos casos no producirá el mismo resultado ya que el valor actualizado de los parámetros, I.mi., "valor1" y "valor2"Se invocará en el segundo y último cálculo, respectivamente.
Ahora, vamos a ver el siguiente proporcionado "principal()" método:
public static void main (string [] args)SwapingOBJ obj1 = nuevo intercambio de OBS (18);
SwapingOBJ obj2 = nuevo intercambio de OBJ (25);
Sistema.afuera.println ("antes de intercambiar->");
Sistema.afuera.println ("El primer objeto es:" + obj1.edad);
Sistema.afuera.println ("El segundo objeto es:" + obj2.edad);
intercambio (obj1, obj2);
Sistema.afuera.println ("después de intercambio->");
Sistema.afuera.println ("El primer objeto es:" + obj1.edad);
Sistema.afuera.println ("El segundo objeto es:" + obj2.edad);
En este fragmento de código:
- Crear dos objetos de clase llamados "obj1" y "obj2" mediante el "nuevo"Palabra clave y la"SwapingObj ()"Constructor, respectivamente.
- En el parámetro del constructor, pase los dos "edad"Valores que deben intercambiarse y mostrarlos.
- Ahora, invoca la función "intercambio()”Y pase los objetos de clase creados como sus argumentos.
- Esto cambiará el resultado de los valores de objeto pasados a través de los operadores aritméticos.
Código completo
SwapingBoBj de clasePublic int Age;
público intercambioBJ (int Age)
este.edad = edad;
Templ de clase pública
Swap vacío estático público (intercambio de valor1,
Intercambio de valor2)
valor1.edad = valor1.edad + valor2.edad;
valor2.edad = valor1.Edad - Valor2.edad;
valor1.edad = valor1.Edad - Valor2.edad;
public static void main (string [] args)
SwapingOBJ obj1 = nuevo intercambio de OBS (18);
SwapingOBJ obj2 = nuevo intercambio de OBJ (25);
Sistema.afuera.println ("antes de intercambiar->");
Sistema.afuera.println ("El primer objeto es:" + obj1.edad);
Sistema.afuera.println ("El segundo objeto es:" + obj2.edad);
intercambio (obj1, obj2);
Sistema.afuera.println ("después de intercambio->");
Sistema.afuera.println ("El primer objeto es:" + obj1.edad);
Sistema.afuera.println ("El segundo objeto es:" + obj2.edad);
Producción
En este resultado, se puede analizar que los valores del objeto se intercambian adecuadamente.
Enfoque 2: Cambiar objetos en Java usando la "clase de envoltorio" y el "Operador de asignación"
En este enfoque particular, el objeto de clase creado se puede cambiar con la ayuda de una clase de envoltorio externo haciendo una referencia a la clase principal y al operador de asignación "=":
objeto de clasePublic int Age;
Object (int Age)
este.edad = edad;
envoltura de clase
objeto x;
WRAPPER (Object Inner)
este.x = interno;
clase pública temp2
Swap void estático (Wrapper Object1, Wrapper Object2)
objeto temp;
temp = Object1.X;
objeto1.x = Object2.X;
objeto2.x = temp;
En las líneas anteriores del código de clase, aplique los siguientes pasos:
- Recuerde los enfoques discutidos para definir una clase y consulte la variable especificada con la ayuda del constructor de clases.
- Después de eso, declare una clase de envoltura llamada "Envoltura".
- En su definición, consulte la clase principal llamada "objeto"Y especifique la variable"X" basado en eso.
- Además, incluya un constructor de clase y asigne el valor del objeto aprobado a la variable especificada a través de "este".
- Ahora, de manera similar, defina una función de intercambio llamada "intercambio()"Donde los parámetros de la función apuntan a los valores de objeto que deben intercambiarse.
- En la definición de función, del mismo modo, pase una referencia de la clase principal a la variable "temperatura"Y asignarlo el valor anterior del objeto envuelto en la clase de envoltorio.
- En el siguiente paso, asigne el valor del último objeto al objeto anterior.
- Por último, asigne el valor actualizado de "temperatura"Para el último objeto envuelto, yo.mi., "objeto2".
Ahora, procedamos al "principal()" método:
public static void main (string [] args)objeto ob1 = nuevo objeto (25);
objeto ob2 = nuevo objeto (30);
WRAPPER SWAPObject1 = nuevo contenedor (OB1);
WRAPPER SWAPObject2 = nuevo contenedor (OB2);
Sistema.afuera.println ("Antes de intercambiar -> \ nage1:" + swapobject1.X.edad +
"\ n" + "edad2:"
+ swapobject2.X.edad + "\ n");
intercambio (swapObject1, swapobject2);
Sistema.afuera.println ("Después de intercambiar -> \ nage1:" + swapobject1.X.edad +
"\ n" + "edad2:"
+ swapobject2.X.edad);
Según lo anterior "principal()"Método, aplique los siguientes pasos:
- Repita los enfoques explicados para crear objetos de clase y pasar el indicado "edad"Valores como parámetros del constructor.
- En el siguiente paso, cree dos objetos de clase de envoltorio y envuelva los objetos de clase principal como parámetros de constructor.
- Además, muestre el resultado antes de intercambiar los objetos.
- Ahora, acceda al "intercambio()"Funcionar y pasar los objetos de clase envueltos como argumentos.
- Esto dará como resultado intercambiar el "principal"Objetos de clase.
Código completo
objeto de clasePublic int Age;
Object (int Age)
este.edad = edad;
envoltura de clase
objeto x;
WRAPPER (Object Inner)
este.x = interno;
clase pública temp2
Swap void estático (Wrapper Object1, Wrapper Object2)
objeto temp;
temp = Object1.X;
objeto1.x = Object2.X;
objeto2.x = temp;
public static void main (string [] args)
objeto ob1 = nuevo objeto (25);
objeto ob2 = nuevo objeto (30);
WRAPPER SWAPObject1 = nuevo contenedor (OB1);
WRAPPER SWAPObject2 = nuevo contenedor (OB2);
Sistema.afuera.println ("Antes de intercambiar -> \ nage1:" + swapobject1.X.edad +
"\ n" + "edad2:"
+ swapobject2.X.edad + "\ n");
intercambio (swapObject1, swapobject2);
Sistema.afuera.println ("Después de intercambiar -> \ nage1:" + swapobject1.X.edad +
"\ n" + "edad2:"
+ swapobject2.X.edad);
Producción
Esta salida implicó que el intercambio se realiza adecuadamente a través de la clase de envoltura y la función definida por el usuario.
Conclusión
Los objetos en Java se pueden intercambiar utilizando la función definida por el usuario combinada con el "Operadores aritméticos" o el "EnvolturaClase "y la"Operador de asignación". El enfoque anterior intercambia los objetos y simplemente realiza los cálculos basados en los valores de objeto actualizados en cada paso. El último enfoque aplica el intercambio refiriéndose a los objetos de clase principal, envolviéndolos y utilizando el operador de asignación en la función definida por el usuario. Este artículo guió sobre los objetos de intercambio en Java.