How do you use interfaces and abstract classes for flexible type safety?

1 What are interfaces and abstract classes?

Interfaces and abstract classes are both types of abstract types, which means they cannot be instantiated directly. They are used to define the common features and behaviors of a group of related classes, without specifying the implementation details. Interfaces are like contracts that specify what methods a class must implement, but not how. Abstract classes are like templates that provide some default or partial implementation of methods, but leave some abstract methods for the subclasses to override.

3 How to use interfaces?

To use interfaces, you need to declare them using the keyword interface, followed by the name of the interface and the methods it defines. For example, you can define an interface called Animal that has a method called makeSound:

interface Animal {
  void makeSound();
}        

Then, you can implement this interface in any class that represents an animal, such as Dog, Cat, or Bird, by using the keyword implements, followed by the name of the interface. For example, you can implement the Animal interface in the Dog class and provide the implementation of the makeSound method:

class Dog implements Animal {
  @Override
  public void makeSound() {
    System.out.println("Woof!");
  }
}        

Now, you can use the Animal interface as a reference type to store and manipulate objects of any class that implements it, such as Dog, Cat, or Bird. For example, you can create an array of Animal objects and iterate over them, calling the makeSound method on each one:

Animal[] animals = {new Dog(), new Cat(), new Bird()};
for (Animal animal : animals) {
  animal.makeSound();
}        

This will print out "Woof!", "Meow!", and "Tweet!" respectively, depending on the actual class of each object.

4 How to use abstract classes?

To use abstract classes, you need to declare them using the keyword abstract, followed by the name of the abstract class and the methods it defines. Some of these methods can be abstract, which means they have no implementation and must be overridden by the subclasses. Some of these methods can be concrete, which means they have a default or partial implementation that can be reused or modified by the subclasses. For example, you can define an abstract class called Shape that has an abstract method called getArea and a concrete method called printArea:

abstract class Shape {
  abstract double getArea();
  public void printArea() {
    System.out.println("The area is "   getArea());
  }
}        

Then, you can inherit from this abstract class in any class that represents a shape, such as Circle, Square, or Triangle, by using the keyword extends, followed by the name of the abstract class. For example, you can inherit from the Shape class in the Circle class and provide the implementation of the getArea method:

class Circle extends Shape {
  private double radius;
  public Circle(double radius) {
    this.radius = radius;
  }
  @Override
  double getArea() {
    return Math.PI * radius * radius;
  }
}        

Now, you can use the Shape abstract class as a reference type to store and manipulate objects of any class that inherits from it, such as Circle, Square, or Triangle. For example, you can create an array of Shape objects and iterate over them, calling the printArea method on each one:

Shape[] shapes = {new Circle(2), new Square(3), new Triangle(4, 5, 6)};
for (Shape shape : shapes) {
  shape.printArea();
}        

This will print out the area of each shape, depending on the actual class and parameters of each object.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?