Introduction to Interfaces

Welcome to the first lesson in Advanced Programming Concepts! In this lesson, you’ll learn about interfaces, their purpose, and how to use them to achieve abstraction and flexibility in your C# programs. Let’s get started!

What is an Interface?

An interface is a contract that defines a set of methods and properties that a class must implement. It provides no implementation itself but ensures that any class implementing the interface adheres to a specific design.

Example: An interface for a "Vehicle" might define methods like Start() and Stop(), which all vehicles must implement.

Key Point: Interfaces enable you to design flexible and reusable code by separating behavior from implementation.

Defining an Interface

To define an interface in C#, use the interface keyword. Example:

Tip: By convention, interface names in C# begin with the letter I.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

Implementing an Interface

To implement an interface, a class must define all the methods and properties declared in the interface. Example:

Key Point: A class can implement multiple interfaces to support multiple behaviors.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

class Car : IVehicle {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }
}

class Program {
    static void Main() {
        IVehicle myCar = new Car();
        myCar.Start();
        myCar.Stop();
    }
}

Why Use Interfaces?

Interfaces provide several advantages:

• Abstraction: Define behavior without specifying implementation.
• Flexibility: A class can implement multiple interfaces, allowing it to support multiple roles.
• Consistency: Enforce a common structure across related classes.

Tip: Use interfaces when you want to define a shared contract without dictating how it should be fulfilled.

Combining Multiple Interfaces

A class can implement multiple interfaces to combine different sets of behavior. Example:

using System;

interface IVehicle {
    void Start();
    void Stop();
}

interface IRadio {
    void PlayMusic();
}

class Car : IVehicle, IRadio {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }

    public void PlayMusic() {
        Console.WriteLine("Playing music.");
    }
}

class Program {
    static void Main() {
        Car myCar = new Car();
        myCar.Start();
        myCar.PlayMusic();
        myCar.Stop();
    }
}

Practice Challenge

Create an interface IShape with a method CalculateArea(). Implement this interface in classes Rectangle and Circle. Example:

using System;

interface IShape {
    double CalculateArea();
}

class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }

    public double CalculateArea() {
        return Width * Height;
    }
}

class Circle : IShape {
    public double Radius { get; set; }

    public double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

class Program {
    static void Main() {
        IShape rectangle = new Rectangle { Width = 5, Height = 4 };
        IShape circle = new Circle { Radius = 3 };

        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
        Console.WriteLine("Circle Area: " + circle.CalculateArea());
    }
}

Best Practices for Using Interfaces

Here are some best practices:

• Use interfaces to define contracts that classes must follow.
• Prefer interfaces over inheritance for unrelated classes that share common behavior.
• Keep interfaces focused and avoid including unnecessary methods or properties.

Tip: Interfaces should describe what a class does, not how it does it.

Great Job!

Congratulations! You’ve learned the basics of interfaces and how to use them to achieve abstraction and flexibility in your programs. In the next lesson, we’ll dive into abstract classes and learn how they differ from interfaces. Let’s keep coding!