Samderlust

As learning Java, we knew how to deal with Inheritance where all the subclasses will represent the spirit of the superclass. They inherited all the attributes and methods that belong to superclass. 

Abstract on a class

Once we have enough subclasses for covering all different kinds of the superClass. Sure we don’t need to make an instance from the superclass anymore. There is no scene for doing that.

For giving an simple example, let me put it in this silly way:

We have a superClass Finger, and we will have 5 subclasses, no need to say eh? Just in case of birth defects, we have another subclass for the extra fingers...

• Finger (superClass)
  1. Thumb
  2. Index
  3. Middle
  4. Ring
  5. Little
  6. ExtraFinger

Up to this point, all the subclasses are enough to cover all kinds of a finger.  It seems like we don’t need to initialize any object straight from the Finger class. We make Finger an abstract class to prevent accidentally initialize it.

Another case of Abstract class is when your Inheritance tree has many layers, the top superClass at some point doesn’t need to be used for initializing an object, you also wanna make it abstract.

Note:

• An abstract class cannot be used to initialize an object (it’s abstract, not a real object).
• We make a superclass as Abstract when we find that all the subclasses cover all the type we need about that class and there’s no need to have an object that initialized directly from the superclass.
• An Abstract class is kind of a principle that enforce all the subclass to follow all the abstract methods inside it.

Abstract on methods

If a method is declared as abstract in a superclass, the subclass must implement this method unless it will throw an error. The abstract method just needs to be declared (name, return type, variable type) without having the body.

We declare an abstract method to ensure that all the subclasses will have a kind of behavior in common, but the behavior doesn’t need to be the same between those subclasses.

public static abstract class Finger {
    private String name;

    public Finger(String name) { this.name = name; }

    public abstract void action();
}

public static class Thumb extends Finger{
    public Thumb(String name) { super(name); }

    @Override
    public void action() { System.out.println("Give a thumb up"); }
}

public static class Index extends Finger{

    public Index(String name) { super(name); }

    @Override
    public void action() { System.out.println("Point to something"); }
}

Consider the code above. We want to enforce all the finger subclasses have a method of action but they can implement that method in their own way. We declared the action method in the superclass Finger as abstract without specific the code inside the method. The ability that allows the same method acts differently among all subclasses is known as Polymorphism. The abstract keyword here is just for enforcing all the subclasses implement that method. Keeping everything uniform.

Note:

• An Abstract method must be declared inside an Abstract class.
• An Abstract method couldn’t be implemented (have no code in its body) in abstract class since this class couldn’t be initialized.
• All subclasses of an abstract class MUST implement the abstract methods.

public class AbstractClass {
    public static abstract class Finger {
        private String name;

        public Finger(String name) { this.name = name; }

        public abstract void action();
    }

    public static class Thumb extends Finger{
        public Thumb(String name) { super(name); }

        @Override
        public void action() { System.out.println("Give a thumb up"); }
    }

    public static class Index extends Finger{

        public Index(String name) { super(name); }

        @Override
        public void action() { System.out.println("Point to something"); }
    }

    public static class Middle extends Finger{
        public Middle(String name) {
            super(name);
        }

        @Override
        public void action() { System.out.println("OK, F...ine!"); }
    }
    public static class Ring extends Finger{
        public Ring(String name) {
            super(name);
        }

        @Override
        public void action() { System.out.println("Will you marry me?"); }
    }

    public static class Little extends Finger{
        public Little(String name) {
            super(name);
        }

        @Override
        public void action() { System.out.println("What am I used for?"); }
    }

    public static void main(String[] args) {
        //initialize all subclasses
    }
}

Today, we will get to know how to write an ArrayList object to a file and then load the object back to the Java program form that file. This would help us to store the data to test other features that we added to the program without re-putting the common data.

First, we’ll take a look at the code below

1. Since we will need to use a lot of classes inside java.io, we import everything inside that specific library.

2. Create a class Person with 3 attributes, a constructor function and overriding toString method to print the detail of an object we will initialize later. As this the objects of this class will be used to write to file and then load back, we need to implement the Serializable interface to indicate Java that this class can be serialized or deserialized.

3. inside this main methods we will create 3 objects of the class Person. Then, we create an ArrayList name people and add those 3 Person objects.

Now, we are ready to write this Arraylist into a file.

Write an object into a file.

