Monday, 29 August 2011


Introduction to Object Serialization
Java object serialization is used to persist Java objects to a file, database, network, process or any other system. Serialization flattens objects into an ordered, or serialized stream of bytes. The ordered stream of bytes can then be read at a later time, or in another environment, to recreate the original objects.
Java serialization does not cannot occur for transient or static fields. Marking the field transient prevents the state from being written to the stream and from being restored during deserialization. Java provides classes to support writing objects to streams and restoring objects from streams. Only objects that support the java.io.Serializable interface or the java.io.Externalizable interface can be written to streams.
public interface Serializable
  • The Serializable interface has no methods or fields. (Marker Interface)
  • Only objects of classes that implement java.io.Serializable interface can be serialized or deserialized
Transient Fields and Java Serialization
The transient keyword is a modifier applied to instance variables in a class. It specifies that the variable is not part of the persistent state of the object and thus never saved during serialization.
You can use the transient keyword to describe temporary variables, or variables that contain local information,
<br /><font size=-1>

such as a process ID or a time lapse.
Input and Output Object Streams
ObjectOutputStream is the primary output stream class that implements the ObjectOutput interface for serializing objects. ObjectInputStream is the primary input stream class that implements the ObjectInput interface for deserializing objects.
These high-level streams are each chained to a low-level stream, such as FileInputStream or FileOutputStream.
The low-level streams handle the bytes of data. The writeObject method saves the state of the class by writing the individual fields to the ObjectOutputStream. The readObject method is used to deserialize the object from
the object input stream.
Case 1: Below is an example that demonstrates object Serialization into a File
PersonDetails is the bean class that implements the Serializable interface
import java.io.Serializable;
public class PersonDetails implements Serializable {

        private String name;
        private int age;
        private String sex;
        public PersonDetails(String name, int age, String sex) {
               this.name = name;
               this.age = age;
               this.sex = sex;
        }
        public int getAge() {
               return age;
        }
        public void setAge(int age) {
               this.age = age;
        }
        public String getName() {
               return name;
        }
        public void setName(String name) {
               this.name = name;
        }
        public String getSex() {
               return sex;
        }
        public void setSex(String sex) {
               this.sex = sex;
        }
}
GetPersonDetails is the class that is used to Deserialize object from the File (person.txt).
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
public class GetPersonDetails {

        public static void main(String[] args) {
               String filename = "person.txt";
               List pDetails = null;
               FileInputStream fis = null;
               ObjectInputStream in = null;
               try {
                       fis = new FileInputStream(filename);
                       in = new ObjectInputStream(fis);
                       pDetails = (ArrayList) in.readObject();
                       in.close();
               } catch (IOException ex) {
                       ex.printStackTrace();
               } catch (ClassNotFoundException ex) {
                       ex.printStackTrace();
               }
               // print out the size
               System.out.println("Person Details Size: " + pDetails.size());
               System.out.println();
        }
}
PersonPersist is the class that is used to serialize object into the File (person.txt).
public class PersonPersist {

