The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Abstraction

Next ►
►

Introduction to Abstraction

Abstraction is one of the four fundamental principles of Object-Oriented Programming (OOP), alongside encapsulation, inheritance, and polymorphism. It allows you to hide the complex implementation details of a system and expose only the necessary parts to the user. This makes the system easier to understand and use.

Key Concepts of Abstraction

  1. Simplification: Abstraction simplifies complex systems by breaking them down into more manageable parts.
  2. Hiding Implementation Details: Only the essential features are shown to the user, while the internal workings are hidden.
  3. Interfaces and Abstract Classes: These are the primary tools used to achieve abstraction in C#.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own and is meant to be inherited by other classes. It can contain abstract methods (methods without a body) that must be implemented by derived classes.

Syntax

public abstract class Animal
{
    public abstract void MakeSound(); // Abstract method
    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

Example

public abstract class Animal
{
    public abstract void MakeSound(); // Abstract method

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.MakeSound(); // Output: Bark
        myCat.MakeSound(); // Output: Meow

        myDog.Sleep(); // Output: Sleeping...
        myCat.Sleep(); // Output: Sleeping...
    }
}

Explanation

  • Abstract Class: Animal is an abstract class with an abstract method MakeSound and a concrete method Sleep.
  • Derived Classes: Dog and Cat are derived classes that implement the MakeSound method.
  • Instantiation: You cannot instantiate Animal directly, but you can instantiate Dog and Cat.

Interfaces

An interface is a contract that defines a set of methods and properties that a class must implement. Unlike abstract classes, interfaces cannot contain any implementation.

Syntax

public interface IAnimal
{
    void MakeSound(); // Method signature
}

Example

public interface IAnimal
{
    void MakeSound(); // Method signature
}

public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

public class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}

class Program
{
    static void Main(string[] args)
    {
        IAnimal myDog = new Dog();
        IAnimal myCat = new Cat();

        myDog.MakeSound(); // Output: Bark
        myCat.MakeSound(); // Output: Meow
    }
}

Explanation

  • Interface: IAnimal is an interface with a method MakeSound.
  • Implementation: Dog and Cat classes implement the IAnimal interface.
  • Instantiation: You can instantiate Dog and Cat and assign them to an IAnimal reference.

Practical Exercises

Exercise 1: Abstract Class

Create an abstract class Shape with an abstract method CalculateArea. Then, create two derived classes Circle and Rectangle that implement the CalculateArea method.

Solution

public abstract class Shape
{
    public abstract double CalculateArea();
}

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

    public Circle(double radius)
    {
        Radius = radius;
    }

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

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

    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

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

class Program
{
    static void Main(string[] args)
    {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        Console.WriteLine($"Circle Area: {circle.CalculateArea()}"); // Output: Circle Area: 78.53981633974483
        Console.WriteLine($"Rectangle Area: {rectangle.CalculateArea()}"); // Output: Rectangle Area: 24
    }
}

Exercise 2: Interface

Create an interface IVehicle with a method Drive. Then, create two classes Car and Bike that implement the IVehicle interface.

Solution

public interface IVehicle
{
    void Drive();
}

public class Car : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("Driving a car");
    }
}

public class Bike : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("Riding a bike");
    }
}

class Program
{
    static void Main(string[] args)
    {
        IVehicle car = new Car();
        IVehicle bike = new Bike();

        car.Drive(); // Output: Driving a car
        bike.Drive(); // Output: Riding a bike
    }
}

Common Mistakes and Tips

  • Not Implementing All Methods: When a class inherits from an abstract class or implements an interface, it must implement all abstract methods or interface methods.
  • Instantiation: Remember that you cannot instantiate an abstract class or an interface directly.
  • Use Cases: Use abstract classes when you want to provide some common functionality along with abstract methods. Use interfaces when you want to define a contract without any implementation.

Conclusion

In this section, you learned about abstraction in C#, including how to use abstract classes and interfaces to hide implementation details and expose only the necessary parts of a system. You also practiced creating and using abstract classes and interfaces through practical exercises. Understanding abstraction is crucial for designing clean, maintainable, and scalable software systems.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved