Przerwa kawowa #180. Zmienne w Javie: czym są i jak się ich używa. 5 rzeczy, które powinieneś wiedzieć o serializacji i deserializacji w Javie

Zmienne w Javie: czym są i jak się ich używa

Źródło: Hackernoon W Javie istnieją cztery różne typy zmiennych, w zależności od tego, gdzie są zadeklarowane w programie. Dziś poznasz przykłady i różnice każdego typu. 1. Zmienne instancji lub pola instancji to zmienne zadeklarowane wewnątrz klasy bez słowa kluczowego static , ale poza metodą, konstruktorem lub blokiem kodu. Takie zmienne można zadeklarować w dowolnym miejscu klasy. Możesz je zadeklarować z modyfikatorem dostępu lub bez niego, takim jak public , private , chroniony lub domyślny (nie słowo kluczowe).

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

Jeśli pole instancji nie ma przypisanej wartości w momencie deklaracji, przypisuje się mu domyślną wartość zero, jeśli jest to typ pierwotny, taki jak ( int , boolean , long , float ) lub null , jeśli nie jest typem pierwotnym, takie jak ( String , Integer , AnyClass ). Nazywa się je polami lub zmiennymi instancji, ponieważ należą do instancji dowolnego obiektu utworzonego z klasy, w której są zadeklarowane.

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

Zatem każde pole instancji jest unikalne dla swojego obiektu, jak widać w powyższym fragmencie. W nim obj1 i obj2 mają unikalne wartości przypisane do odpowiednich pól instancji. 2. Pola klasowe lub pola statyczne to pola zadeklarowane za pomocą słowa kluczowego static . Są deklarowane wewnątrz klasy, ale poza metodą, konstruktorem lub blokiem kodu. Można je również zadeklarować na dowolnej pozycji w klasie, z modyfikatorem dostępu lub bez niego, takim jak public , private , protected lub default (nie słowo kluczowe).

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

Dostęp do pól statycznych można uzyskać wyłącznie poprzez ich klasy, a nie z żadnego obiektu, jak pokazano w powyższym fragmencie kodu. 3. Parametry lub zmienne argumentów to zmienne zadeklarowane wewnątrz konstrukcji metody pomiędzy otwierającymi i zamykającymi nawiasami klamrowymi sygnatury metody. Służą do przekazywania wartości lub obiektów do metody.

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. Zmienne lokalne to zmienne zadeklarowane wewnątrz metody lub dowolnego bloku kodu, na przykład wewnątrz bloku instrukcji if , pętli for , pętli while , bloku instrukcji switch i tak dalej.

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

W tym kodzie można zauważyć użycie referencji w przypadku niektórych zmiennych, podczas gdy zmienna lokalna id nie została wymieniona jako zmienna referencyjna. Każda zmienna nieprymitywna jest zmienną referencyjną. Na przykład obj1 jest zmienną typu MyClass , a tempName jest zmienną typu String i w tym przypadku oba typy nie są typami pierwotnymi. W tym przypadku id jest zmienną typu int , który jest pierwotnym typem danych. Dlatego nie jest to zmienna referencyjna.

5 rzeczy, które powinieneś wiedzieć o serializacji i deserializacji w Javie

Źródło: Devgenius Dzięki temu samouczkowi poszerzysz swoją wiedzę na temat działania serializacji i deserializacji. Serializacja w Javie pomaga przekonwertować istniejący obiekt na strumień bajtów. I odwrotnie, deserializacja sprawia, że ​​strumień bajtów staje się obiektem. Korzystając z serializacji i deserializacji w Javie, informacje o obiektach można przesyłać z jednej maszyny JVM do drugiej.

#1 Serializacja

Zanim przejdziemy do szczegółów, przyjrzyjmy się klasom SerializeUtils.java i Person.java . Tutaj pomogą nam przeprowadzić serializację i deserializację na konkretnych przykładach.

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

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

Jak wspomniano, serializacja pomaga przekonwertować obiekt na strumień bajtów. Oznacza to, że wszystkie informacje o obiekcie, takie jak metoda, właściwości i dane, są również konwertowane na strumień bajtów. Oto przykład serializacji obiektu:

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

Po procesie serializacji mamy plik o następującej zawartości:

#2 Deserializacja

Jeśli w poprzednim przykładzie utworzyliśmy strumień bajtów poprzez serializację obiektu, zobaczmy teraz, jak wrócić do obiektu za pomocą deserializacji:

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

Oto dane po procesie deserializacji:

#3 UID wersji seryjnej

SerialVersionUID oznacza unikalny numer identyfikacyjny dla każdej wersji procesu serializacji i deserializacji. Liczba ta służy do zapewnienia, że ​​zarówno obiekty serializowane, jak i deserializowane korzystają ze zgodnych klas. W przypadku pliku Person.java chciałbym zwiększyć wartość serialVersionUID do 2. Przyjrzyjmy się wynikom deserializacji pliku person.txt.

#4 Słowo kluczowe przejściowe

Czasami w procesie serializacji i deserializacji nie musimy serializować wszystkich informacji o obiekcie. Używając procesu przejściowego dla zmiennych, możemy zignorować te zmienne z serializowanego obiektu. Poniższy przykład pomoże lepiej to zrozumieć:

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

W powyższym kodzie użyliśmy słowa kluczowego transient dla zmiennej age . A oto co otrzymaliśmy po procesie serializacji i deserializacji.

#5 Interfejs możliwy do uzewnętrznienia

Jeśli w Javie chcemy dostosować proces serializacji i deserializacji, możemy zastosować proces przejścia, aby zignorować zmienne, których nie potrzebujemy w procesie serializacji i deserializacji. Innym sposobem uproszczenia i poprawy wydajności jest użycie interfejsu zewnętrznego zamiast interfejsu serializowalnego . Spójrzmy na przykład:

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

Jak widać, korzystając z metodyExternalizable , możemy łatwo napisać niestandardową logikę, ignorować zmienne i uzyskać lepszą wydajność niż przy użyciu Serializable . Teraz spójrzmy na wynik:

Wniosek

Mamy nadzieję, że dzięki temu artykułowi zrozumiałeś, jak serializacja i deserializacja działają w Javie, a powyższe przykłady mogą ci pomóc w praktyce w przyszłości.