ตัวแปรใน Java: คืออะไรและใช้งานอย่างไร ที่มา:
Hackernoon มีตัวแปรสี่ประเภทที่แตกต่างกันใน Java ขึ้นอยู่กับตำแหน่งที่ประกาศในโปรแกรม วันนี้คุณจะได้เรียนรู้ตัวอย่างและข้อแตกต่างของแต่ละประเภท 1. ตัวแปรอินสแตนซ์ หรือ
ฟิลด์อินสแตนซ์ เป็นตัวแปรที่ประกาศภายในคลาสโดยไม่มี คีย์เวิร์ด
แบบคงที่ แต่อยู่นอกเมธอด ตัวสร้าง หรือบล็อกของโค้ด ตัวแปรดังกล่าวสามารถประกาศได้ทุกที่ภายในคลาส คุณสามารถประกาศโดยมีหรือไม่มีตัวแก้ไขการเข้าถึง เช่น
public ,
private ,
protected หรือ
default (ไม่ใช่คำหลัก)
public class MyClass {
private String instanceField1;
public MyClass ( ) { }
public int anotherInstanceField2;
public void setInstanceField ( String parameterVariable) { . . . }
boolean instanceField3;
public static void main ( String [ ] args) {
System . out. println ( "field 1 value: " + instanceField1) ;
System . out. println ( "field 2 value: " + anotherInstanceField2) ;
System . out. println ( "field 3 value: " + instanceField3) ;
}
}
หากฟิลด์อินสแตนซ์ไม่ได้กำหนดค่า ณ เวลาประกาศ ฟิลด์นั้นจะถูกกำหนดค่าเริ่มต้นเป็นศูนย์หากเป็นประเภทดั้งเดิม เช่น ( int , boolean ,
long ,
float )
หรือ null
หาก ไม่ใช่
ประเภท ดั้งเดิม เช่น (
String ,
Integer ,
AnyClass ) พวกมันถูกเรียกว่าฟิลด์หรือตัวแปรอินสแตนซ์เนื่องจากเป็นของอินสแตนซ์ของออบเจ็กต์ใด ๆ ที่สร้างขึ้นจากคลาสที่มีการประกาศพวกมัน
public Main {
public static void main ( String [ ] args) {
MyClass obj1 = new MyClass ( ) ;
MyClass obj2 = new MyClass ( ) ;
obj1. anotherInstanceField2 = 11 ;
obj2. anotherInstanceField2 = 33 ;
System . out. println ( obj1. anotherInstanceField2) ;
System . out. println ( obj2. anotherInstanceField2) ;
}
}
ดังนั้น แต่ละฟิลด์อินสแตนซ์จะไม่ซ้ำกับออบเจ็กต์ ดังที่เห็นในตัวอย่างด้านบน ในนั้น
obj1 และ
obj2 มีค่าเฉพาะที่กำหนดให้กับฟิลด์อินสแตนซ์ที่เกี่ยวข้อง
2. ฟิลด์คลาส หรือ
ฟิลด์แบบคงที่ คือฟิลด์ที่ประกาศด้วย คำหลัก
แบบคง ที่ มีการประกาศภายในคลาส แต่อยู่นอกเมธอด ตัวสร้าง หรือบล็อกของโค้ด นอกจากนี้ยังสามารถประกาศในตำแหน่งใดก็ได้ภายในคลาส โดยมีหรือไม่มีตัวแก้ไขการเข้าถึง เช่น
public ,
private ,
protected หรือ
default (ไม่ใช่คีย์เวิร์ด)
public class MyClass {
public static String staticField;
public MyClass ( ) { }
}
class Main {
public static void main ( String [ ] args) {
MyClass obj = new MyClass ( ) ;
obj. staticField
MyClass . staticField = "I am a static field" ;
System . out. println ( MyClass . staticField) ;
}
}
ฟิลด์แบบคงที่สามารถเข้าถึงได้ผ่านคลาสเท่านั้นและไม่ใช่จากออบเจ็กต์ใด ๆ ดังที่แสดงในตัวอย่างโค้ดด้านบน 3.
พารามิเตอร์ หรือ
ตัวแปรอาร์กิวเมนต์ เป็นตัวแปรที่ประกาศภายในโครงสร้างวิธีการระหว่างเครื่องหมายปีกกาเปิดและปิดของลายเซ็นวิธีการ ใช้เพื่อส่งผ่านค่าหรือวัตถุไปยังวิธีการ
public class MyClass {
public String instanceField;
public MyClass ( ) { }
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) ;
}
}
4.
ตัวแปรเฉพาะที่ คือตัวแปรที่ประกาศภายในเมธอดหรือบล็อกโค้ดใดๆ ตัวอย่างเช่น ภายในบล็อกของ คำสั่ง
if ,
for loop ,
While loop , บล็อกของ คำสั่ง
switch และอื่นๆ
public Main {
public static void main ( String [ ] args) {
MyClass obj1 = new MyClass ( ) ;
int id = 1 ;
if ( id > 1 ) {
String tempName = "Austin" ;
}
}
}
ในโค้ดนี้ คุณจะสังเกตเห็นการใช้การอ้างอิงกับตัวแปรบางตัว ในขณะที่
รหัส ตัวแปรภายในเครื่อง ไม่ได้ถูกกล่าวถึงเป็นตัวแปรอ้างอิง ตัวแปรที่ไม่ใช่ตัวแปรพื้นฐานใดๆ จะเป็นตัวแปรอ้างอิง ตัวอย่างเช่น
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 และตัวอย่างข้างต้นจะช่วยคุณได้ในทางปฏิบัติในอนาคต
GO TO FULL VERSION