        public static void main(String[] args) {
               String filename = "person.txt";
               PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
               PersonDetails person2 = new PersonDetails("bob", 12, "Male");
               PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
               List list = new ArrayList();
               list.add(person1);
               list.add(person2);
               list.add(person3);
               FileOutputStream fos = null;
                ObjectOutputStream out = null;
               try {
                       fos = new FileOutputStream(filename);
                       out = new ObjectOutputStream(fos);
                       out.writeObject(list);
                       out.close();
                       System.out.println("Object Persisted");
               } catch (IOException ex) {
                       ex.printStackTrace();
               }
        }
}
——————————————————————————–
Case 2: Below is an example that demonstrates object Serialization into the database
PersonDetails remains the same as shown above
GetPersonDetails remains the same as shown above
Create SerialTest Table
create table SerialTest(
name BLOB,
viewname VARCHAR2(30)
);
PersonPersist is the class that is used to serialize object into the into the Database Table SerialTest.
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class PersonPersist {

        static String userid = "scott", password = "tiger";
        static String url = "jdbc:odbc:bob";
        static int count = 0;
        static Connection con = null;
        public static void main(String[] args) {
               Connection con = getOracleJDBCConnection();
               PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
               PersonDetails person2 = new PersonDetails("bob", 12, "Male");
               PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
               PreparedStatement ps;
               try {
                       ps = con
                                      .prepareStatement("INSERT INTO SerialTest VALUES (?, ?)");
                       write(person1, ps);
                       ps.execute();
                       write(person2, ps);
                       ps.execute();
                       write(person3, ps);
                       ps.execute();
                       ps.close();
                       Statement st = con.createStatement();
                       ResultSet rs = st.executeQuery("SELECT * FROM SerialTest");
                       while (rs.next()) {
                               Object obj = read(rs, "Name");
                               PersonDetails p = (PersonDetails) obj;
                               System.out.println(p.getName() + "\t" + p.getAge() + "\t"
                                              + p.getSex());
                       }
                       rs.close();
                       st.close();
               } catch (Exception e) {
               }
        }
        public static void write(Object obj, PreparedStatement ps)
                       throws SQLException, IOException {
               ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oout = new ObjectOutputStream(baos);
               oout.writeObject(obj);
               oout.close();
               ps.setBytes(1, baos.toByteArray());
               ps.setInt(2, ++count);
        }
        public static Object read(ResultSet rs, String column)
                       throws SQLException, IOException, ClassNotFoundException {
               byte[] buf = rs.getBytes(column);
               if (buf != null) {
                       ObjectInputStream objectIn = new ObjectInputStream(
                                      new ByteArrayInputStream(buf));
                       return objectIn.readObject();
               }
               return null;
        }
        public static Connection getOracleJDBCConnection() {
               try {
                       Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
               } catch (java.lang.ClassNotFoundException e) {
                       System.err.print("ClassNotFoundException: ");
                       System.err.println(e.getMessage());
               }
               try {
                       con = DriverManager.getConnection(url, userid, password);
               } catch (SQLException ex) {
                       System.err.println("SQLException: " + ex.getMessage());
               }
               return con;
        }
}
——————————————————————————–
Case 3: Below is an example that demonstrates object Serialization into the database using Base 64 Encoder
PersonDetails remains the same as shown above
GetPersonDetails remains the same as shown above
Create SerialTest Table
create table SerialTest(
name BLOB,
viewname VARCHAR2(30)
);
PersonPersist is the class that is used to serialize object into the Database Table SerialTest
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class PersonPersist {

        static String userid = "scott", password = "tiger";
        static String url = "jdbc:odbc:bob";
        static int count = 0;
        static Connection con = null;
        static String s;
        public static void main(String[] args) {
               Connection con = getOracleJDBCConnection();
               PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
               PersonDetails person2 = new PersonDetails("bob", 12, "Male");
               PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
               PreparedStatement ps;
               try {
                       ps = con
                                      .prepareStatement("INSERT INTO SerialTest VALUES (?, ?)");
                       write(person1, ps);
                       ps.execute();
                       write(person2, ps);
                       ps.execute();
                       write(person3, ps);
                       ps.execute();
                       ps.close();
                       Statement st = con.createStatement();
                       ResultSet rs = st.executeQuery("SELECT * FROM SerialTest");
                       while (rs.next()) {
                               Object obj = read(rs, "Name");
                               PersonDetails p = (PersonDetails) obj;
                               System.out.println(p.getName() + "\t" + p.getAge() + "\t"
                                              + p.getSex());
                       }
                       rs.close();
                       st.close();
               } catch (Exception e) {
               }
        }
        public static void write(Object obj, PreparedStatement ps)
                       throws SQLException, IOException {
               ByteArrayOutputStream baos = new ByteArrayOutputStream();
               ObjectOutputStream oout = new ObjectOutputStream(baos);
               oout.writeObject(obj);
               oout.close();
               byte[] buf = baos.toByteArray();
               s = new sun.misc.BASE64Encoder().encode(buf);
               ps.setString(1, s);
               // ps.setBytes(1, Base64.byteArrayToBase64(baos.toByteArray()));
               ps.setBytes(1, baos.toByteArray());
               ps.setInt(2, ++count);
        }
        public static Object read(ResultSet rs, String column)
                       throws SQLException, IOException, ClassNotFoundException {
               byte[] buf = new sun.misc.BASE64Decoder().decodeBuffer(s);
               // byte[] buf = Base64.base64ToByteArray(new
               // String(rs.getBytes(column)));
               if (buf != null) {
                       ObjectInputStream objectIn = new ObjectInputStream(
                                      new ByteArrayInputStream(buf));
                       Object obj = objectIn.readObject(); // Contains the object
                       PersonDetails p = (PersonDetails) obj;
                       System.out.println(p.getName() + "\t" + p.getAge() + "\t"
                                      + p.getSex());
               }
               return null;
        }
        public static Connection getOracleJDBCConnection() {
               try {
                       Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
               } catch (java.lang.ClassNotFoundException e) {
                       System.err.print("ClassNotFoundException: ");
                       System.err.println(e.getMessage());
               }
               try {
                       con = DriverManager.getConnection(url, userid, password);
               } catch (SQLException ex) {
                       System.err.println("SQLException: " + ex.getMessage());
               }
               return con;
        }
}
Below is a program that shows the serialization of a JButton object to a file and a Byte Array Stream. As before theobject to be serialized must implement the Serializable interface.
PersonDetails is the bean class that implements the Serializable interface
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class ObjectSerializationExample {

        public static void main(String args[]) {
               try {
                       Object object = new javax.swing.JButton("Submit");
                       // Serialize to a file namely "filename.dat"
                       ObjectOutput out = new ObjectOutputStream(
                                      new FileOutputStream("filename.dat"));
                       out.writeObject(object);
                       out.close();
                       // Serialize to a byte array
                       ByteArrayOutputStream bos = new ByteArrayOutputStream();
                       out = new ObjectOutputStream(bos);
                       out.writeObject(object);
                       out.close();
                       // Get the bytes of the serialized object
                       byte[] buf = bos.toByteArray();
               } catch (Exception e) {
                       e.printStackTrace();
               }
        }
}
Download Object Serialization Source code
Java Inheritance:
Java Inheritance defines an is-a relationship between a superclass and its subclasses. This means that an object of a subclass can be used wherever an object of the superclass can be used. Class Inheritance in java mechanism is used to build new classes from existing classes. The inheritance relationship is transitive: if class x extends class y, then a class z, which extends class x, will also inherit from class y.
For example a car class can inherit some properties from a General vehicle class. Here we find that the base class is the vehicle class and the subclass is the more specific car class. A subclass must use the extends clause to derive from a super class which must be written in the header of the subclass definition. The subclass inherits members of the superclass and hence promotes code reuse. The subclass itself can add its own new behavior and properties. The java.lang.Object class is always at the top of any Class inheritance hierarchy.
class Box {

