Pausa caffè #180. Variabili in Java: cosa sono e come si utilizzano. 5 cose che dovresti sapere sulla serializzazione e deserializzazione in Java

Variabili in Java: cosa sono e come vengono utilizzate

Fonte: Hackernoon Esistono quattro diversi tipi di variabili in Java, a seconda di dove vengono dichiarate nel programma. Oggi imparerai esempi e differenze di ogni tipo. 1. Le variabili di istanza o i campi di istanza sono variabili dichiarate all'interno di una classe senza la parola chiave statica , ma all'esterno di un metodo, costruttore o blocco di codice. Tali variabili possono essere dichiarate ovunque all'interno della classe. Puoi dichiararli con o senza un modificatore di accesso, come public , private , protected o default (non una parola chiave).

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 a un campo di istanza non viene assegnato un valore al momento della dichiarazione, gli viene assegnato un valore predefinito pari a zero se è un tipo primitivo, ad esempio ( int , boolean , long , float ) o null se non è un tipo primitivo, come ( String , Integer , AnyClass ). Sono chiamati campi o variabili di istanza perché appartengono all'istanza di qualsiasi oggetto creato dalla classe in cui sono dichiarati.

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

Pertanto, ogni campo di istanza è unico per il suo oggetto, come visto nello snippet sopra. In esso, obj1 e obj2 hanno valori univoci assegnati ai rispettivi campi di istanza. 2. I campi di classe o campi statici sono campi dichiarati con la parola chiave static . Vengono dichiarati all'interno della classe, ma all'esterno del metodo, del costruttore o del blocco di codice. Possono anche essere dichiarati in qualsiasi posizione all'interno di una classe, con o senza un modificatore di accesso, come public , private , protected o default (non una parola chiave).

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

È possibile accedere ai campi statici solo tramite le relative classi e non da qualsiasi oggetto, come mostrato nello snippet di codice sopra. 3. I parametri o le variabili argomento sono variabili dichiarate all'interno di un costrutto di metodo tra le parentesi graffe di apertura e chiusura della firma del metodo. Vengono utilizzati per passare valori o oggetti a un metodo.

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. Le variabili locali sono variabili dichiarate all'interno di un metodo o qualsiasi blocco di codice, ad esempio all'interno di un blocco di istruzioni if , ciclo for , ciclo while , blocco di istruzioni switch e così via.

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

In questo codice puoi notare l'uso del riferimento con alcune variabili, mentre la variabile locale id non è stata menzionata come variabile di riferimento. Qualsiasi variabile non primitiva è una variabile di riferimento. Ad esempio, obj1 è una variabile di tipo MyClass e tempName è una variabile di tipo String e in questo caso entrambi i tipi non sono tipi primitivi. In questo caso, id è una variabile di tipo int , che è un tipo di dati primitivo. Si tratta quindi di una variabile non di riferimento.

5 cose che dovresti sapere sulla serializzazione e deserializzazione in Java

Fonte: Devgenius Con questo tutorial migliorerai la tua conoscenza del funzionamento della serializzazione e della deserializzazione. La serializzazione in Java aiuta a convertire un oggetto esistente in un flusso di byte. Al contrario, la deserializzazione trasforma un flusso di byte in un oggetto. Utilizzando la serializzazione e la deserializzazione in Java, le informazioni sugli oggetti possono essere trasferite da una JVM all'altra.

N. 1 Serializzazione

Prima di entrare nei dettagli, diamo un'occhiata alle classi SerializeUtils.java e Person.java . Qui ci aiuteranno a eseguire la serializzazione e la deserializzazione utilizzando esempi specifici.

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

Come accennato, la serializzazione aiuta a convertire un oggetto in un flusso di byte. Ciò significa che anche tutte le informazioni sull'oggetto vengono convertite in un flusso di byte, come metodo, proprietà e dati. Ecco un esempio di come viene serializzato un oggetto:

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

Dopo il processo di serializzazione abbiamo un file con il seguente contenuto:

#2 Deserializzazione

Se nell'esempio precedente abbiamo creato uno stream di byte serializzando un oggetto, ora vediamo come tornare all'oggetto tramite la deserializzazione:

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

Ecco i dati dopo il processo di deserializzazione:

#3 UID della versione seriale

SerialVersionUID indica un numero di identificazione univoco per ciascuna versione del processo di serializzazione e deserializzazione. Questo numero viene utilizzato per garantire che sia gli oggetti serializzati che quelli deserializzati utilizzino classi compatibili. Per Person.java, vorrei aumentare serialVersionUID a 2. Diamo un'occhiata all'output dopo aver deserializzato il file person.txt.

#4 Parola chiave transitoria

Durante il processo di serializzazione e deserializzazione, a volte non è necessario serializzare tutte le informazioni su un oggetto. Utilizzando un processo transitorio per le variabili, possiamo ignorare tali variabili dall'oggetto da serializzare. L’esempio seguente aiuterà a capirlo più chiaramente:

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

Nel codice precedente, abbiamo utilizzato la parola chiave transitoria per la variabile age . E questo è ciò che abbiamo ottenuto dopo il processo di serializzazione e deserializzazione.

#5 Interfaccia esternalizzabile

In Java, quando vogliamo personalizzare il processo di serializzazione e deserializzazione, possiamo utilizzare un processo di transizione per ignorare le variabili di cui non abbiamo bisogno per il processo di serializzazione e deserializzazione. Un altro modo per semplificare e migliorare le prestazioni consiste nell'utilizzare l' interfaccia Externalizable invece dell'interfaccia Serializable . Diamo un'occhiata ad un esempio:

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

Come puoi vedere, quando utilizziamo Externalizable possiamo facilmente scrivere logica personalizzata, ignorare le variabili e ottenere prestazioni migliori rispetto all'utilizzo di Serializable . Ora diamo un'occhiata all'output:

Conclusione

Si spera che, attraverso questo articolo, tu abbia acquisito una chiara comprensione di come funzionano la serializzazione e la deserializzazione in Java e che gli esempi precedenti possano aiutarti nella pratica in futuro.