What is the difference between an interface and an abstract class in object-oriented programming?

During my final year in college, I worked on a group project that involved creating a simulation of a zoo management system. We needed to define various animal types, and I suggested using interfaces for common behaviors like 'MakeSound()' and 'Eat()'. This allowed us to ensure that every animal class, such as 'Lion' and 'Elephant', implemented these methods. On the other hand, we used an abstract class called 'Animal' to define properties like 'Age' and 'Weight', along with some shared methods like 'Sleep()' which had a default implementation. This experience taught me the importance of using interfaces for defining contracts and abstract classes for shared logic, making our code cleaner and more maintainable.

While volunteering for a local non-profit, I helped design a simple event management system. We needed to handle different types of events, such as workshops and fundraisers. I proposed creating an interface called 'Event' that mandated the implementation of methods like 'Schedule()' and 'Promote()'. This ensured that all event types adhered to a consistent structure. We also created an abstract class called 'BaseEvent' that included properties like 'Date' and 'Location', along with a method for 'SendNotifications()' that we could use for all event types. This hands-on experience helped me appreciate how interfaces and abstract classes work together to create flexible and reusable code.

In my first job as a junior developer, I was tasked with enhancing a legacy application that tracked employee performance. I encountered an existing structure using abstract classes to manage different employee types, like 'FullTime' and 'PartTime'. I realized we could benefit from interfaces to define roles, such as 'Manager' and 'TeamLead', which required specific behaviors like 'ConductMeeting()'. This led to a clearer separation of responsibilities and allowed us to introduce new employee roles without altering existing code. My experience reinforced the importance of utilizing both interfaces and abstract classes effectively to improve code organization and functionality.