        double width;
        double height;
        double depth;
        Box() {
        }
        Box(double w, double h, double d) {
               width = w;
               height = h;
               depth = d;
        }
        void getVolume() {
               System.out.println("Volume is : " + width * height * depth);
        }
}

public class MatchBox extends Box {

        double weight;
        MatchBox() {
        }
        MatchBox(double w, double h, double d, double m) {
               super(w, h, d);
<font size=-1>

               weight = m;
        }
        public static void main(String args[]) {
               MatchBox mb1 = new MatchBox(10, 10, 10, 10);
               mb1.getVolume();
               System.out.println("width of MatchBox 1 is " + mb1.width);
               System.out.println("height of MatchBox 1 is " + mb1.height);
               System.out.println("depth of MatchBox 1 is " + mb1.depth);
               System.out.println("weight of MatchBox 1 is " + mb1.weight);
        }
}
Output
Volume is : 1000.0
width of MatchBox 1 is 10.0
height of MatchBox 1 is 10.0
depth of MatchBox 1 is 10.0
weight of MatchBox 1 is 10.0
Download MatchBox.java
What is not possible using java class Inheritance?
1. Private members of the superclass are not inherited by the subclass and can only be indirectly accessed.
2. Members that have default accessibility in the superclass are also not inherited by subclasses in other packages, as these members are only accessible by their simple names in subclasses within the same package as the superclass.
3. Since constructors and initializer blocks are not members of a class, they are not inherited by a subclass.
4. A subclass can extend only one superclass
class Vehicle {

