[C#]abstract(抽象)クラスとInterfaceの使い分け方

このサイトはプロモーションを含みます

2024年9月1日

C#でオブジェクト指向プログラミングを行う際、コードの再利用性や拡張性を高めるために、abstract(抽象)クラスとInterfaceは非常に重要な概念です。しかし、これらの使い分けに迷う開発者も多いのではないでしょうか。この記事では、abstract(抽象)クラスとInterfaceの違いを詳しく解説し、それぞれの適切な使用シーンを具体的な例を交えて説明します。

abstract(抽象)クラスとInterfaceの基本

まず、abstract(抽象)クラスとInterfaceの基本的な特徴を押さえておきましょう。

abstract(抽象)クラス

abstractキーワードを使用して宣言します。
抽象メソッド（実装を持たないメソッド）と具象メソッド（実装を持つメソッド）の両方を含むことができます。
フィールド、プロパティ、コンストラクタを持つことができます。
単一継承のみ可能です（C#では多重継承は許可されていません）。

Interface

interfaceキーワードを使用して宣言します。
メソッド、プロパティ、イベント、インデクサーの宣言のみを含みます（C# 8.0以降ではデフォルト実装も可能）。
フィールドやコンストラクタは持てません。
複数のInterfaceを実装することができます。

使い分けの基準

abstract(抽象)クラスとInterfaceの使い分けは、以下の基準を考慮して決定します：

Is-a関係 vs Can-do関係
- abstract(抽象)クラス：Is-a関係（「〜である」関係）を表現する場合に使用
- Interface：Can-do関係（「〜ができる」関係）を表現する場合に使用
共通の実装
- abstract(抽象)クラス：派生クラス間で共通の実装を提供したい場合に使用
- Interface：実装の共通性よりも、機能の約束を定義したい場合に使用
継承の柔軟性
- abstract(抽象)クラス：単一継承の制限がある場合に使用
- Interface：複数の機能を組み合わせて実装したい場合に使用
バージョン管理と拡張性
- abstract(抽象)クラス：既存の実装を変更せずに新しい機能を追加したい場合に使用
- Interface：既存のコードに影響を与えずに新しい機能を追加したい場合に使用（C# 8.0以降）

具体的な使用例

それでは、abstract(抽象)クラスとInterfaceの使い分けを、具体的な例を通じて見ていきましょう。

abstract(抽象)クラスの使用例

動物を表す抽象クラスと、それを継承する具象クラスを考えてみましょう。

public abstract class Animal
{
    public string Name { get; set; }

    protected Animal(string name)
    {
        Name = name;
    }

    public abstract void MakeSound();

    public virtual void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }

    public override void MakeSound()
    {
        Console.WriteLine($"{Name} barks: Woof!");
    }
}

public class Cat : Animal
{
    public Cat(string name) : base(name) { }

    public override void MakeSound()
    {
        Console.WriteLine($"{Name} meows: Meow!");
    }

    public override void Eat()
    {
        base.Eat();
        Console.WriteLine($"{Name} licks its paws after eating.");
    }
}

この例では、Animal抽象クラスが以下の要素を持っています：

Nameプロパティ：すべての動物に共通
MakeSound()抽象メソッド：各動物で異なる鳴き方を実装
Eat()仮想メソッド：共通の実装を提供しつつ、オーバーライド可能

DogとCatクラスはAnimalを継承し、必要なメソッドを実装しています。この構造は、”犬は動物である”、”猫は動物である”というIs-a関係を表現しています。

Interfaceの使用例

次に、異なる種類のオブジェクトに共通の機能を持たせたい場合を考えてみましょう。例えば、データベースに保存可能なオブジェクトを定義するインターフェースを作成します。

public interface ISaveable
{
    void Save();
    void Load(int id);
}

public class User : ISaveable
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Save()
    {
        Console.WriteLine($"Saving User {Name} to database.");
        // データベース保存のロジック
    }

    public void Load(int id)
    {
        Console.WriteLine($"Loading User with ID {id} from database.");
        // データベースからのロード処理
    }
}

