Kaffeepause Nr. 180. Variablen in Java: Was sie sind und wie sie verwendet werden. 5 Dinge, die Sie über Serialisierung und Deserialisierung in Java wissen sollten

Variablen in Java: Was sind sie und wie werden sie verwendet?

Quelle: Hackernoon In Java gibt es vier verschiedene Arten von Variablen, je nachdem, wo sie im Programm deklariert werden. Heute lernen Sie Beispiele und Unterschiede der einzelnen Typen kennen. 1. Instanzvariablen oder Instanzfelder sind Variablen, die innerhalb einer Klasse ohne das Schlüsselwort static , aber außerhalb einer Methode, eines Konstruktors oder eines Codeblocks deklariert werden. Solche Variablen können an einer beliebigen Stelle innerhalb der Klasse deklariert werden. Sie können sie mit oder ohne Zugriffsmodifikator deklarieren, z. B. public , private , protected oder default (kein Schlüsselwort).

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

Wenn einem Instanzfeld zum Zeitpunkt der Deklaration kein Wert zugewiesen wird, wird ihm der Standardwert Null zugewiesen, wenn es sich um einen primitiven Typ handelt, z. B. ( int , boolean , long , float ), oder null , wenn es sich nicht um einen primitiven Typ handelt. wie ( String , Integer , AnyClass ). Sie werden Felder oder Instanzvariablen genannt, weil sie zur Instanz eines beliebigen Objekts gehören, das aus der Klasse erstellt wird, in der sie deklariert sind.

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

Somit ist jedes Instanzfeld für sein Objekt einzigartig, wie im obigen Snippet zu sehen ist. Darin sind obj1 und obj2 ihren jeweiligen Instanzfeldern eindeutige Werte zugewiesen. 2. Klassenfelder oder statische Felder sind Felder, die mit dem Schlüsselwort static deklariert werden . Sie werden innerhalb der Klasse deklariert, jedoch außerhalb der Methode, des Konstruktors oder des Codeblocks. Sie können auch an jeder Position innerhalb einer Klasse mit oder ohne Zugriffsmodifikator deklariert werden, z. B. public , private , protected oder default (kein Schlüsselwort).

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

Auf statische Felder kann nur über ihre Klassen und nicht von einem Objekt aus zugegriffen werden, wie im Codeausschnitt oben gezeigt. 3. Parameter oder Argumentvariablen sind Variablen, die innerhalb eines Methodenkonstrukts zwischen den öffnenden und schließenden geschweiften Klammern der Methodensignatur deklariert werden. Sie werden verwendet, um Werte oder Objekte an eine Methode zu übergeben.

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. Lokale Variablen sind Variablen, die innerhalb einer Methode oder eines beliebigen Codeblocks deklariert werden, beispielsweise innerhalb eines Blocks mit if- Anweisungen , einer for-Schleife , einer while-Schleife , einem Block mit switch- Anweisungen usw.

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 diesem Code können Sie die Verwendung von Referenzen bei einigen Variablen erkennen, während die lokale Variablen- ID nicht als Referenzvariable erwähnt wurde. Jede nicht-primitive Variable ist eine Referenzvariable. Beispielsweise ist obj1 eine Variable vom Typ MyClass und tempName eine Variable vom Typ String , und hier sind beide Typen keine primitiven Typen. In diesem Fall ist id eine Variable vom Typ int , einem primitiven Datentyp. Daher handelt es sich um eine Nicht-Referenzvariable.

5 Dinge, die Sie über Serialisierung und Deserialisierung in Java wissen sollten

Quelle: Devgenius Mit diesem Tutorial verbessern Sie Ihr Wissen über die Funktionsweise von Serialisierung und Deserialisierung. Die Serialisierung in Java hilft dabei, ein vorhandenes Objekt in einen Bytestream umzuwandeln. Umgekehrt macht die Deserialisierung einen Bytestrom zu einem Objekt. Mithilfe der Serialisierung und Deserialisierung in Java können Informationen über Objekte von einer JVM auf eine andere übertragen werden.

#1 Serialisierung

Bevor wir ins Detail gehen, werfen wir einen Blick auf die Klassen SerializeUtils.java und Person.java . Hier helfen sie uns anhand konkreter Beispiele bei der Serialisierung und Deserialisierung.

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

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

Wie bereits erwähnt, hilft die Serialisierung dabei, ein Objekt in einen Bytestrom umzuwandeln. Das bedeutet, dass alle Informationen über das Objekt ebenfalls in einen Bytestrom umgewandelt werden, wie z. B. Methode, Eigenschaften und Daten. Hier ist ein Beispiel für die Serialisierung eines Objekts:

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

Nach dem Serialisierungsprozess haben wir eine Datei mit folgendem Inhalt:

#2 Deserialisierung

Wenn wir im vorherigen Beispiel einen Bytestrom durch Serialisierung eines Objekts erstellt haben, sehen wir uns nun an, wie wir mithilfe der Deserialisierung zum Objekt zurückkehren:

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

Hier sind die Daten nach dem Deserialisierungsprozess:

#3 UID der Serienversion

SerialVersionUID bezeichnet eine eindeutige Identifikationsnummer für jede Version des Serialisierungs- und Deserialisierungsprozesses. Diese Nummer wird verwendet, um sicherzustellen, dass sowohl serialisierte als auch deserialisierte Objekte kompatible Klassen verwenden. Für Person.java möchte ich die serialVersionUID auf 2 erhöhen. Schauen wir uns die Ausgabe nach der Deserialisierung der Datei person.txt an.

#4 Schlüsselwort vorübergehend

Während des Serialisierungs- und Deserialisierungsprozesses müssen wir manchmal nicht alle Informationen über ein Objekt serialisieren. Indem wir einen transienten Prozess für Variablen verwenden, können wir diese Variablen aus dem zu serialisierenden Objekt ignorieren. Das folgende Beispiel hilft, dies besser zu verstehen:

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

Im obigen Code haben wir das Schlüsselwort transient für die Altersvariable verwendet . Und das haben wir nach dem Serialisierungs- und Deserialisierungsprozess erhalten.

#5 Externalisierbare Schnittstelle

Wenn wir in Java den Serialisierungs- und Deserialisierungsprozess anpassen möchten, können wir einen Übergangsprozess verwenden, um die Variablen zu ignorieren, die wir für den Serialisierungs- und Deserialisierungsprozess nicht benötigen. Eine weitere Möglichkeit zur Vereinfachung und Verbesserung der Leistung besteht darin, die Externalizable- Schnittstelle anstelle der Serializable- Schnittstelle zu verwenden . Schauen wir uns ein Beispiel an:

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

Wie Sie sehen, können wir mit Externalizable problemlos benutzerdefinierte Logik schreiben, Variablen ignorieren und eine bessere Leistung erzielen als mit Serializable . Schauen wir uns nun die Ausgabe an:

Abschluss

Hoffentlich haben Sie durch diesen Artikel ein klares Verständnis dafür gewonnen, wie Serialisierung und Deserialisierung in Java funktionieren, und die obigen Beispiele können Ihnen in Zukunft in der Praxis helfen.