        // Instance fields
        int noOfTyres; // no of tyres
        private boolean accessories; // check if accessorees present or not
        protected String brand; // Brand of the car
        // Static fields
        private static int counter; // No of Vehicle objects created
        // Constructor
        Vehicle() {
               System.out.println("Constructor of the Super class called");
               noOfTyres = 5;
               accessories = true;
               brand = "X";
               counter++;
        }
        // Instance methods
        public void switchOn() {
               accessories = true;
        }
        public void switchOff() {
                accessories = false;
        }
        public boolean isPresent() {
               return accessories;
        }
        private void getBrand() {
               System.out.println("Vehicle Brand: " + brand);
        }
        // Static methods
        public static void getNoOfVehicles() {
               System.out.println("Number of Vehicles: " + counter);
        }
}

class Car extends Vehicle {

        private int carNo = 10;
        public void printCarInfo() {
               System.out.println("Car number: " + carNo);
               System.out.println("No of Tyres: " + noOfTyres); // Inherited.
               //  System.out.println("accessories: "    + accessories); // Not Inherited.
               System.out.println("accessories: " + isPresent()); // Inherited.
               //        System.out.println("Brand: "     + getBrand());  // Not Inherited.
               System.out.println("Brand: " + brand); // Inherited.
               //  System.out.println("Counter: "    + counter);     // Not Inherited.
               getNoOfVehicles(); // Inherited.
        }
}

public class VehicleDetails { // (3)

        public static void main(String[] args) {
               new Car().printCarInfo();
        }
}
Output
Constructor of the Super class called
Car number: 10
No of Tyres: 5
accessories: true
Brand: X
Number of Vehicles: 1
Download VehicleDetails.java
this and super keywords
The two keywords, this and super to help you explicitly name the field or method that you want. Using this and super you have full control on whether to call a method or field present in the same class or to call from the immediate superclass. This keyword is used as a reference to the current object which is an instance of the current class. The keyword super also references the current object, but as an instance of the current class’s super class.
The this reference to the current object is useful in situations where a local variable hides, or shadows, a field with the same name. If a method needs to pass the current object to another method, it can do so using the this reference. Note that the this reference cannot be used in a static context, as static code is not executed in the context of any object.
class Counter {

        int i = 0;
        Counter increment() {
               i++;
               return this;
        }
        void print() {
               System.out.println("i = " + i);
        }
}

public class CounterDemo extends Counter {

        public static void main(String[] args) {
               Counter x = new Counter();
               x.increment().increment().increment().print();
        }
}
Output
Volume is : 1000.0
width of MatchBox 1 is 10.0
height of MatchBox 1 is 10.0
depth of MatchBox 1 is 10.0
weight of MatchBox 1 is 10.0
Download CounterDemo.java

Object Reference Type Casting

