คอฟฟี่เบรค #180. ตัวแปรใน Java: คืออะไรและใช้งานอย่างไร 5 สิ่งที่คุณควรรู้เกี่ยวกับการทำให้เป็นอนุกรมและดีซีเรียลไลซ์ใน Java

ตัวแปรใน Java: คืออะไรและใช้งานอย่างไร

ที่มา: Hackernoon มีตัวแปรสี่ประเภทที่แตกต่างกันใน Java ขึ้นอยู่กับตำแหน่งที่ประกาศในโปรแกรม วันนี้คุณจะได้เรียนรู้ตัวอย่างและข้อแตกต่างของแต่ละประเภท 1. ตัวแปรอินสแตนซ์หรือฟิลด์อินสแตนซ์เป็นตัวแปรที่ประกาศภายในคลาสโดยไม่มี คีย์เวิร์ด แบบคงที่แต่อยู่นอกเมธอด ตัวสร้าง หรือบล็อกของโค้ด ตัวแปรดังกล่าวสามารถประกาศได้ทุกที่ภายในคลาส คุณสามารถประกาศโดยมีหรือไม่มีตัวแก้ไขการเข้าถึง เช่นpublic , private , protectedหรือdefault (ไม่ใช่คำหลัก)

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

หากฟิลด์อินสแตนซ์ไม่ได้กำหนดค่า ณ เวลาประกาศ ฟิลด์นั้นจะถูกกำหนดค่าเริ่มต้นเป็นศูนย์หากเป็นประเภทดั้งเดิม เช่น ( int , boolean , long , float ) หรือ null หากไม่ใช่ประเภทดั้งเดิม เช่น ( String , Integer , AnyClass ) พวกมันถูกเรียกว่าฟิลด์หรือตัวแปรอินสแตนซ์เนื่องจากเป็นของอินสแตนซ์ของออบเจ็กต์ใด ๆ ที่สร้างขึ้นจากคลาสที่มีการประกาศพวกมัน

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

ดังนั้น แต่ละฟิลด์อินสแตนซ์จะไม่ซ้ำกับออบเจ็กต์ ดังที่เห็นในตัวอย่างด้านบน ในนั้นobj1และobj2มีค่าเฉพาะที่กำหนดให้กับฟิลด์อินสแตนซ์ที่เกี่ยวข้อง 2. ฟิลด์คลาสหรือฟิลด์แบบคงที่คือฟิลด์ที่ประกาศด้วย คำหลัก แบบคงที่ มีการประกาศภายในคลาส แต่อยู่นอกเมธอด ตัวสร้าง หรือบล็อกของโค้ด นอกจากนี้ยังสามารถประกาศในตำแหน่งใดก็ได้ภายในคลาส โดยมีหรือไม่มีตัวแก้ไขการเข้าถึง เช่นpublic , private , protectedหรือdefault (ไม่ใช่คีย์เวิร์ด)

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

ฟิลด์แบบคงที่สามารถเข้าถึงได้ผ่านคลาสเท่านั้นและไม่ใช่จากออบเจ็กต์ใด ๆ ดังที่แสดงในตัวอย่างโค้ดด้านบน 3. พารามิเตอร์หรือตัวแปรอาร์กิวเมนต์เป็นตัวแปรที่ประกาศภายในโครงสร้างวิธีการระหว่างเครื่องหมายปีกกาเปิดและปิดของลายเซ็นวิธีการ ใช้เพื่อส่งผ่านค่าหรือวัตถุไปยังวิธีการ

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. ตัวแปรเฉพาะที่คือตัวแปรที่ประกาศภายในเมธอดหรือบล็อกโค้ดใดๆ ตัวอย่างเช่น ภายในบล็อกของ คำสั่ง if , for loop , While loop , บล็อกของ คำสั่ง switchและอื่นๆ

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

ในโค้ดนี้ คุณจะสังเกตเห็นการใช้การอ้างอิงกับตัวแปรบางตัว ในขณะที่รหัส ตัวแปรภายในเครื่อง ไม่ได้ถูกกล่าวถึงเป็นตัวแปรอ้างอิง ตัวแปรที่ไม่ใช่ตัวแปรพื้นฐานใดๆ จะเป็นตัวแปรอ้างอิง ตัวอย่างเช่นobj1เป็นตัวแปรประเภทMyClassและtempNameเป็นตัวแปรประเภทStringและที่นี่ทั้งสองประเภทไม่ใช่ประเภทดั้งเดิม ในกรณีนี้idคือตัวแปรประเภทintซึ่งเป็นประเภทข้อมูลดั้งเดิม ดังนั้นจึงเป็นตัวแปรที่ไม่อ้างอิง

5 สิ่งที่คุณควรรู้เกี่ยวกับการทำให้เป็นอนุกรมและดีซีเรียลไลซ์ใน Java

