Pausa para el café #180. Variables en Java: qué son y cómo se utilizan. 5 cosas que debes saber sobre la serialización y deserialización en Java

Variables en Java: Qué son y cómo se utilizan

Fuente: Hackernoon Hay cuatro tipos diferentes de variables en Java, dependiendo de dónde se declaren en el programa. Hoy aprenderás ejemplos y diferencias de cada tipo. 1. Las variables de instancia o campos de instancia son variables declaradas dentro de una clase sin la palabra clave estática , pero fuera de un método, constructor o bloque de código. Estas variables se pueden declarar en cualquier lugar dentro de la clase. Puedes declararlos con o sin un modificador de acceso, como public , private , protected o default (no una palabra clave).

public class MyClass {

  //instance field 1
  private String instanceField1;

  public MyClass(){} //Constructor

  //instance field 2
  public int anotherInstanceField2;

  public void setInstanceField(String parameterVariable) {...} //instance method

  //instance field 3
  boolean instanceField3;

  public static void main(String[] args) {
    System.out.println("field 1 value: " + instanceField1); // = null
    System.out.println("field 2 value: " + anotherInstanceField2); // = 0
    System.out.println("field 3 value: " + instanceField3); // = 0
  }
}

Si a un campo de instancia no se le asigna un valor en el momento de la declaración, se le asigna un valor predeterminado de cero si es un tipo primitivo, como ( int , boolean , long , float ), o null si no es un tipo primitivo. como ( Cadena , Entero , Cualquier Clase ). Se denominan campos o variables de instancia porque pertenecen a la instancia de cualquier objeto creado a partir de la clase en la que están declarados.

public Main {

  public static void main(String[] args) {
    MyClass obj1 = new MyClass();
    MyClass obj2 = new MyClass();

    //Now we can access every 'public' field declared in the MyClass class
    // from the newly created object 'obj'

    obj1.anotherInstanceField2 = 11;
    obj2.anotherInstanceField2 = 33;

    System.out.println(obj1.anotherInstanceField2); // prints '11'
    System.out.println(obj2.anotherInstanceField2); // prints '33'
  }
}

Por lo tanto, cada campo de instancia es exclusivo de su objeto, como se ve en el fragmento anterior. En él, obj1 y obj2 tienen valores únicos asignados a sus respectivos campos de instancia. 2. Los campos de clase o campos estáticos son campos declarados con la palabra clave estática . Se declaran dentro de la clase, pero fuera del método, constructor o bloque de código. También se pueden declarar en cualquier posición dentro de una clase, con o sin un modificador de acceso, como public , private , protected o default (no es una palabra clave).

public class MyClass {

  //static field
  public static String staticField;

  public MyClass(){} //Constructor

}

class Main {

  public static void main(String[] args) {

    MyClass obj = new MyClass();

    obj.staticField //will throw Not defined Error

    //Now we cannot access the static field declared in MyClass class from the
     // newly created object 'obj' because static fields are not attached to any
    // object. They belong solely to the class they are declared and can only be
    // accessed from their class.

    MyClass.staticField = "I am a static field";
    System.out.println(MyClass.staticField); // prints 'I am a static field'
  }
}

Solo se puede acceder a los campos estáticos a través de sus clases y no desde ningún objeto, como se muestra en el fragmento de código anterior. 3. Los parámetros o variables de argumento son variables declaradas dentro de una construcción de método entre las llaves de apertura y cierre de la firma del método. Se utilizan para pasar valores u objetos a un método.

public class MyClass {

  //instance field
  public String instanceField;

  public MyClass(){} //Constructor

  //instance method with a parameter variable
   public void setInstanceField(String parameterVariable) {
      instanceField = parameterVariable;
   }
}

class Main {

  public static void main(String[] args) {
    
    MyClass obj = new MyClass();

    obj.setInstanceField("From a parameter variable");

    System.out.println(obj.instanceField); // prints 'From a parameter variable'
  }
}

4. Las variables locales son variables declaradas dentro de un método o cualquier bloque de código, por ejemplo, dentro de un bloque de sentencias if , bucle for , bucle while , bloque de sentencias switch , etc.

public Main {

  public static void main(String[] args) {
    MyClass obj1 = new MyClass(); // 'obj1' is local reference variable

    int id = 1; // 'name' is a local variable here.

    if (id > 1) {
        String tempName = "Austin"; // 'tempName' is a local reference variable
     }
  }
}

En este código se puede notar el uso de referencia con algunas variables, mientras que la identificación de la variable local no se mencionó como variable de referencia. Cualquier variable no primitiva es una variable de referencia. Por ejemplo, obj1 es una variable de tipo MyClass y tempName es una variable de tipo String , y aquí ambos tipos no son tipos primitivos. En este caso, id es una variable de tipo int , que es un tipo de datos primitivo. Por tanto, es una variable de no referencia.

5 cosas que debes saber sobre la serialización y deserialización en Java

Fuente: Devgenius Con este tutorial, mejorará su conocimiento sobre cómo funcionan la serialización y la deserialización. La serialización en Java ayuda a convertir un objeto existente en un flujo de bytes. Por el contrario, la deserialización convierte un flujo de bytes en un objeto. Al utilizar la serialización y deserialización en Java, la información sobre objetos se puede transferir de una JVM a otra.

#1 Serialización

