Understanding the Connections Between Classes in OOP

Suppose we have a Shape class representing various shapes such as circles, squares, and triangles. We then create subclasses Circle, Square, and Triangle that inherit from the Shape class.

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a generic shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

class Square : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a square.");
    }
}

class Triangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a triangle.");
    }
}

Now, let's say we want to introduce a new shape called Rectangle. We decided to create a new subclass Rectangle that inherits from the Shape class.

class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

However, what if later we realize that a rectangle has different properties compared to other shapes? For example, rectangles have a width and height, while other shapes do not.

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

    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

In this situation, opting for inheritance from the Shape class might not be ideal due to the inconsistency in properties among different shapes.

A more effective strategy would involve employing composition over inheritance. By creating a Rectangle class that encompasses a Shape object rather than inheriting from it, we can better capture the relationship between the entities. This approach ensures a more accurate representation and mitigates the risk of encountering inheritance-related issues.

To solve the problem using composition instead of inheritance, we can create a Rectangle class that contains a Shape object as a member. This way, we can leverage the functionality of the Shape class without inheriting it directly. Here's how we can implement it.

using System;

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a generic shape.");
    }
}

class Rectangle
{
    private readonly Shape _shape;

    public Rectangle(Shape shape)
    {
        _shape = shape;
    }

    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
        _shape.Draw(); // Delegate drawing the generic shape to the Shape object
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

class Square : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a square.");
    }
}

class Triangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a triangle.");
    }
}

class Program
{
    static void Main()
    {
        var circle = new Circle();
        var square = new Square();
        var triangle = new Triangle();

        var rectangleWithCircle = new Rectangle(circle);
        var rectangleWithSquare = new Rectangle(square);
        var rectangleWithTriangle = new Rectangle(triangle);

        rectangleWithCircle.Draw(); // Drawing a rectangle, Drawing a circle
        rectangleWithSquare.Draw(); // Drawing a rectangle, Drawing a square
        rectangleWithTriangle.Draw(); // Drawing a rectangle, Drawing a triangle
    }
}

I hope this article will help you in understanding various associations between classes while designing. Wishing you successful coding!