Module 3 - Chapter 4: Interfaces and Abstract Classes in C#

Interfaces and Abstract Classes in C#

Interfaces

Defining and Implementing an Interface

public interface IAnimal
{
    void Eat();
    void Sleep();
}

public class Dog : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("Dog is eating.");
    }

    public void Sleep()
    {
        Console.WriteLine("Dog is sleeping.");
    }
}

Key Points About Interfaces

• A class can implement multiple interfaces, enabling a form of multiple inheritance.

• Interfaces can contain methods, properties, events, and indexers, but no fields (variables).

• All members of an interface are implicitly public, and they cannot include access modifiers.

• Interfaces support polymorphism, allowing objects to be treated as instances of their interface types rather than their concrete types.

Abstract Classes

Defining an Abstract Class

public abstract class Animal
{
    public abstract void Eat();

    public void Sleep()
    {
        Console.WriteLine("Animal is sleeping.");
    }
}

public class Cat : Animal
{
    public override void Eat()
    {
        Console.WriteLine("Cat is eating.");
    }
}

Key Points About Abstract Classes

• Abstract classes cannot be instantiated directly.

• A class can inherit from only one abstract class, following C#'s single inheritance model for classes.

• Abstract classes can provide some default behavior and force derived classes to implement specific methods.

• Abstract classes are suitable when there is a tight relationship between the abstract class and its subclasses.

Interfaces vs. Abstract Classes

• Use an interface when you want to define a contract for functionalities that can be implemented by multiple unrelated classes. Interfaces are ideal for representing capabilities or types that can be added to classes in a flexible manner.

• Use an abstract class when creating a closely related family of classes that share common behavior or require a common point of inheritance. Abstract classes are also useful when you need to provide some shared implementation to derived classes.

Summary