public class Document : ISaveable
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public void Save()
    {
        Console.WriteLine($"Saving Document '{Title}' to database.");
        // データベース保存のロジック
    }

    public void Load(int id)
    {
        Console.WriteLine($"Loading Document with ID {id} from database.");
        // データベースからのロード処理
    }
}

この例では、ISaveableインターフェースが以下のメソッドを定義しています：

Save()：オブジェクトをデータベースに保存
Load(int id)：指定されたIDのオブジェクトをデータベースから読み込む

UserクラスとDocumentクラスは、互いに関連性がありませんが、どちらもISaveableインターフェースを実装しています。これにより、両方のクラスに「データベースに保存可能である」という機能を持たせることができます。

使い分けの実践

abstract(抽象)クラスとInterfaceの使い分けを、より実践的な観点から考えてみましょう。

階層構造の設計
- abstract(抽象)クラス：明確な階層構造があり、基本的な実装を共有したい場合に使用します。例：Shape → Circle, Rectangle, Triangle
複数の型にまたがる機能の定義
- Interface：異なる階層や無関係のクラスに共通の機能を持たせたい場合に使用します。例：IComparable, IDisposable, IEnumerable
将来の拡張性
- Interface：システムの将来的な拡張を見据えて、最小限の契約を定義したい場合に使用します。
- abstract(抽象)クラス：基本的な実装を提供しつつ、特定の機能を派生クラスに委ねたい場合に使用します。
テスト容易性
- Interface：単体テストでモックオブジェクトを使用する場合、Interfaceを使うとテストが容易になります。

実際の使用例

abstract(抽象)クラスとInterfaceを組み合わせて使用する実際の例を見てみましょう。

public interface ILogger
{
    void Log(string message);
}

public abstract class Vehicle
{
    protected ILogger Logger;
    public string Model { get; set; }

    protected Vehicle(string model, ILogger logger)
    {
        Model = model;
        Logger = logger;
    }

    public abstract void Start();

    public virtual void Stop()
    {
        Logger.Log($"{Model} stopped.");
    }
}

public class Car : Vehicle
{
    public Car(string model, ILogger logger) : base(model, logger) { }

    public override void Start()
    {
        Logger.Log($"{Model} car engine started.");
    }
}

public class Bicycle : Vehicle
{
    public Bicycle(string model, ILogger logger) : base(model, logger) { }

    public override void Start()
    {
        Logger.Log($"{Model} bicycle is ready to ride.");
    }

    public override void Stop()
    {
        Logger.Log($"{Model} bicycle stopped. Remember to use the kickstand.");
    }
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[{DateTime.Now}] {message}");
    }
}

// 使用例
class Program
{
    static void Main(string[] args)
    {
        ILogger logger = new ConsoleLogger();
        Vehicle car = new Car("Toyota Corolla", logger);
        Vehicle bicycle = new Bicycle("Mountain Bike", logger);

        car.Start();
        car.Stop();

        bicycle.Start();
        bicycle.Stop();
    }
}

この例では、以下のようにabstract(抽象)クラスとInterfaceを組み合わせています：

ILoggerインターフェース：ログ機能を定義
Vehicle抽象クラス：車両の基本的な構造と振る舞いを定義
CarとBicycleクラス：Vehicleを継承し、具体的な実装を提供
ConsoleLoggerクラス：ILoggerを実装し、コンソールにログを出力

この構造により、以下のような利点が得られます：

共通の機能（ログ出力）をInterfaceで定義し、異なる実装（コンソール、ファイル、データベースなど）に容易に切り替えられる。
車両の基本構造をabstract(抽象)クラスで定義し、共通の実装（Stopメソッド）を提供しつつ、特定の機能（Startメソッド）を派生クラスに委ねている。
新しい車両タイプ（例：電車、飛行機）を追加する際に、既存のコードを変更せずに拡張できる。