In java object typecasting one object reference can be type cast into another object reference. The cast can be to its own class type or to one of its subclass or superclass types or interfaces. There are compile-time rules and runtime rules for casting in java.
How to Typecast Objects with a dynamically loaded Class ? - The casting of object references depends on the relationship of the classes involved in the same hierarchy. Any object reference can be assigned to a reference variable of the type Object, because the Object class is a superclass of every Java class.
There can be 2 casting java scenarios
· Upcasting
· Downcasting

When we cast a reference along the class hierarchy in a direction from the root class towards the children or subclasses, it is a downcast. When we cast a reference along the class hierarchy in a direction from the sub classes towards the root, it is an upcast. We need not use a cast operator in this case.
The compile-time rules are there to catch attempted casts in cases that are simply not possible. This happens when we try to attempt casts on objects that are totally unrelated (that is not subclass super class relationship or a class-interface relationship) At runtime a ClassCastException is thrown if the object being cast is not compatible with the new type it is being cast to.
&lt;br /&gt;&lt;font size=-1&gt;
Below is an example showing when a ClassCastException can occur during object casting
//X is a supper class of Y and Z which are sibblings.
public class RunTimeCastDemo {
 
        public static void main(String args[]) {
               X x = new X();
               Y y = new Y();
               Z z = new Z();
               X xy = new Y(); // compiles ok (up the hierarchy)
               X xz = new Z(); // compiles ok (up the hierarchy)
               //             Y yz = new Z();   incompatible type (siblings)
               //             Y y1 = new X();   X is not a Y
               //             Z z1 = new X();   X is not a Z
               X x1 = y; // compiles ok (y is subclass of X)
               X x2 = z; // compiles ok (z is subclass of X)
               Y y1 = (Y) x; // compiles ok but produces runtime error
               Z z1 = (Z) x; // compiles ok but produces runtime error
               Y y2 = (Y) x1; // compiles and runs ok (x1 is type Y)
               Z z2 = (Z) x2; // compiles and runs ok (x2 is type Z)
               //             Y y3 = (Y) z;     inconvertible types (siblings)
               //             Z z3 = (Z) y;     inconvertible types (siblings)
               Object o = z;
               Object o1 = (Y) o; // compiles ok but produces runtime error
        }
}
Download ClassCastException example Source Code

Casting Object References: Implicit Casting using a Compiler

In general an implicit cast is done when an Object reference is assigned (cast) to:
* A reference variable whose type is the same as the class from which the object was instantiated.
An Object as Object is a super class of every Class.
* A reference variable whose type is a super class of the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by a super class of the class from which the object was instantiated.
Consider an interface Vehicle, a super class Car and its subclass Ford. The following example shows the automatic conversion of object references handled by the compiler
interface Vehicle {
}
class Car implements Vehicle {
}
class Ford extends Car {
}
Let c be a variable of type Car class and f be of class Ford and v be an vehicle interface reference. We can assign the Ford reference to the Car variable:
I.e. we can do the following
Example 1
c = f; //Ok Compiles fine
Where c = new Car();
And, f = new Ford();
The compiler automatically handles the conversion (assignment) since the types are compatible (sub class - super class relationship), i.e., the type Car can hold the type Ford since a Ford is a Car.
Example 2
v = c; //Ok Compiles fine
c = v; // illegal conversion from interface type to class type results in compilation error
Where c = new Car();
And v is a Vehicle interface reference (Vehicle v)
The compiler automatically handles the conversion (assignment) since the types are compatible (class – interface relationship), i.e., the type Car can be cast to Vehicle interface type since Car implements Vehicle Interface. (Car is a Vehicle).
Casting Object References: Explicit Casting
Sometimes we do an explicit cast in java when implicit casts don’t work or are not helpful for a particular scenario. The explicit cast is nothing but the name of the new “type” inside a pair of matched parentheses. As before, we consider the same Car and Ford Class
class Car {
void carMethod(){
}
}
class Ford extends Car {
void fordMethod () {
}
}
We also have a breakingSystem() function which takes Car reference (Superclass reference) as an input parameter.
The method will invoke carMethod() regardless of the type of object (Car or Ford Reference) and if it is a Ford object, it will also invoke fordMethod(). We use the instanceof operator to determine the type of object at run time.
public void breakingSystem (Car obj) {
obj.carMethod();
if (obj instanceof Ford)
((Ford)obj).fordMethod ();
}
To invoke the fordMethod(), the operation (Ford)obj tells the compiler to treat the Car object referenced by obj as if it is a Ford object. Without the cast, the compiler will give an error message indicating that fordMethod() cannot be found in the Car definition.

