Monday, 3 October 2016

Java Tutorial : Java IO (Java Serialization with IS A Inheritance)

🚀 Ready to Master Java?

Don't miss out on more easy-to-follow coding tutorials. Join our growing community today!

Java Serialization with IS-A (Inheritance)

Welcome back! Today, we are diving deep into how Serialization works when Inheritance (IS-A relationship) is involved. This is a common topic in interviews and a must-know for any Java developer working with object persistence.

What is the IS-A Relationship in Serialization?

In Java, when a child class inherits from a parent class, it is known as an IS-A relationship. When it comes to Serialization, the main question is: If a parent class is serializable, is the child class also serializable? Let’s look at the different scenarios.

Scenario 1: Parent Class Implements Serializable

If a Parent class implements the java.io.Serializable interface, then every Child class that extends it automatically becomes serializable. You don't need to explicitly implement the interface in the child class. This is because the serializable property is inherited.

Scenario 2: Parent is NOT Serializable, but Child IS

This is a tricky part! If the Parent class does not implement Serializable, but the Child class does, you can still serialize the Child object. However, there are specific rules:

During deserialization, Java will run the default constructor of the non-serializable Parent class.
Any fields inherited from the non-serializable Parent will be reset to their default values (e.g., 0 for int, null for objects).
Important: The Parent class must have a no-argument constructor; otherwise, a InvalidClassException will be thrown.

Key Takeaways for Beginners

Inheritance Matters: If the base class is serializable, all subclasses are too.
Constructor Rule: Always check if your non-serializable parent classes have a default constructor if you plan to serialize the children.
Data Loss: Be careful with non-serializable parents, as their specific state won't be saved during the process.

Watch More from Ram N Java:

Keep learning with these related Java IO tutorials:

Click here to watch in Youtube :
https://www.youtube.com/watch?v=Ww7W_VLVgHQ&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

Java Tutorial : Java IO (Java Serialization with IS A Inheritance)

Person.java

import java.io.Serializable;

/*
 * If a class implements serializable then all its sub
 * classes will also be serializable.
 */
public class Person implements Serializable
{

    private static final long serialVersionUID = -7438582605700356851L;
    protected String name;
    protected int age;

    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }

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

}

Employee.java

/*
 * We can serialize the Employee class object that
 * extends the Person class which is Serializable.Parent
 * class properties are inherited to subclasses so if
 * parent class is Serializable, subclass would also be.
 */
public class Employee extends Person
{

    private static final long serialVersionUID = 312396230370712755L;
    private int salary;

    public Employee(String name, int age, int salary)
    {
        super(name, age);
        this.salary = salary;
    }

    public int getSalary()
    {
        return salary;
    }

    public void setSalary(int salary)
    {
        this.salary = salary;
    }

}

SerializationDemo.java

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializationDemo
{

    public static void main(String[] args) throws FileNotFoundException,
            IOException, ClassNotFoundException
    {
        SerializationDemo serializationDemo = new SerializationDemo();
        serializationDemo.writeEmployeeObject();
    }

    private void writeEmployeeObject() throws FileNotFoundException,
            IOException
    {
        FileOutputStream fileOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try
        {
            fileOutputStream = new FileOutputStream("employee.tmp");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);

            Employee employee = new Employee("Peter", 29, 80000);

            /*
             * Write the specified object to the
             * ObjectOutputStream.
             */
            objectOutputStream.writeObject(employee);
            System.out
                    .println("Successfully written employee object to the file.\n");
        }
        finally
        {

            if (objectOutputStream != null)
            {
                /*
                 * Closing a ObjectOutputStream will also
                 * close the OutputStream instance to which
                 * the ObjectOutputStream is writing.
                 */
                objectOutputStream.close();
            }
        }

    }

}

Output

Successfully written employee object to the file.

employee.tmp

DeSerializationDemo.java

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeSerializationDemo
{

    public static void main(String[] args) throws FileNotFoundException,
            IOException, ClassNotFoundException
    {
        DeSerializationDemo deSerializationDemo = new DeSerializationDemo();
        deSerializationDemo.readEmployeeObject();
    }

    private void readEmployeeObject() throws IOException,
            FileNotFoundException, ClassNotFoundException
    {
        FileInputStream fileInputStream = null;
        ObjectInputStream objectInputStream = null;

        try
        {
            fileInputStream = new FileInputStream("employee.tmp");
            objectInputStream = new ObjectInputStream(fileInputStream);

            /*
             * Read an object from the ObjectInputStream.
             */
            Employee employee = (Employee) objectInputStream.readObject();

            System.out
                    .println("Successfully read employee object from the file.");

            System.out.println("Name = " + employee.getName());
            System.out.println("Age  = " + employee.getAge());
            System.out.println("Salary  = " + employee.getSalary());
        }
        finally
        {

            if (objectInputStream != null)
            {
                /*
                 * Closing a ObjectInputStream will also
                 * close the InputStream instance from which
                 * the ObjectInputStream is reading.
                 */
                objectInputStream.close();
            }
        }

    }

}

Output

Successfully read employee object from the file.
Name = Peter
Age  = 29
Salary  = 80000

Click the below link to download the code:
https://sites.google.com/site/ramj2eev1/home/javabasics/JavaIODemo_Serialization_IS_A_Relationship_App.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/Java/tree/master/BasicJava/JavaIODemo_Serialization_IS_A_Relationship_App

Bitbucket Link:
https://bitbucket.org/ramram43210/java/src/9ef303db3f229fc70e7cf47baac5692282611e62/BasicJava/JavaIODemo_Serialization_IS_A_Relationship_App/?at=master

See also:

All JavaEE Viedos Playlist

All JavaEE Viedos

All JAVA EE Links

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Monday, 3 October 2016

Java Tutorial : Java IO (Java Serialization with IS A Inheritance)

Java Serialization with IS-A (Inheritance)

What is the IS-A Relationship in Serialization?

Scenario 1: Parent Class Implements Serializable

Scenario 2: Parent is NOT Serializable, but Child IS

Key Takeaways for Beginners

Watch More from Ram N Java:

No comments:

Post a Comment

Tutorials