What are differences among Interface, Abstract Class and Class? Hints: Use case Syntax and code example

Sure! Here are the step-by-step explanations of the differences among Interface, Abstract Class, and Class:

1. Class:

   • A class is a blueprint for creating objects in object-oriented programming.
   • It can have both data members (variables) and member functions (methods).
   • It can be instantiated to create objects.
   • It can provide default implementations for its methods.

   Example code:

   class Car:
       def __init__(self, brand, model):
           self.brand = brand
           self.model = model
   
       def start_engine(self):
           print("Engine started.")
   
   my_car = Car("Toyota", "Camry")
   my_car.start_engine()
   

2. Abstract Class:

   • An abstract class is a class that cannot be instantiated.
   • It is meant to be subclassed by other classes.
   • It can have both abstract methods (methods without implementation) and concrete methods (methods with implementation).
   • Subclasses of an abstract class must provide implementations for all the abstract methods.

   Example code:

   from abc import ABC, abstractmethod
   
   class Shape(ABC):
       @abstractmethod
       def calculate_area(self):
           pass
   
   class Rectangle(Shape):
       def __init__(self, length, width):
           self.length = length
           self.width = width
   
       def calculate_area(self):
           return self.length * self.width
   
   my_rectangle = Rectangle(5, 3)
   print(my_rectangle.calculate_area())
   

3. Interface:

   • An interface is a collection of abstract methods.
   • It cannot have any concrete methods or data members.
   • It defines a contract that the implementing classes must adhere to.
   • Implementing classes must provide implementations for all the methods defined in the interface.

   Example code:

   public interface Animal {
       void eat();
       void sleep();
   }
   
   public class Dog implements Animal {
       public void eat() {
           System.out.println("Dog is eating.");
       }
   
       public void sleep() {
           System.out.println("Dog is sleeping.");
       }
   }
   
   Animal my_dog = new Dog();
   my_dog.eat();
   

I hope this helps clarify the differences among Interface, Abstract Class, and Class! Let me know if you have any further questions.