ที่มา: Devgenius ด้วยบทช่วยสอนนี้ คุณจะพัฒนาความรู้เกี่ยวกับวิธีการทำงานของซีเรียลไลซ์เซชันและดีซีเรียลไลซ์เซชัน การทำให้เป็นอนุกรมใน Java ช่วยแปลงอ็อบเจ็กต์ที่มีอยู่ให้เป็นสตรีมไบต์ ในทางกลับกัน การดีซีเรียลไลซ์ทำให้สตรีมไบต์เป็นอ็อบเจ็กต์ การใช้การทำให้เป็นอนุกรมและการดีซีเรียลไลซ์ใน Java ข้อมูลเกี่ยวกับอ็อบเจ็กต์สามารถถ่ายโอนจาก JVM หนึ่งไปยังอีก JVM ได้

#1 การทำให้เป็นอนุกรม

ก่อนที่จะลงรายละเอียด เรามาดู คลาส SerializeUtils.javaและPerson.java กัน ก่อน ที่นี่จะช่วยเราดำเนินการซีเรียลไลเซชันและดีซีเรียลไลซ์โดยใช้ตัวอย่างเฉพาะ

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

บุคคล.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;
    }
}

ดังที่ได้กล่าวไปแล้ว การทำให้เป็นอนุกรมจะช่วยแปลงอ็อบเจ็กต์ให้เป็นกระแสข้อมูลไบต์ ซึ่งหมายความว่าข้อมูลทั้งหมดเกี่ยวกับออบเจ็กต์จะถูกแปลงเป็นสตรีมไบต์ด้วย เช่น วิธีการ คุณสมบัติ และข้อมูล นี่คือตัวอย่างของวิธีการทำให้วัตถุเป็นอนุกรม:

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

หลังจากกระบวนการซีเรียลไลซ์ เราจะได้ไฟล์ที่มีเนื้อหาดังต่อไปนี้:

#2 ดีซีเรียลไลเซชัน

หากในตัวอย่างก่อนหน้านี้ เราสร้างกระแสข้อมูลไบต์โดยทำให้วัตถุเป็นอนุกรม ตอนนี้เรามาดูกันว่าเราจะกลับไปยังวัตถุโดยใช้การดีซีเรียลไลซ์ได้อย่างไร:

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

นี่คือข้อมูลหลังจากกระบวนการดีซีเรียลไลซ์:

#3 UID เวอร์ชันอนุกรม

SerialVersionUID หมายถึงหมายเลขประจำตัวที่ไม่ซ้ำกันสำหรับกระบวนการซีเรียลไลซ์และดีซีเรียลไลซ์แต่ละเวอร์ชัน หมายเลขนี้ใช้เพื่อให้แน่ใจว่าทั้งอ็อบเจ็กต์ซีเรียลไลซ์และดีซีเรียลไลซ์ใช้คลาสที่เข้ากันได้ สำหรับPerson.javaฉันต้องการเพิ่ม serialVersionUID เป็น 2 มาดูผลลัพธ์หลังจากทำการดีซีเรียลไลซ์ไฟล์ person.txt แล้ว

#4 คำหลักชั่วคราว

ในระหว่างกระบวนการซีเรียลไลซ์และดีซีเรียลไลซ์ บางครั้งเราไม่จำเป็นต้องซีเรียลไลซ์ข้อมูลทั้งหมดเกี่ยวกับออบเจ็กต์ ด้วยการใช้กระบวนการชั่วคราวสำหรับตัวแปร เราสามารถละเว้นตัวแปรเหล่านั้นจากออบเจ็กต์ที่กำลังซีเรียลไลซ์ได้ ตัวอย่างด้านล่างจะช่วยให้เข้าใจสิ่งนี้ได้ชัดเจนยิ่งขึ้น:

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

ในโค้ดข้าง ต้น เราได้ใช้ คีย์เวิร์ดชั่วคราวสำหรับ ตัวแปร อายุ และนี่คือสิ่งที่เราได้รับหลังจากกระบวนการซีเรียลไลซ์และดีซีเรียลไลซ์

#5 อินเทอร์เฟซภายนอกได้

ใน Java เมื่อเราต้องการปรับแต่งกระบวนการซีเรียลไลซ์และดีซีเรียลไลซ์ เราสามารถใช้กระบวนการเปลี่ยนผ่านเพื่อละเว้นตัวแปรที่เราไม่ต้องการสำหรับกระบวนการซีเรียลไลซ์และดีซีเรียลไลซ์ อีกวิธีหนึ่งใน การลดความซับซ้อนและปรับปรุงประสิทธิภาพคือการใช้ อินเทอร์เฟซ Externalizable แทน อินเทอร์เฟซSerializable ลองดูตัวอย่าง:

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

อย่างที่คุณเห็น เมื่อใช้Externalizableเราสามารถเขียนตรรกะที่กำหนดเอง ละเว้นตัวแปร และรับประสิทธิภาพที่ดีกว่าการใช้Serializableได้ อย่างง่ายดาย ตอนนี้เรามาดูผลลัพธ์กันดีกว่า:

บทสรุป

หวังว่าจากบทความนี้ คุณจะได้รับความเข้าใจที่ชัดเจนเกี่ยวกับวิธีการทำงานของซีเรียลไลซ์เซชันและดีซีเรียลไลเซชันใน Java และตัวอย่างข้างต้นจะช่วยคุณได้ในทางปฏิบัติในอนาคต