The following program shown illustrates the use of the cast operator with references.
Note: Classes Honda and Ford are Siblings in the class Hierarchy. Both these classes are subclasses of Class Car. Both Car and HeavyVehicle Class extend Object Class. Any class that does not explicitly extend some other class will automatically extends the Object by default. This code instantiates an object of the class Ford and assigns the object’s reference to a reference variable of type Car. This assignment is allowed as Car is a superclass of Ford. In order to use a reference of a class type to invoke a method, the method must be defined at or above that class in the class hierarchy. Hence an object of Class Car cannot invoke a method present in Class Ford, since the method fordMethod is not present in Class Car or any of its superclasses. Hence this problem can be colved by a simple downcast by casting the Car object reference to the Ford Class Object reference as done in the program. Also an attempt to cast an object reference to its Sibling Object reference produces a ClassCastException at runtime, although compilation happens without any error.
 
class Car extends Object {
 
      void carMethod() {
      }
}
 
class HeavyVehicle extends Object {
}
 
class Ford extends Car {
 
      void fordMethod() {
            System.out.println("I am fordMethod defined in Class Ford");
      }
}
 
class Honda extends Car {
 
      void fordMethod() {
            System.out.println("I am fordMethod defined in Class Ford");
      }
}
 
public class ObjectCastingEx {
 
      public static void main(String[] args) {
            Car obj = new Ford();
            //    Following will result in compilation error
            //    obj.fordMethod(); //As the method fordMethod is undefined for the Car Type
            //  Following will result in compilation error
            // ((HeavyVehicle)obj).fordMethod();
                               //fordMethod is undefined in the HeavyVehicle Type
            //  Following will result in compilation error
            ((Ford) obj).fordMethod();
            //Following will compile and run
            //    Honda hondaObj = (Ford)obj;    Cannot convert as they are sibblings
      }
}
Download Object Reference Casting Source Code
One common casting that is performed when dealing with collections is, you can cast an object reference into a String.
import java.util.Vector;
 
public class StringCastDemo {
 
        public static void main(String args[]) {
               String username = "asdf";
               String password = "qwer";
               Vector v = new Vector();
               v.add(username);
               v.add(password);
               //               String u = v.elementAt(0); Cannot convert from object to String
               Object u = v.elementAt(0); //Cast not done
               System.out.println("Username : " + u);
               String uname = (String) v.elementAt(0); // cast allowed
               String pass = (String) v.elementAt(1); // cast allowed
               System.out.println();
               System.out.println("Username : " + uname);
               System.out.println("Password : " + pass);
        }
}

Download
Object String Casting Source Code
Output
Username : asdf
Username : asdf
Password : qwer

instanceof Operator

The instanceof operator is called the type comparison operator, lets you determine if an object belongs to a specific class, or implements a specific interface. It returns true if an object is an instance of the class or if the object implements the interface, otherwise it returns false.
Below is an example showing the use of instanceof operator
class Vehicle {
 
        String name;
        Vehicle() {
               name = "Vehicle";
        }
}
 
class HeavyVehicle extends Vehicle {
 
        HeavyVehicle() {
               name = "HeavyVehicle";
        }
}
 
class Truck extends HeavyVehicle {
 
        Truck() {
               name = "Truck";
        }
}
 
class LightVehicle extends Vehicle {
 
