Interface and abstract class

How to decide when to use Interface and abstract class

The choice between using an interface and an abstract class in your code depends on the specific requirements and design goals of your application. Here are some guidelines to help you decide when to use each:

1. Interfaces:

   - Multiple Inheritance: In languages that support multiple inheritance (like Java and C#), you can implement multiple interfaces in a class, allowing you to inherit behaviors from multiple sources.

   - Contract-based: Use interfaces when you want to define a contract that multiple unrelated classes should adhere to. Interfaces specify what methods or properties a class must implement, but they don't provide any default implementation.

   - Polymorphism: When you want to enable polymorphism, interfaces are often preferred. You can use interfaces to create collections of objects that share a common behavior, regardless of their concrete types.

   - Lightweight: Interfaces are lightweight and don't add any implementation details, making them suitable for cases where you want to ensure consistency in method signatures across classes.

2. Abstract Classes:

   - Common Implementation: Use abstract classes when you have a base class that provides a common implementation for some methods but leaves others to be implemented by derived classes. Abstract classes can have both abstract (unimplemented) and concrete (implemented) methods.

   - Code Reuse: Abstract classes are a good choice when you want to share code and data members among related classes. Subclasses can inherit the shared implementation.

   - Extensibility: Abstract classes are helpful when you want to provide a skeletal structure for a class hierarchy, allowing derived classes to extend and override methods as needed.

   - Partial Abstraction: If you have a class that can be partially implemented but still makes sense to be instantiated (with concrete methods), an abstract class can serve this purpose.

Interfaces are suitable for defining contracts and enabling polymorphism, while abstract classes are useful for sharing common implementation among related classes and providing a base for inheritance hierarchies. 

Why abstract class cannot be instantiated?

An abstract class cannot be instantiated because it is designed to serve as a blueprint or template for other classes, rather than as a class that can be used on its own. 

Here's why abstract classes cannot be instantiated:

1. Incomplete Implementation: Abstract classes typically contain one or more abstract (unimplemented) methods. These abstract methods are meant to be overridden by concrete (sub)classes that derive from the abstract class. Since the abstract class itself does not provide complete implementations for these methods, it cannot be used directly.

2. Intended for Inheritance: Abstract classes are designed to be extended by other classes. They provide a common structure and potentially shared implementation details that subclasses can build upon. Instantiating an abstract class would not make sense because it would lack the necessary implementation for its methods, making it incomplete and nonfunctional.

3. Enforces Abstraction: Abstract classes are used to enforce abstraction and to define a contract that derived classes must follow. By preventing instantiation, they ensure that any concrete instances adhere to the contract by providing implementations for all abstract methods.

Code example:

abstract class Animal {

    abstract void makeSound();

}

class Dog extends Animal {

    void makeSound() {

        System.out.println("Woof!");

    }

}

public class Main {

    public static void main(String[] args) {

        // You can't do this: Animal animal = new Animal();

        // Instead, you create instances of concrete subclasses like Dog.

        Animal dog = new Dog();

        dog.makeSound(); // Outputs "Woof!"

    }

}

In the example above, you cannot create an instance of the abstract class `Animal`, but you can create instances of its concrete subclass `Dog`, which provides an implementation for the `makeSound` method.

Abstract classes are a fundamental concept in object-oriented programming that helps ensure a consistent structure and behavior in a class hierarchy while allowing for customization through subclassing.

Partial abstraction in programming refers to a situation where a class provides some concrete (implemented) methods while leaving others as abstract (unimplemented). This allows you to create a base class that can be instantiated, but it also enforces that specific methods are implemented by subclasses

Example of partial abstraction in C#:

using System;

// Define an abstract base class with a mix of concrete and abstract methods

abstract class Shape

{

    public string Name { get; set; }

    public Shape(string name)

    {

        Name = name;

    }

    public void DisplayInfo()

    {

        Console.WriteLine($"Shape: {Name}");

    }

    public abstract double CalculateArea();

}

// Create a concrete subclass of Shape

class Circle : Shape

{

    public double Radius { get; set; }

    public Circle(string name, double radius) : base(name)

    {

        Radius = radius;

    }

    public override double CalculateArea()

    {

        return Math.PI * Radius * Radius;

    }

}

// Create another concrete subclass of Shape

class Rectangle : Shape

{

    public double Width { get; set; }

    public double Height { get; set; }

    public Rectangle(string name, double width, double height) : base(name)

    {

        Width = width;

        Height = height;

    }

    public override double CalculateArea()

    {

        return Width * Height;

    }

}

class Program

{

    static void Main(string[] args)

    {

        // Instantiate objects of the concrete subclasses

        Circle circle = new Circle("Circle 1", 5);

        Rectangle rectangle = new Rectangle("Rectangle 1", 4, 6);

        // Access methods and properties from the base class and subclasses

        circle.DisplayInfo(); // Output: Shape: Circle 1

        Console.WriteLine($"Area: {circle.CalculateArea()}"); // Output: Area: 78.53981633974483

        rectangle.DisplayInfo(); // Output: Shape: Rectangle 1

        Console.WriteLine($"Area: {rectangle.CalculateArea()}"); // Output: Area: 24

    }

}

In this C# example:

- `Shape` is an abstract base class with an abstract method `CalculateArea()`, a concrete property `Name`, and a concrete method `DisplayInfo()`.

- `Circle` and `Rectangle` are concrete subclasses of `Shape`. They provide concrete implementations for the `CalculateArea()` method while inheriting the `Name` property and `DisplayInfo()` method from the base class.

- Objects of `Circle` and `Rectangle` are instantiated, and you can access methods and properties from both the base class and the subclasses, demonstrating partial abstraction.