පළමුව මට අනුක්‍රමිකකරණය යනු කුමක්දැයි පැහැදිලි කළ යුතුය.
අනුක්‍රමිකකරණය මඟින් වස්තුවක් ධාරාවකට පරිවර්තනය කිරීමට ඉඩ සලසයි, එම වස්තුව ජාලය හරහා යැවීම සඳහා හෝ ලිපිගොනු සුරැකීම හෝ ලිපිගොනු භාවිතය සඳහා ඩී.බී.
අනුක්‍රමිකකරණය සඳහා නීති කිහිපයක් තිබේ .
වස්තුවක් අනුක්‍රමික කළ හැක්කේ එහි පන්තිය හෝ එහි සුපිරි පන්තිය අනුක්‍රමික අතුරු මුහුණත ක්රියාත්මක කරන්නේ නම් පමණි
වස්තුවක් එහි සුපිරි පන්තිය නොවුනත්, අනුක්‍රමික කළ හැකි ය (අනුක්‍රමික අතුරු මුහුණත ක්රියාත්මක කරයි). කෙසේ වෙතත්, අනුක්‍රමික කළ හැකි අතුරුමුහුණත ක්රියාත්මක නොකරන, අනුක්‍රමික පන්තියේ ධූරාවලියෙහි පළමු සුපිරි පන්තියට, ආර්ග් රහිත ඉදිකිරීම්කරුවෙකු සිටිය යුතුය. මෙය උල්ලං is නය වී ඇත්නම්, කියවීමේ වස්තුව () ක්රියාත්මක වන විට java.io.InvalidClassException නිපදවයි
සියලුම ප්‍රාථමික වර්ග අනුක්‍රමික වේ.
අස්ථිර ක්ෂේත්‍ර (අස්ථිර විකරණකාරකය සමඟ) අනුක්‍රමික නොවේ, (එනම්, සුරකින ලද හෝ ප්‍රතිස්ථාපනය නොකළ). අනුක්‍රමිකකරණය ක්රියාත්මක කරන පන්තියක් අනුක්‍රමිකකරණයට සහය නොදක්වන පන්තිවල අස්ථිර ක්ෂේත්‍ර සලකුණු කළ යුතුය (උදා: ගොනු ප්‍රවාහයක්).
ස්ථිතික ක්ෂේත්‍ර (ස්ථිතික විකරණකාරකය සමඟ) අනුක්‍රමික නොවේ.
Objectඅනුක්‍රමිකකරණය කළ විට , ජාවා ධාවන වේලාව අනුක්‍රමික අනුවාද අංක aka සමඟ සම්බන්ධ කරයි serialVersionID.
අපට SerialVersionID අවශ්ය තැන:
යවන්නා සහ ලබන්නා අනුක්‍රමිකකරණයට අනුකූලද යන්න තහවුරු කර ගැනීම සඳහා ඩෙසරීකරණය අතරතුර. ග්‍රාහකයා වෙනත් ආකාරයකින් පන්තිය පටවා ඇත්නම්,serialVersionIDඩෙසරීකරණය අවසන් වනු ඇතInvalidClassCastException. ස්ථිතික, අවසාන සහ වර්ගයේ දිග විය යුතුනම්කළක්ෂේත්‍රයක් ප්‍රකාශ කිරීමෙන්
අනුක්‍රමික පන්තියකට තමන්ගේමserialVersionUIDප්‍රකාශයක්serialVersionUIDකළ හැකිය.
අපි මෙය උදාහරණයක් සමඟ උත්සාහ කරමු.
import java.io.Serializable;
public class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String empname;
private byte empage;
public String getEmpName() {
return name;
}
public void setEmpName(String empname) {
this.empname = empname;
}
public byte getEmpAge() {
return empage;
}
public void setEmpAge(byte empage) {
this.empage = empage;
}
public String whoIsThis() {
StringBuffer employee = new StringBuffer();
employee.append(getEmpName()).append(" is ).append(getEmpAge()).append("
years old "));
return employee.toString();
}
}
අනුක්‍රමික වස්තුව සාදන්න
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Writer {
public static void main(String[] args) throws IOException {
Employee employee = new Employee();
employee.setEmpName("Jagdish");
employee.setEmpAge((byte) 30);
FileOutputStream fout = new
FileOutputStream("/users/Jagdish.vala/employee.obj");
ObjectOutputStream oos = new ObjectOutputStream(fout);
oos.writeObject(employee);
oos.close();
System.out.println("Process complete");
}
}
වස්තුව අවතක්සේරු කරන්න
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Reader {
public static void main(String[] args) throws ClassNotFoundException,
IOException {
Employee employee = new Employee();
FileInputStream fin = new
FileInputStream("/users/Jagdish.vala/employee.obj");
ObjectInputStream ois = new ObjectInputStream(fin);
employee = (Employee) ois.readObject();
ois.close();
System.out.println(employee.whoIsThis());
}
}
සටහන: දැන් සේවක පන්තියේ අනුක්‍රමික අනුවාදය වෙනස් කර සුරකින්න:
private static final long serialVersionUID = 4L;
පා er ක පන්තිය ක්රියාත්මක කරන්න. ලේඛක පන්තිය ක්රියාත්මක කිරීමට නොවන අතර ඔබට ව්‍යතිරේකය ලැබෙනු ඇත.
Exception in thread "main" java.io.InvalidClassException:
com.jagdish.vala.java.serialVersion.Employee; local class incompatible:
stream classdesc serialVersionUID = 1, local class serialVersionUID = 4
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at com.krishantha.sample.java.serialVersion.Reader.main(Reader.java:14)