Java instanceOf() Generics

In Java, generics are majorly used for providing a method for the creation of classes and methods which are capable of working with any type of data including the type safety.

When generics are utilized in Java, the type of an object is often checked during the runtime execution. This is the main purpose of the instanceOf() operator in Java. Let's understand about this in detail with the help of few example programs.

Java instanceOf()

The main purpose of the instanceOf() operator in Java is to check whether an object is the instance of a specific type or not. In Java, type erasure can be defined as a process which is used for removing the information during the compilation and making it unavailable during the runtime execution.

The usage of instanceOf() method in Java must be followed by caution as it might indicate that the code has not been fully taken advantage of the type information that is provided by generics. In various cases, the preferable designed classes and methods are made in such way that they allow us to directly work with the types of generics.

Let us understand about instanceOf() operation in Java in detail with the help of Java example programs.

Example 1:

Filename: Zoo.java

// Java program for demonstrating the features and functionalities of instanceOf() operator in Java
import java.util.ArrayList;
// Defining an interface for animals
interface Animal {
    void makeSound();
}
// Creation of a base class for mammals
class Mammal implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Some generic mammal sound");
    }
    void giveBirth() {
        System.out.println("Giving birth to live young");
    }
}
// Implementatoin of classes for specific types of mammals
class Dog extends Mammal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
    void fetch() {
        System.out.println("Fetching the ball");
    }
}
class Cat extends Mammal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
    void purr() {
        System.out.println("Purring contentedly");
    }
}
// Creation of a base class for birds
class Bird implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Some generic bird sound");
    }
    void layEggs() {
        System.out.println("Laying eggs");
    }
}
// Implementation classes for specific types of birds
class Parrot extends Bird {
    @Override
    public void makeSound() {
        System.out.println("Squawk! Squawk!");
    }
    void mimicSpeech() {
        System.out.println("Mimicking human speech");
    }
}
// Creation of a base class for reptiles
class Reptile implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Some generic reptile sound");
    }
    void layEggs() {
        System.out.println("Laying eggs");
    }
}
// Implementation of classes for specific types of reptiles
class Snake extends Reptile {
    @Override
    public void makeSound() {
        System.out.println("Hiss!");
    }
    void slither() {
        System.out.println("Slithering on the ground");
    }
}
public class Zoo {
    public static void main(String[] args) {
        // Create an ArrayList with generics to store various animals
        ArrayList<Animal> zooAnimals = new ArrayList<>();
        zooAnimals.add(new Dog());
        zooAnimals.add(new Cat());
        zooAnimals.add(new Parrot());
        zooAnimals.add(new Snake());
        // Iterate through the list and perform actions based on the type of each animal
        for (Animal animal : zooAnimals) {
            System.out.println("--------");
            if (animal instanceof Dog) {
                System.out.println("It's a Dog!");
                ((Dog) animal).fetch(); // Accessing Dog-specific method
            } else if (animal instanceof Cat) {
                System.out.println("It's a Cat!");
                ((Cat) animal).purr(); // Accessing Cat-specific method
            } else if (animal instanceof Parrot) {
                System.out.println("It's a Parrot!");
                ((Parrot) animal).mimicSpeech(); // Accessing Parrot-specific method
            } else if (animal instanceof Snake) {
                System.out.println("It's a Snake!");
                ((Snake) animal).slither(); // Accessing Snake-specific method
            }
            // Common method for all animals
            animal.makeSound();
        }
    }
}

Output:

--------
It's a Dog!
Fetching the ball
Woof! Woof!
--------
It's a Cat!
Purring contentedly
Meow!
--------
It's a Parrot!
Mimicking human speech
Squawk! Squawk!
--------
It's a Snake!
Slithering on the ground
Hiss!

Example 2:

Filename: Shape.java

// Java program to demonstrate the features and functionalities of instanceOf() operator in Java.
import java.util.ArrayList;
// Defining an interface for shapes
interface Shape {
    double calculateArea();
}
// Creating an abstract class for 3D shapes
abstract class ThreeDimensionalShape implements Shape {
    abstract double calculateVolume();
}
// Implementing classes for specific types of 2D shapes
class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    void displayInfo() {
        System.out.println("Circle with radius: " + radius);
    }
}
class Rectangle implements Shape {
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    public double calculateArea() {
        return length * width;
    }
    void displayInfo() {
        System.out.println("Rectangle with length: " + length + " and width: " + width);
    }
}
class Triangle implements Shape {
    private double base;
    private double height;
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return 0.5 * base * height;
    }
    void displayInfo() {
        System.out.println("Triangle with base: " + base + " and height: " + height);
    }
}
// Implementing classes for specific types of 3D shapes
class Sphere extends ThreeDimensionalShape {
    private double radius;
    public Sphere(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return 4 * Math.PI * radius * radius;
    }
    @Override
    double calculateVolume() {
        return (4.0 / 3.0) * Math.PI * radius * radius * radius;
    }
    void displayInfo() {
        System.out.println("Sphere with radius: " + radius);
    }
}
class Cube extends ThreeDimensionalShape {
    private double sideLength;
    public Cube(double sideLength) {
        this.sideLength = sideLength;
    }
    @Override
    public double calculateArea() {
        return 6 * sideLength * sideLength;
    }
    @Override
    double calculateVolume() {
        return sideLength * sideLength * sideLength;
    }
    void displayInfo() {
        System.out.println("Cube with side length: " + sideLength);
    }
}
public class Shape {
    public static void main(String[] args) {
        // Creating an ArrayList with generics to store various shapes
        ArrayList<Shape> allShapes = new ArrayList<>();
        allShapes.add(new Circle(5.0));
        allShapes.add(new Rectangle(4.0, 6.0));
        allShapes.add(new Triangle(3.0, 8.0));
        allShapes.add(new Sphere(3.0));
        allShapes.add(new Cube(4.0));
        // Iterating through the list and perform actions based on the type of each shape
        for (Shape shape : allShapes) {
            System.out.println("--------");
            if (shape instanceof Circle) {
                System.out.println("It's a Circle!");
                ((Circle) shape).displayInfo(); // Accessing Circle-specific method
            } else if (shape instanceof Rectangle) {
                System.out.println("It's a Rectangle!");
                ((Rectangle) shape).displayInfo(); // Accessing Rectangle-specific method
            } else if (shape instanceof Triangle) {
                System.out.println("It's a Triangle!");
                ((Triangle) shape).displayInfo(); // Accessing Triangle-specific method
            } else if (shape instanceof ThreeDimensionalShape) {
                // Check if the shape is 3D and, if so, invoke 3D shape-specific method
                System.out.println("It's a Three-Dimensional Shape!");
                ((ThreeDimensionalShape) shape).calculateVolume();
            }
            // Common method for all shapes
            System.out.println("Area: " + shape.calculateArea());
        }
    }
}

Output:

--------
It's a Circle!
Circle with radius: 5.0
Area: 78.53981633974483
--------
It's a Rectangle!
Rectangle with length: 4.0 and width: 6.0
Area: 24.0
--------
It's a Triangle!
Triangle with base: 3.0 and height: 8.0
Area: 12.0
--------
It's a Three-Dimensional Shape!
Area: 113.09733552923255
--------
It's a Three-Dimensional Shape!
Area: 96.0

This is the required explanation about the instanceOf() generics operator in Java.

Next TopicSet Precision in Java

← prev next →