We add this code to the main method.

//write to file
try{
    FileOutputStream writeData = new FileOutputStream("peopledata.ser");
    ObjectOutputStream writeStream = new ObjectOutputStream(writeData);

    writeStream.writeObject(people);
    writeStream.flush();
    writeStream.close();

}catch (IOException e) {
    e.printStackTrace();
}

Because writing and reading data can cause Error we need to use a try catch block to handle the Exception that can occur.

FileOutputStream writeData = new FileOutputStream(“peopledata.ser”): Creates a file output stream to write to the file that we provide inside the parentheses. You can provide the path to the file if you want, in this case, I just give the file name, so that the file will be stored in the same folder with the .java file

ObjectOutputStream writeStream = new ObjectOutputStream(writeData):  ObjectOutputStream will handle the object to be written into the file that FileOutputStream created.

FileOutputStream and ObjectOutputStream should come together in order to write an object to a file.

writeStream.writeObject(people): tell the program to write this peple object which is an ArrayList that we’ve just created above into the file peopledata.ser
writeStream.flush(): using the flush method here is not really necessary but it’s a good practice to have flush() since it will flush all the data in the stream, make sure data is written into the file.
writeStream.close(); we close the stream after the writing is done. This also releases the system resources.

Open the file peopledata.ser and you will see that there is something written. Don’t be afraid that you can’t read it, Java can.

��srjava.util.ArrayListx����a�
IsizexpwsrPerson-ĩ��9/I birthYearL 
firtNametLjava/lang/String;L lastNameq~xp�tJonytDeepsq
~�tAndrewtJustinsq~�tValaktSusanx

Reading the data from a file

Writing is done, now we can load the data from the file to be used in our program.

Append the code below to the main method

try{
    FileInputStream readData = new FileInputStream("peopledata.ser");
    ObjectInputStream readStream = new ObjectInputStream(readData);

    ArrayList<Person> people2 = (ArrayList<Person>) readStream.readObject();
    readStream.close();
    System.out.println(people2.toString());
}catch (Exception e) {
    e.printStackTrace();
}

Still, we use try-catch to ensure that all the exceptions will be caught.

FileInputStream readData = new FileInputStream(“peopledata.ser”) & ObjectInputStream readStream = new ObjectInputStream(readData): note that this time we use Input instead of Ouput since we want to read from the file into the program.

ArrayList<Person> people2 = (ArrayList<Person>) readStream.readObject(): We create a new ArrayList people2 just to make sure this is a new object that is distinct from the existing people object. We assign the value that we reed form the file “peopledata.ser” and make sure we cast the value into an ArrayList of Person.

readStream.close(): close the reading stream.

System.out.println(people2.toString()): print the new ArrayList to the console to see if all the data is loaded correctly.

[Person{firtName='Jony', lastName='Deep', birthYear=1980}
, Person{firtName='Andrew', lastName='Justin', birthYear=1990}
, Person{firtName='Valak', lastName='Susan', birthYear=1995}
]

Yes, it’s correct.

import java.io.*;
import java.util.ArrayList;

public class Person implements Serializable {
    private String firstName;
    private String lastName;
    private int birthYear;

    public Person(String firtName, String lastName, int birthYear) {
        this.firstName = firtName;
        this.lastName = lastName;
        this.birthYear = birthYear;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firtName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", birthYear=" + birthYear +
                "}\n";
    }

    public static void main(String[] args) {
        Person p1 = new Person("Jony", "Deep", 1980);
        Person p2 = new Person("Andrew", "Justin", 1990);
        Person p3 = new Person("Valak", "Susan", 1995);

        ArrayList<Person> people = new ArrayList<>();

        people.add(p1);
        people.add(p2);
        people.add(p3);

        //write to file
        try{
            FileOutputStream writeData = new FileOutputStream("peopledata.ser");
            ObjectOutputStream writeStream = new ObjectOutputStream(writeData);

            writeStream.writeObject(people);
            writeStream.flush();
            writeStream.close();

        }catch (IOException e) {
            e.printStackTrace();
        }

        try{
            FileInputStream readData = new FileInputStream("peopledata.ser");
            ObjectInputStream readStream = new ObjectInputStream(readData);

            ArrayList people2 = (ArrayList<Person>) readStream.readObject();
            readStream.close();

            System.out.println(people2.toString());
        }catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}