Coffee break #180. Mga variable sa Java: kung ano ang mga ito at kung paano ginagamit ang mga ito. 5 Bagay na Dapat Mong Malaman Tungkol sa Serialization at Deserialization sa Java

Mga variable sa Java: Ano ang mga ito at paano ginagamit ang mga ito

Source: Hackernoon Mayroong apat na iba't ibang uri ng mga variable sa Java, depende sa kung saan idineklara ang mga ito sa programa. Ngayon ay matututunan mo ang mga halimbawa at pagkakaiba ng bawat uri. 1. Ang mga variable ng Instance o mga field ng Instance ay mga variable na idineklara sa loob ng isang klase na walang static na keyword , ngunit sa labas ng isang method, constructor, o block ng code. Ang ganitong mga variable ay maaaring ideklara kahit saan sa loob ng klase. Maaari mong ideklara ang mga ito nang mayroon o walang access modifier, gaya ng pampubliko , pribado , protektado o default (hindi isang keyword).

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

Kung ang isang field ng instance ay hindi nakatalaga ng isang halaga sa oras ng deklarasyon, ito ay nakatalaga ng isang default na halaga ng zero kung ito ay isang primitive na uri, tulad ng ( int , boolean , long , float ), o null kung ito ay hindi isang primitive na uri, tulad ng ( String , Integer , AnyClass ). Ang mga ito ay tinatawag na mga field o instance variable dahil nabibilang ang mga ito sa instance ng anumang bagay na nilikha mula sa klase kung saan sila idineklara.

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

Kaya, ang bawat field ng instance ay natatangi sa object nito, tulad ng nakikita sa snippet sa itaas. Sa loob nito, ang obj1 at obj2 ay may mga natatanging value na nakatalaga sa kani-kanilang mga field ng instance. 2. Ang mga patlang ng klase o mga static na patlang ay mga patlang na idineklara gamit ang static na keyword . Ang mga ito ay ipinahayag sa loob ng klase, ngunit sa labas ng pamamaraan, tagabuo, o bloke ng code. Maaari din silang ideklara sa anumang posisyon sa loob ng isang klase, mayroon o walang access modifier, gaya ng pampubliko , pribado , protektado , o default (hindi isang keyword).

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

Maa-access lang ang mga static na field sa pamamagitan ng kanilang mga klase at hindi mula sa anumang bagay tulad ng ipinapakita sa snippet ng code sa itaas. 3. Ang mga parameter o Argument variable ay mga variable na ipinahayag sa loob ng isang paraan na binuo sa pagitan ng pagbubukas at pagsasara ng mga kulot na brace ng lagda ng pamamaraan. Ginagamit ang mga ito upang ipasa ang mga halaga o bagay sa isang pamamaraan.

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. Ang mga lokal na variable ay mga variable na idineklara sa loob ng isang paraan o anumang bloke ng code, halimbawa, sa loob ng isang bloke ng if statements , para sa loop , while loop , block ng switch statement , at iba pa.

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

Sa code na ito maaari mong mapansin ang paggamit ng reference sa ilang mga variable, habang ang lokal na variable id ay hindi binanggit bilang isang reference variable. Anumang di-primitive na variable ay isang reference variable. Halimbawa, ang obj1 ay isang variable ng uri ng MyClass at ang tempName ay isang variable ng uri ng String , at dito ang parehong mga uri ay hindi primitive na mga uri. Sa kasong ito, ang id ay isang variable ng uri int , na isang primitive na uri ng data. Samakatuwid, ito ay isang di-reference na variable.

5 Bagay na Dapat Mong Malaman Tungkol sa Serialization at Deserialization sa Java

Source: Devgenius Sa tutorial na ito, mapapabuti mo ang iyong kaalaman sa kung paano gumagana ang serialization at deserialization. Ang serialization sa Java ay tumutulong sa pag-convert ng isang umiiral na bagay sa isang byte stream. Sa kabaligtaran, ginagawang object ng deserialization ang isang byte stream. Gamit ang serialization at deserialization sa Java, ang impormasyon tungkol sa mga bagay ay maaaring ilipat mula sa isang JVM patungo sa isa pa.

#1 Serialization

Bago pumunta sa detalye, tingnan natin ang SerializeUtils.java at Person.java na mga klase . Dito ay tutulungan nila kaming magsagawa ng serialization at deserialization gamit ang mga partikular na halimbawa.

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

Gaya ng nabanggit, nakakatulong ang serialization na i-convert ang isang object sa isang stream ng bytes. Nangangahulugan ito na ang lahat ng impormasyon tungkol sa bagay ay na-convert din sa isang byte stream, tulad ng pamamaraan, mga katangian at data. Narito ang isang halimbawa kung paano na-serialize ang isang bagay:

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

Pagkatapos ng proseso ng serialization mayroon kaming isang file na may sumusunod na nilalaman:

#2 Deserialization

Kung sa nakaraang halimbawa ay lumikha kami ng isang stream ng mga byte sa pamamagitan ng pagse-serialize ng isang bagay, ngayon tingnan natin kung paano tayo babalik sa object gamit ang deserialization:

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

Narito ang data pagkatapos ng proseso ng deserialization:

#3 Serial na Bersyon UID

Ang SerialVersionUID ay nangangahulugang isang natatanging numero ng pagkakakilanlan para sa bawat bersyon ng proseso ng serialization at deserialization. Ginagamit ang numerong ito upang matiyak na ang parehong serialized at deserialized na mga bagay ay gumagamit ng mga katugmang klase. Para sa Person.java, gusto kong taasan ang serialVersionUID sa 2. Tingnan natin ang output pagkatapos i-deserialize ang person.txt file.

#4 Lumilipas ang Keyword

Sa panahon ng proseso ng serialization at deserialization, minsan hindi namin kailangang i-serialize ang lahat ng impormasyon tungkol sa isang bagay. Sa pamamagitan ng paggamit ng lumilipas na proseso para sa mga variable, maaari nating balewalain ang mga variable na iyon mula sa object na sine-serye. Ang halimbawa sa ibaba ay makakatulong na maunawaan ito nang mas malinaw:

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

Sa code sa itaas, ginamit namin ang lumilipas na keyword para sa variable ng edad . At ito ang nakuha namin pagkatapos ng proseso ng serialization at deserialization.

#5 Externalizable Interface

Sa Java, kapag gusto naming i-customize ang proseso ng serialization at deserialization, maaari kaming gumamit ng proseso ng paglipat upang balewalain ang mga variable na hindi namin kailangan para sa proseso ng serialization at deserialization. Ang isa pang paraan upang pasimplehin at pagbutihin ang pagganap ay ang paggamit ng Externalizable na interface sa halip na ang Serializable na interface . Tingnan natin ang isang halimbawa:

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

Gaya ng nakikita mo, kapag gumagamit ng Externalizable madali kaming makakasulat ng custom na logic, huwag pansinin ang mga variable at makakuha ng mas mahusay na performance kaysa sa paggamit ng Serializable . Ngayon tingnan natin ang output:

Konklusyon

Sana, sa pamamagitan ng artikulong ito, nakakuha ka ng malinaw na pag-unawa sa kung paano gumagana ang serialization at deserialization sa Java, at ang mga halimbawa sa itaas ay makakatulong sa iyo sa pagsasanay sa hinaharap.