Pausa para café #180. Variáveis em Java: o que são e como são utilizadas. 5 coisas que você deve saber sobre serialização e desserialização em Java

Variáveis ​​em Java: o que são e como são usadas

Fonte: Hackernoon Existem quatro tipos diferentes de variáveis ​​em Java, dependendo de onde elas são declaradas no programa. Hoje você aprenderá exemplos e diferenças de cada tipo. 1. Variáveis ​​de instância ou campos de instância são variáveis ​​declaradas dentro de uma classe sem a palavra-chave estática , mas fora de um método, construtor ou bloco de código. Tais variáveis ​​podem ser declaradas em qualquer lugar da classe. Você pode declará-los com ou sem um modificador de acesso, como public , private , protected ou default (não uma palavra-chave).

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
  }
}

Se um campo de instância não receber um valor no momento da declaração, será atribuído a ele um valor padrão zero se for um tipo primitivo, como ( int , boolean , long , float ) ou null se não for um tipo primitivo, como ( String , Integer , AnyClass ). Eles são chamados de campos ou variáveis ​​de instância porque pertencem à instância de qualquer objeto criado a partir da classe na qual são 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'
  }
}

Assim, cada campo de instância é exclusivo para seu objeto, conforme visto no trecho acima. Nele, obj1 e obj2 possuem valores exclusivos atribuídos aos seus respectivos campos de instância. 2. Campos de classe ou campos estáticos são campos declarados com a palavra-chave estática . Eles são declarados dentro da classe, mas fora do método, construtor ou bloco de código. Eles também podem ser declarados em qualquer posição dentro de uma classe, com ou sem um modificador de acesso, como public , private , protected ou default (não uma palavra-chave).

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'
  }
}

Os campos estáticos só podem ser acessados ​​através de suas classes e não de qualquer objeto como mostrado no trecho de código acima. 3. Parâmetros ou variáveis ​​de argumento são variáveis ​​declaradas dentro de uma construção de método entre as chaves de abertura e fechamento da assinatura do método. Eles são usados ​​para passar valores ou objetos para um 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. Variáveis ​​locais são variáveis ​​declaradas dentro de um método ou qualquer bloco de código, por exemplo, dentro de um bloco de instruções if , loop for , loop while , bloco de instruções switch e assim por diante.

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
     }
  }
}

Neste código você pode notar o uso de referência com algumas variáveis, enquanto a variável local id não foi mencionada como variável de referência. Qualquer variável não primitiva é uma variável de referência. Por exemplo, obj1 é uma variável do tipo MyClass e tempName é uma variável do tipo String , e aqui ambos os tipos não são tipos primitivos. Neste caso, id é uma variável do tipo int , que é um tipo de dados primitivo. Portanto, é uma variável sem referência.

5 coisas que você deve saber sobre serialização e desserialização em Java

Fonte: Devgenius Com este tutorial, você aprimorará seu conhecimento sobre como funcionam a serialização e a desserialização. A serialização em Java ajuda a converter um objeto existente em um fluxo de bytes. Por outro lado, a desserialização transforma um fluxo de bytes em um objeto. Usando serialização e desserialização em Java, informações sobre objetos podem ser transferidas de uma JVM para outra.

#1 Serialização

Antes de entrar em detalhes, vamos dar uma olhada nas classes SerializeUtils.java e Person.java . Aqui eles nos ajudarão a realizar serialização e desserialização usando exemplos 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();
    }
}

Pessoa.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;
    }
}

Conforme mencionado, a serialização ajuda a converter um objeto em um fluxo de bytes. Isso significa que todas as informações sobre o objeto também são convertidas em um fluxo de bytes, como método, propriedades e dados. Aqui está um exemplo de como um objeto é serializado:

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");
    }
}

Após o processo de serialização temos um arquivo com o seguinte conteúdo:

#2 Desserialização

Se no exemplo anterior criamos um fluxo de bytes serializando um objeto, agora vamos ver como voltamos ao objeto usando a desserialização:

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());
    }
}

Aqui estão os dados após o processo de desserialização:

#3 UID da versão serial

SerialVersionUID significa um número de identificação exclusivo para cada versão do processo de serialização e desserialização. Esse número é usado para garantir que objetos serializados e desserializados usem classes compatíveis. Para Person.java, gostaria de aumentar o serialVersionUID para 2. Vejamos a saída após desserializar o arquivo person.txt.

#4 Palavra-chave transitória

Durante o processo de serialização e desserialização, às vezes não precisamos serializar todas as informações sobre um objeto. Ao usar um processo transitório para variáveis, podemos ignorar essas variáveis ​​do objeto que está sendo serializado. O exemplo abaixo ajudará a entender isso mais 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());
    }
}

No código acima, usamos a palavra-chave transitória para a variável idade . E foi isso que obtivemos após o processo de serialização e desserialização.

#5 Interface externalizável

Em Java, quando queremos personalizar o processo de serialização e desserialização, podemos usar um processo de transição para ignorar as variáveis ​​que não precisamos para o processo de serialização e desserialização. Outra maneira de simplificar e melhorar o desempenho é usar a interface Externalizable em vez da interface Serializable . Vejamos um exemplo:

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 você pode ver, ao usar Externalizable podemos facilmente escrever lógica customizada, ignorar variáveis ​​e obter melhor desempenho do que usar Serializable . Agora vamos dar uma olhada na saída:

Conclusão

Esperamos que, por meio deste artigo, você tenha obtido uma compreensão clara de como a serialização e a desserialização funcionam em Java, e os exemplos acima podem ajudá-lo na prática no futuro.