        LightVehicle() {
               name = "LightVehicle";
        }
}
 
public class InstanceOfExample {
 
        static boolean result;
        static HeavyVehicle hV = new HeavyVehicle();
        static Truck T = new Truck();
        static HeavyVehicle hv2 = null;
        public static void main(String[] args) {
               result = hV instanceof HeavyVehicle;
               System.out.print("hV is an HeavyVehicle: " + result + "\n");
               result = T instanceof HeavyVehicle;
               System.out.print("T is an HeavyVehicle: " + result + "\n");
               result = hV instanceof Truck;
               System.out.print("hV is a Truck: " + result + "\n");
               result = hv2 instanceof HeavyVehicle;
               System.out.print("hv2 is an HeavyVehicle: " + result + "\n");
               hV = T; //Sucessful Cast form child to parent
               T = (Truck) hV; //Sucessful Explicit Cast form parent to child
        }
}
Download instanceof operator Source Code
Output
hV is an HeavyVehicle: true
T is an HeavyVehicle: true
hV is a Truck: false
hv2 is an HeavyVehicle: false
Note: hv2 does not yet reference an HeavyVehicle object, instanceof returns false. Also we can’t use instanceof operator with siblings

Abstract Class in java

Java Abstract classes are used to declare common characteristics of subclasses. An abstract class cannot be instantiated. It can only be used as a superclass for other classes that extend the abstract class. Abstract classes are declared with the abstract keyword. Abstract classes are used to provide a template or design for concrete subclasses down the inheritance tree.
Like any other class, an abstract class can contain fields that describe the characteristics and methods that describe the actions that a class can perform. An abstract class can include methods that contain no implementation. These are called abstract methods. The abstract method declaration must then end with a semicolon rather than a block. If a class has any abstract methods, whether declared or inherited, the entire class must be declared abstract. Abstract methods are used to provide a template for the classes that inherit the abstract methods.
Abstract classes cannot be instantiated; they must be subclassed, and actual implementations must be provided for the abstract methods. Any implementation specified can, of course, be overridden by additional subclasses. An object must have an implementation for all of its methods. You need to create a subclass that provides an implementation for the abstract method.
A class abstract Vehicle might be specified as abstract to represent the general abstraction of a vehicle, as creating instances of the class would not be meaningful.
&lt;br /&gt;&lt;font size=-1&gt;
abstract class Vehicle {
 
      int numofGears;
      String color;
      abstract boolean hasDiskBrake();
      abstract int getNoofGears();
}
Example of a shape class as an abstract class
abstract class Shape {
 
      public String color;
      public Shape() {
      }
      public void setColor(String c) {
            color = c;
      }
      public String getColor() {
            return color;
      }
      abstract public double area();
}
We can also implement the generic shapes class as an abstract class so that we can draw lines, circles, triangles etc. All shapes have some common fields and methods, but each can, of course, add more fields and methods. The abstract class guarantees that each shape will have the same set of basic properties. We declare this class abstract because there is no such thing as a generic shape. There can only be concrete shapes such as squares, circles, triangles etc.
public class Point extends Shape {
 
        static int x, y;
        public Point() {
               x = 0;
               y = 0;
        }
        public double area() {
               return 0;
        }
        public double perimeter() {
               return 0;
        }
        public static void print() {
               System.out.println("point: " + x + "," + y);
        }
        public static void main(String args[]) {
               Point p = new Point();
               p.print();
        }
}
Output
point: 0, 0
Notice that, in order to create a Point object, its class cannot be abstract. This means that all of the abstract methods of the Shape class must be implemented by the Point class.
The subclass must define an implementation for every abstract method of the abstract superclass, or the subclass itself will also be abstract. Similarly other shape objects can be created using the generic Shape Abstract class.
A big Disadvantage of using abstract classes is not able to use multiple inheritance. In the sense, when a class extends an abstract class, it can’t extend any other class.
Post a Comment