Antes de entrar en detalles, echemos un vistazo a las clases SerializeUtils.java y Person.java . Aquí nos ayudarán a realizar la serialización y deserialización utilizando ejemplos específicos.

SerializeUtils.java

package com.techteam.serialization;

import java.io.*;

public class SerializeUtils {
    public static <T> void serialize(T input, String fileName) throws IOException {
        FileOutputStream file = new FileOutputStream(fileName);
        ObjectOutputStream out = new ObjectOutputStream(file);
        out.writeObject(input);
        out.close();
        file.close();
    }

    public static <T> T deserialize(String fileName) throws IOException, ClassNotFoundException {
        FileInputStream file = new FileInputStream(fileName);
        ObjectInputStream in = new ObjectInputStream(file);
        T result = (T) in.readObject();

        return result;
    }

    public static void externalSeialize(Externalizable e, String fileName) throws IOException {
        FileOutputStream file = new FileOutputStream(fileName);
        ObjectOutputStream out = new ObjectOutputStream(file);
        e.writeExternal(out);
        out.close();
        file.close();
    }

    public static void externalDeseialize(Externalizable e, String fileName) throws IOException, ClassNotFoundException {
        FileInputStream file = new FileInputStream (fileName);
        ObjectInputStream in = new ObjectInputStream (file);
        e.readExternal(in);
        in.close();
        file.close();
    }
}

persona.java

package com.techteam.serialization;

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Como se mencionó, la serialización ayuda a convertir un objeto en un flujo de bytes. Esto significa que toda la información sobre el objeto también se convierte en un flujo de bytes, como métodos, propiedades y datos. A continuación se muestra un ejemplo de cómo se serializa un objeto:

package com.techteam.serialization;

import java.io.IOException;

public class SerializationMain {

    public static void main(String[] args) throws IOException {
        Person p = new Person();
        p.setId(1);
        p.setName("Tech team members");
        p.setAge(20);

        SerializeUtils.serialize(p, "/person.txt");
    }
}

Luego del proceso de serialización tenemos un archivo con el siguiente contenido:

#2 Deserialización

Si en el ejemplo anterior creamos un flujo de bytes serializando un objeto, ahora veamos cómo volvemos al objeto usando la deserialización:

package com.techteam.serialization;

import java.io.IOException;

public class DeserializationMain {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p = SerializeUtils.deserialize("/person.txt");

        System.out.println("Person data:");
        System.out.println(p.getId());
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}

Aquí están los datos después del proceso de deserialización:

#3 UID de la versión en serie

SerialVersionUID significa un número de identificación único para cada versión del proceso de serialización y deserialización. Este número se utiliza para garantizar que tanto los objetos serializados como los deserializados utilicen clases compatibles. Para Person.java, me gustaría aumentar serialVersionUID a 2. Veamos el resultado después de deserializar el archivo person.txt.

#4 Palabra clave transitoria

Durante el proceso de serialización y deserialización, a veces no necesitamos serializar toda la información sobre un objeto. Al utilizar un proceso transitorio para las variables, podemos ignorar esas variables del objeto que se está serializando. El siguiente ejemplo le ayudará a entender esto más claramente:

package com.techteam.serialization;

import java.io.IOException;
import java.io.Serializable;

public class PersonWithTransient implements Serializable {

    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private transient int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        PersonWithTransient p = new PersonWithTransient();
        p.setId(2);
        p.setName("Tech team members(transient)");
        p.setAge(50);

        SerializeUtils.serialize(p, "/person_transient.txt");

        PersonWithTransient deserializeP = SerializeUtils.deserialize("/person_transient.txt");
        System.out.println("Person without transient data:");
        System.out.println(deserializeP.getId());
        System.out.println(deserializeP.getName());
        System.out.println(deserializeP.getAge());
    }
}

En el código anterior, hemos utilizado la palabra clave transitoria para la variable edad . Y esto es lo que obtuvimos después del proceso de serialización y deserialización.

#5 Interfaz externalizable

En Java, cuando queremos personalizar el proceso de serialización y deserialización, podemos usar un proceso de transición para ignorar las variables que no necesitamos para el proceso de serialización y deserialización. Otra forma de simplificar y mejorar el rendimiento es utilizar la interfaz externalizable en lugar de la interfaz serializable . Veamos un ejemplo:

package com.techteam.serialization;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class PersonExternalizable implements Externalizable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(this.name);
        out.writeInt(this.age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = in.readUTF();
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        PersonExternalizable p = new PersonExternalizable();
        p.setId(3);
        p.setName("Tech team members(Externalizable)");
        p.setAge(30);

        SerializeUtils.externalSeialize(p, "/person_externalizable.txt");

        PersonExternalizable deserializeP = new PersonExternalizable();
        SerializeUtils.externalDeseialize(deserializeP, "/person_externalizable.txt");
        System.out.println("Person data:");
        System.out.println(deserializeP.getId());
        System.out.println(deserializeP.getName());
        System.out.println(deserializeP.getAge());
    }
}

Como puede ver, cuando usamos Externalizable podemos escribir fácilmente lógica personalizada, ignorar variables y obtener un mejor rendimiento que usando Serializable . Ahora veamos el resultado:

Conclusión

Con suerte, a través de este artículo, habrá obtenido una comprensión clara de cómo funcionan la serialización y la deserialización en Java, y los ejemplos anteriores pueden ayudarlo en la práctica en el futuro.