What are the key differences between an abstract class and an interface in object-oriented programming?

During a group project in my software engineering class, we were tasked with developing a simple game. I took the lead in designing the game structure. I proposed using an abstract class for the main character, which included shared attributes like health and methods like attack and defend. This allowed us to create specific character types, like 'Warrior' and 'Mage', that inherited from the abstract class. We also utilized interfaces for gameplay elements, such as 'IPlayable' and 'IControllable', which defined methods for player actions. This experience taught me the importance of using an abstract class for shared behavior and interfaces for defining contracts, ultimately streamlining our development process.

While volunteering for a local non-profit, I was part of a team organizing community events. We needed a clear structure for our event management system. I suggested we create an abstract class to handle shared event details, such as date and location, as well as common methods like 'scheduleEvent()'. Meanwhile, we defined an interface for different event types, like 'ICharityEvent' and 'IFundraiserEvent', to ensure each event type implemented their unique requirements. This approach helped us ensure consistency across different event types while allowing flexibility for specific details, demonstrating how abstract classes and interfaces can work together in project implementation.

In my first job as a junior developer, I worked on a team developing a web application. We used an abstract class for our base API handler that included common methods for making requests and handling responses. This allowed us to create specialized handlers for different APIs, such as 'UserAPIHandler' and 'ProductAPIHandler', inheriting the shared functionality. At the same time, we defined an interface for logging, ensuring that all components of the application implemented a 'Logger' interface with methods for logging errors and events. This experience reinforced the importance of using abstract classes for shared functionality and interfaces for ensuring consistent behavior across different components.