Introduction

In Unity development with C#, abstract classes and interfaces are core object-oriented programming constructs. They facilitate the design of flexible and maintainable game architectures by establishing contracts and defining shared behavior.

Core Definitions

Abstract Class

An abstract class is a class that cannot be instantiated and may contain both abstract method declarations (without implementation) and concrete methods (with implementation). It serves as a base class for other classes.

public abstract class GameEntity
{
    // Abstract method to be implemented by derived classes
    public abstract void PerformAction();

    // Concrete method with default behavior
    public void Initialize()
    {
        Debug.Log("Entity initialized.");
    }
}

Interface

An interface defines a conrtact specifying a set of members (methods, properties, events, indexers) that implementing classes must define. Prior to C# 8.0, it cannot provide any implementation.

public interface IDamageable
{
    // Method signature without implementation
    void ApplyDamage(int damageAmount);
}

Practical Roles and Distinctions

Role of Abstract Classes

• Code Reuse: Allows sharing common method implementations across derived classes.
• Enforced Implementation: Abstract members compel derived classes to provide specific functionality.
• Default Behavier: Can provide ready-to-use functionality that derived classes can optionally override.

Role of Interfaces

• Contract Definition: Establishes a guaranteed set of capabilities without dictating how they are achieved.
• Multiple Implementation: A class can implement multiple interfaces, enabling polymorphic designs beyond single inheritance.
• Decoupling: Separates definition from implementation, promoting looser coupling between components.

Key Differences

Application in Unity

Abstract Class Use Case

Abstract classes are ideal for creating a family of related objects with shared logic. For example, a base character class can define common game entity behavior.

public abstract class BaseCharacter : MonoBehaviour
{
    public float health;
    public abstract void Attack(); // Must be defined by specific character types

    public virtual void TakeDamage(float damage)
    {
        health -= damage;
        if (health <= 0) Destroy(gameObject);
    }
}

public class Enemy : BaseCharacter
{
    public override void Attack()
    {
        // Enemy-specific attack logic
        Debug.Log("Enemy attacks player.");
    }
}

Interface Use Case

Interfaces are perfect for defining cross-cutting capabilities that can be added to diverse game objects.

public interface ICollectible
{
    void Collect();
}

public class Coin : MonoBehaviour, ICollectible
{
    public void Collect()
    {
        GameManager.Instance.AddScore(10);
        Destroy(gameObject);
    }
}

public class PowerUp : MonoBehaviour, ICollectible
{
    public void Collect()
    {
        Player.Instance.BoostStrength();
        Destroy(gameObject);
    }
}

Design Guidelines for Unity

1. Use an abstract class when multiple closely related classes share significant common code and you want to provide a common base type with default behavior.
2. Use an interface when you need to define a capability contract that can be adopted by unrelated classes, or when a class needs to support multiple distinct roles.
3. Favor composition over deep inheritance hierarchies; interfaces can help achieve this by defining smaller, focused contracts.