Last updated on Nov 15, 2024

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

If you want to write clean and maintainable code, you need to understand how to use interfaces and abstract classes for flexible type safety. These are two key concepts in object oriented design that help you create modular and reusable software components. In this article, you will learn the differences between interfaces and abstract classes, how to use them to define common behaviors and contracts, and how to leverage polymorphism and inheritance to achieve 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.

Add your perspective

Abel Hailu

Software Engineer | Java Spring Boot | Microservices | React | Building Scalable Systems
Report contribution
In object-oriented programming, interfaces define what methods a class should implement without specifying how. They act as blueprints for behavior. Abstract classes, on the other hand, are partially implemented classes that cannot be instantiated on their own. They contain both concrete and abstract methods, offering a template for subclasses to inherit and extend. Interfaces emphasize capability definitions, while abstract classes provide a mix of implemented and unimplemented methods for subclass customization.

Like
Dhruv Mittal

CEO & Director at Syscon Wires | Leading Manufacturer of CHQ Wires, Alloy Steel Wires & Specialty Wires for Fasteners, Bearings & Automotive Applications |
Report contribution
Interfaces define a contract that classes must adhere to, specifying methods that must be implemented without providing method bodies. They allow different classes to guarantee they provide certain functionality, promoting loose coupling and flexibility. Abstract classes are classes that cannot be instantiated and may contain both abstract methods (without implementation) and concrete methods (with implementation). They provide a partial implementation that other classes can extend. Abstract classes allow sharing common code among subclasses while enforcing certain methods to be overridden.

Like
Paulo Zëmek

Software Engineer - I used talk to computers and they understood me even without AI, we just spoke the same language... now that they got smarter we are so in-sync that sometimes it feels we talk to each-other mentally!
Report contribution
Saying that "they cannot be instantiated directly" says nothing to somebody that doesn't know object oriented principles already.

Like

2 Why use interfaces and abstract classes?

One of the main benefits of using interfaces and abstract classes is that they enable flexible type safety. This means that you can use them as reference types to store and manipulate objects of different concrete classes, as long as they implement the same interface or inherit from the same abstract class. This way, you can write code that works with any object that satisfies the interface or abstract class contract, without knowing or caring about its specific class. This makes your code more modular, extensible, and adaptable to changing requirements.

Add your perspective

Gaurav Arora

SDE-2 DigitalOcean | 3 X INSTA AWARD WINNER AT HT | Meta Hackercup AIR-51 2022 | System Design and DSA ❤️
Report contribution
Loose coupling is one of the primary reasons to use interfaces or abstract classes. Loosely coupled classes are easier to test and debug, offering high flexibility. Additional benefits include reducing code redundancy, enhancing extensibility, and simplifying the testing of extended parts. By defining clear contracts and separating concerns, interfaces and abstract classes enable more modular and maintainable code.

Like
Dhruv Mittal

CEO & Director at Syscon Wires | Leading Manufacturer of CHQ Wires, Alloy Steel Wires & Specialty Wires for Fasteners, Bearings & Automotive Applications |
Report contribution
Interfaces provide a way to define a common protocol for unrelated classes, ensuring they implement specific methods, facilitating polymorphism, and allowing for multiple inheritance of types. Abstract classes allow for code reuse by providing shared functionality while forcing subclasses to implement specific methods. They help in defining a common base with some implemented methods, reducing redundancy and promoting a clear hierarchy in object-oriented design.

Like

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.

Add your perspective

Dhruv Mittal

CEO & Director at Syscon Wires | Leading Manufacturer of CHQ Wires, Alloy Steel Wires & Specialty Wires for Fasteners, Bearings & Automotive Applications |
Report contribution
Define an interface using the interface keyword and specify the methods that must be implemented: from abc import ABC, abstractmethod class Flyable(ABC): @abstractmethod def fly(self): pass class Bird(Flyable): def fly(self): print("Flies in the sky") Classes implementing the interface must provide concrete implementations for all its methods, ensuring consistent behavior across different classes.

Like

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.

Add your perspective

Dhruv Mittal

CEO & Director at Syscon Wires | Leading Manufacturer of CHQ Wires, Alloy Steel Wires & Specialty Wires for Fasteners, Bearings & Automotive Applications |
Report contribution
Define an abstract class using the ABC module and include abstract methods that subclasses must implement: from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def make_sound(self): pass def sleep(self): print("Sleeping...") class Dog(Animal): def make_sound(self): print("Barks") # Dog can use sleep method from Animal and must implement make_sound Abstract classes can provide default behavior and enforce method implementation in subclasses, supporting code reuse and polymorphism.

Like

5 How to choose between interfaces and abstract classes?

When deciding whether to use an interface or an abstract class, it depends on the design goals and requirements of your software. Generally, interfaces are used when you want to define a common behavior or contract for a group of unrelated or loosely related classes without needing to provide any default or partial implementation. On the other hand, abstract classes are used when you want to define a common behavior or contract for a group of closely related classes while providing some default or partial implementation that can be reused or modified by the subclasses. Additionally, you can combine both approaches when you want to separate the abstraction from the implementation. For example, you can use an interface to define a common functionality for different types of vehicles and then use an abstract class to implement some of the methods of the interface, providing some default or partial implementation that can be reused or modified by the subclasses.

Add your perspective

Gaurav Arora

SDE-2 DigitalOcean | 3 X INSTA AWARD WINNER AT HT | Meta Hackercup AIR-51 2022 | System Design and DSA ❤️
(edited)
Report contribution
Deciding between abstract class and interface is generally pretty straight-forward and it goes like this- If there is a method in the class that is going to be consistent between all concrete classes then it's better to go with an abstract class , however you may want to think ahead and make sure that no matter which concrete class is added in the future, this method would have the same behavior throughout. If you see no such method, then interface is the way to go. However deciding between the two could get a little tricky sometimes, in those cases i always feel it's better to go with an abstract class .Since you would have an extra flexibility to initialise a non-abstract method (method without an empty body).

Like
Dhruv Mittal

CEO & Director at Syscon Wires | Leading Manufacturer of CHQ Wires, Alloy Steel Wires & Specialty Wires for Fasteners, Bearings & Automotive Applications |
Report contribution
Choose interfaces when you need to define a common protocol for disparate classes or require multiple inheritance of behavior. Interfaces are ideal for scenarios where multiple unrelated classes need to conform to a set of methods without inheriting shared code. Choose abstract classes when you need a common base with shared code and want to define a clear hierarchical structure. Use abstract classes if you need to provide default behavior or when classes share a common ancestor that requires some implemented functionality. The choice depends on whether you prioritize shared implementation (abstract classes) or flexible, contract-based design (interfaces).

Like
Binu Manuel

Senior Technical Consultant Specializing in .NET Frameworks & Web Applications Development | Problem-Solver in .NET Technologies | Driving Efficiency in Web & Windows Applications
Report contribution
Interfaces and abstract classes are used based on application requirements. Use interfaces to define contracts between different classes, ensuring they implement specific methods. Abstract classes are ideal for sharing common features and methods in a base class. For multiple inheritance and code reusability, interfaces are the way to go, as they support multiple inheritance, unlike abstract classes which support only single inheritance. The choice between them depends on the specific requirements and design of your application.

Like

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?

Add your perspective

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

1

2

3

4

5

6

1 What are interfaces and abstract classes?

2 Why use interfaces and abstract classes?

3 How to use interfaces?

4 How to use abstract classes?

5 How to choose between interfaces and abstract classes?

6 Here’s what else to consider

Object Oriented Design

Rate this article

Thanks for your feedback

More articles on Object Oriented Design

More relevant reading