Interfaces
Basics of Interfaces
- Definition: Interfaces are defined using the ‘interface’ keyword. They can include method signatures, properties, events, and indexers.
- Implementation: Classes or structs that implement an interface must provide an implementation for all of its members.
- Multiple Inheritance: A class can implement multiple interfaces, enabling more flexible and modular designs.
Example
using System;
// Define an interface
interface IAnimal
{
// Interface members
string Name { get; set; }
void Speak();
}
// Implement the interface in the Dog class
class Dog : IAnimal
{
// Property implementation
public string Name { get; set; }
// Constructor
public Dog(string name)
{
Name = name;
}
// Method implementation
public void Speak()
{
Console.WriteLine($"{Name} says: Woof!");
}
}
// Implement the interface in the Cat class
class Cat : IAnimal
{
// Property implementation
public string Name { get; set; }
// Constructor
public Cat(string name)
{
Name = name;
}
// Method implementation
public void Speak()
{
Console.WriteLine($"{Name} says: Meow!");
}
}
class Program
{
static void Main()
{
// Create instances of Dog and Cat
IAnimal myDog = new Dog("Buddy");
IAnimal myCat = new Cat("Whiskers");
// Call the Speak method
myDog.Speak(); // Outputs: Buddy says: Woof!
myCat.Speak(); // Outputs: Whiskers says: Meow!
}
}
Explanation of the Example
- Interface Definition (IAnimal):
- The IAnimal interface defines two members: a Name property and a Speak method.
- These members do not have any implementation; they just specify what any class implementing the interface must provide.
- Class Implementation (Dog and Cat):
- Both Dog and Cat classes implement the IAnimal interface.
- Each class provides its own implementation for the Name property and the Speak method.
- The Speak method in the Dog class prints a message indicating that the dog barks, while the Speak method in the Cat class prints a message indicating that the cat meows.
- Main Method:
- We create instances of Dog and Cat and assign them to variables of type IAnimal.
- We call the Speak method on these instances, demonstrating that each class provides its own implementation.
Benefits of Using Interfaces
Abstraction: Interfaces allow you to define a contract that specifies what a class must accomplish without detailing how it should achieve those goals. This promotes a clear separation of concerns and facilitates abstraction in your code.
Multiple Inheritance: C# does not support multiple inheritance for classes; however, a class can implement multiple interfaces. This feature enables more flexible and modular designs.
Decoupling: Interfaces contribute to decoupling your code, making it more modular and easier to maintain. You can change the implementation of an interface without impacting the code that relies on it.
Polymorphism: Interfaces facilitate polymorphic behavior. Different classes can implement the same interface in various ways, allowing you to treat objects of these classes as instances of the interface type.