【C#】抽象クラスと抽象メソッドをやさしく理解するための基礎と実践ポイント

public abstract class Shape
{
    public abstract double GetArea(); // 面積を計算する抽象メソッド
}

// コンパイルエラー: 抽象クラスはインスタンス化できません
Shape shape = new Shape();

public abstract class Vehicle
{
    public void StartEngine()
    {
        Console.WriteLine("エンジンを始動します。");
    }
    public abstract void Drive(); // 派生クラスで具体的に実装
}

public abstract class Animal
{
    public void Breathe()
    {
        Console.WriteLine("呼吸しています。");
    }
    public abstract void MakeSound(); // 派生クラスで必須実装
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
}
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ニャーニャー");
    }
}
class Program
{
    static void Main()
    {
        Animal dog = new Dog();
        dog.Breathe();    // 呼吸しています。
        dog.MakeSound();  // ワンワン
        Animal cat = new Cat();
        cat.Breathe();    // 呼吸しています。
        cat.MakeSound();  // ニャーニャー
    }
}

呼吸しています。
ワンワン
呼吸しています。
ニャーニャー

public abstract class Animal
{
    public abstract void MakeSound(); // シグネチャのみ定義、実装なし
}

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

public abstract class Animal
{
    public abstract void MakeSound();
}
public class Cat : Animal
{
    // overrideしないとコンパイルエラーになる
    public override void MakeSound()
    {
        Console.WriteLine("ニャーニャー");
    }
}

public abstract class Animal
{
    public abstract void MakeSound();
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
}
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ニャーニャー");
    }
}
class Program
{
    static void Main()
    {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.MakeSound(); // ワンワン
        animal2.MakeSound(); // ニャーニャー
    }
}

ワンワン
ニャーニャー

[アクセス修飾子] abstract class クラス名
{
    // メンバー定義
}

public abstract class Animal
{
    public abstract void MakeSound();
}

internal abstract class BaseClass
{
    public abstract void DoWork();
}

// コンパイルエラー: abstractクラスはsealedにできない
public abstract sealed class MyClass
{
}

public abstract class Logger
{
    // ログを出力する抽象メソッド(戻り値なし)
    public abstract void Log(string message);
}
public class ConsoleLogger : Logger
{
    public override void Log(string message)
    {
        Console.WriteLine($"ログ: {message}");
    }
}
class Program
{
    static void Main()
    {
        Logger logger = new ConsoleLogger();
        logger.Log("システムが起動しました。");
    }
}

ログ: システムが起動しました。

public abstract class Shape
{
    // 面積を計算して返す抽象メソッド(戻り値はdouble)
    public abstract double GetArea();
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public Circle(double radius)
    {
        Radius = radius;
    }
    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}
class Program
{
    static void Main()
    {
        Shape circle = new Circle(5);
        Console.WriteLine($"円の面積: {circle.GetArea():F2}");
    }
}

円の面積: 78.54

public abstract class DataProvider
{
    // データを文字列配列で返す抽象メソッド
    public abstract string[] GetData();
}
public class SampleDataProvider : DataProvider
{
    public override string[] GetData()
    {
        return new string[] { "データ1", "データ2", "データ3" };
    }
}
class Program
{
    static void Main()
    {
        DataProvider provider = new SampleDataProvider();
        foreach (var item in provider.GetData())
        {
            Console.WriteLine(item);
        }
    }
}

データ1
データ2
データ3

public abstract class Repository
{
    // ジェネリックな抽象メソッド。型Tのデータを取得する
    public abstract T GetById<T>(int id);
}
public class SampleRepository : Repository
{
    public override T GetById<T>(int id)
    {
        // ここでは簡単にデフォルト値を返す例
        Console.WriteLine($"ID {id} のデータを取得します。型: {typeof(T).Name}");
        return default(T);
    }
}
class Program
{
    static void Main()
    {
        Repository repo = new SampleRepository();
        var data1 = repo.GetById<string>(1);
        var data2 = repo.GetById<int>(2);
    }
}

ID 1 のデータを取得します。型: String
ID 2 のデータを取得します。型: Int32

public abstract class Repository
{
    // Tは参照型でなければならない
    public abstract T GetById<T>(int id) where T : class;
}
public class SampleRepository : Repository
{
    public override T GetById<T>(int id)
    {
        Console.WriteLine($"ID {id} の参照型データを取得します。型: {typeof(T).Name}");
        return null; // 参照型なのでnullを返せる
    }
}
class Program
{
    static void Main()
    {
        Repository repo = new SampleRepository();
        var data = repo.GetById<string>(1); // OK
        // var value = repo.GetById<int>(2); // コンパイルエラー: intは値型なので制約違反
    }
}

ID 1 の参照型データを取得します。型: String

public abstract class Person
{
    // 名前プロパティのgetterとsetterを抽象メソッドとして定義
    public abstract string Name { get; set; }
}
public class Employee : Person
{
    private string name;
    public override string Name
    {
        get { return name; }
        set { name = value; }
    }
}
class Program
{
    static void Main()
    {
        Person employee = new Employee();
        employee.Name = "山田太郎";
        Console.WriteLine($"名前: {employee.Name}");
    }
}

名前: 山田太郎

public abstract class ReadOnlyData
{
    public abstract int Id { get; } // 読み取り専用プロパティ
}

public abstract class ButtonBase
{
    // クリックイベントを抽象イベントとして宣言
    public abstract event EventHandler Clicked;
}
public class Button : ButtonBase
{
    private event EventHandler clicked;
    public override event EventHandler Clicked
    {
        add { clicked += value; }
        remove { clicked -= value; }
    }
    public void SimulateClick()
    {
        clicked?.Invoke(this, EventArgs.Empty);
    }
}
class Program
{
    static void Main()
    {
        Button button = new Button();
        button.Clicked += (sender, e) => Console.WriteLine("ボタンがクリックされました。");
        button.SimulateClick();
    }
}

ボタンがクリックされました。

public abstract class DataCollection
{
    // インデクサのgetterとsetterを抽象メンバーとして定義
    public abstract string this[int index] { get; set; }
}
public class StringList : DataCollection
{
    private List<string> items = new List<string>();
    public override string this[int index]
    {
        get
        {
            if (index < 0 || index >= items.Count)
                throw new IndexOutOfRangeException();
            return items[index];
        }
        set
        {
            if (index < 0 || index >= items.Count)
                throw new IndexOutOfRangeException();
            items[index] = value;
        }
    }
    public void Add(string item)
    {
        items.Add(item);
    }
}
class Program
{
    static void Main()
    {
        StringList list = new StringList();
        list.Add("りんご");
        list.Add("みかん");
        list.Add("バナナ");
        Console.WriteLine(list[1]); // みかん
        list[1] = "オレンジ";
        Console.WriteLine(list[1]); // オレンジ
    }
}

みかん
オレンジ

public abstract class Vehicle
{
    public string Brand { get; }
    // 抽象クラスのコンストラクタ
    protected Vehicle(string brand)
    {
        Brand = brand;
        Console.WriteLine($"Vehicleコンストラクタ: {brand}を初期化");
    }
}
public class Car : Vehicle
{
    public string Model { get; }
    // 派生クラスのコンストラクタでbaseを使って基底クラスのコンストラクタを呼び出す
    public Car(string brand, string model) : base(brand)
    {
        Model = model;
        Console.WriteLine($"Carコンストラクタ: {model}を初期化");
    }
}
class Program
{
    static void Main()
    {
        Car car = new Car("トヨタ", "カローラ");
        Console.WriteLine($"ブランド: {car.Brand}, モデル: {car.Model}");
    }
}

Vehicleコンストラクタ: トヨタを初期化
Carコンストラクタ: カローラを初期化
ブランド: トヨタ, モデル: カローラ

public abstract class Device
{
    // 1. フィールド宣言時の初期化
    protected int version = 1;
    // 3. プロパティの初期化子
    public string Manufacturer { get; protected set; } = "未設定";
    protected Device()
    {
        // 2. コンストラクタ内での初期化
        version = 2;
        Manufacturer = "Generic Corp";
        Console.WriteLine($"Deviceコンストラクタ: version={version}, Manufacturer={Manufacturer}");
    }
}
public class Smartphone : Device
{
    public Smartphone()
    {
        Console.WriteLine("Smartphoneコンストラクタ");
    }
}
class Program
{
    static void Main()
    {
        Smartphone phone = new Smartphone();
    }
}

Deviceコンストラクタ: version=2, Manufacturer=Generic Corp
Smartphoneコンストラクタ

public abstract class Config
{
    public static readonly string AppName;
    // 静的コンストラクタ
    static Config()
    {
        AppName = "MyApplication";
        Console.WriteLine("Configの静的コンストラクタが呼ばれました。");
    }
}
public class AppConfig : Config
{
    public void ShowAppName()
    {
        Console.WriteLine($"アプリ名: {AppName}");
    }
}
class Program
{
    static void Main()
    {
        AppConfig config = new AppConfig();
        config.ShowAppName();
    }
}

Configの静的コンストラクタが呼ばれました。
アプリ名: MyApplication

public abstract class Animal
{
    public abstract void MakeSound();
}
public class Dog : Animal
{
    // overrideキーワードを付けて抽象メソッドを実装
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
}
class Program
{
    static void Main()
    {
        Animal dog = new Dog();
        dog.MakeSound(); // ワンワン
    }
}

ワンワン

public abstract class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("動物の鳴き声");
    }
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        base.MakeSound(); // 基底クラスの処理を呼び出す
        Console.WriteLine("ワンワン");
    }
}
class Program
{
    static void Main()
    {
        Animal dog = new Dog();
        dog.MakeSound();
    }
}

動物の鳴き声
ワンワン

public abstract class Animal
{
    public abstract void MakeSound();
    public abstract void Fly();
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
    public override void Fly()
    {
        // 犬は飛べないので例外をスロー
        throw new NotImplementedException("犬は飛べません。");
    }
}
class Program
{
    static void Main()
    {
        Animal dog = new Dog();
        dog.MakeSound();
        try
        {
            dog.Fly();
        }
        catch (NotImplementedException ex)
        {
            Console.WriteLine($"例外: {ex.Message}");
        }
    }
}

ワンワン
例外: 犬は飛べません。

public interface ILogger
{
    void Log(string message);
    // デフォルト実装
    void LogWarning(string message)
    {
        Log($"警告: {message}");
    }
}
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class Program
{
    static void Main()
    {
        ILogger logger = new ConsoleLogger();
        logger.Log("通常のログ");
        logger.LogWarning("これは警告です");
    }
}

通常のログ
警告: これは警告です

// コンパイルエラー: 多重継承は不可
public class MultiDerived : AbstractClass1, AbstractClass2
{
}

public interface IFirst
{
    void MethodA();
}
public interface ISecond
{
    void MethodB();
}
public class MultiImplementer : IFirst, ISecond
{
    public void MethodA() { Console.WriteLine("MethodA"); }
    public void MethodB() { Console.WriteLine("MethodB"); }
}

public abstract class Animal
{
    // abstract: 派生クラスで必須実装
    public abstract void MakeSound();
    // virtual: 基底クラスで既定実装あり、必要に応じてオーバーライド可能
    public virtual void Sleep()
    {
        Console.WriteLine("動物は眠ります。");
    }
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
    public override void Sleep()
    {
        Console.WriteLine("犬は丸くなって眠ります。");
    }
}

public abstract class Logger
{
    public virtual void Log(string message)
    {
        Console.WriteLine($"ログ: {message}");
    }
}
public class FileLogger : Logger
{
    public override void Log(string message)
    {
        base.Log(message); // 基底クラスのログ出力を呼び出す
        Console.WriteLine("ファイルにログを書き込みました。");
    }
}

ログ: システム起動
ファイルにログを書き込みました。

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ニャーニャー");
    }
    // Sleepはオーバーライドしないので基底クラスの実装が使われる
}

ニャーニャー
動物は眠ります。

public abstract class Cooking
{
    // テンプレートメソッド(処理の流れを定義)
    public void Prepare()
    {
        PrepareIngredients();
        Cook();
        Serve();
    }
    protected abstract void PrepareIngredients(); // 材料の準備(派生クラスで実装)
    protected abstract void Cook();               // 調理(派生クラスで実装)
    protected virtual void Serve()
    {
        Console.WriteLine("料理を皿に盛り付けます。");
    }
}
public class Sushi : Cooking
{
    protected override void PrepareIngredients()
    {
        Console.WriteLine("米を炊き、魚を切ります。");
    }
    protected override void Cook()
    {
        Console.WriteLine("酢飯を作り、ネタをのせます。");
    }
}
public class Steak : Cooking
{
    protected override void PrepareIngredients()
    {
        Console.WriteLine("牛肉を室温に戻します。");
    }
    protected override void Cook()
    {
        Console.WriteLine("フライパンで焼きます。");
    }
    protected override void Serve()
    {
        Console.WriteLine("ステーキソースをかけて盛り付けます。");
    }
}
class Program
{
    static void Main()
    {
        Cooking sushi = new Sushi();
        sushi.Prepare();
        Console.WriteLine();
        Cooking steak = new Steak();
        steak.Prepare();
    }
}

米を炊き、魚を切ります。
酢飯を作り、ネタをのせます。
料理を皿に盛り付けます。

牛肉を室温に戻します。
フライパンで焼きます。
ステーキソースをかけて盛り付けます。

public abstract class AnimalFactory
{
    // ファクトリーメソッド(抽象メソッド)
    public abstract Animal CreateAnimal();
    public void ShowAnimalSound()
    {
        Animal animal = CreateAnimal();
        animal.MakeSound();
    }
}
public abstract class Animal
{
    public abstract void MakeSound();
}
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ワンワン");
    }
}
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("ニャーニャー");
    }
}
public class DogFactory : AnimalFactory
{
    public override Animal CreateAnimal()
    {
        return new Dog();
    }
}
public class CatFactory : AnimalFactory
{
    public override Animal CreateAnimal()
    {
        return new Cat();
    }
}
class Program
{
    static void Main()
    {
        AnimalFactory dogFactory = new DogFactory();
        dogFactory.ShowAnimalSound();
        AnimalFactory catFactory = new CatFactory();
        catFactory.ShowAnimalSound();
    }
}

ワンワン
ニャーニャー

public abstract class CalculationStrategy
{
    public abstract int Calculate(int a, int b);
}
public class AddStrategy : CalculationStrategy
{
    public override int Calculate(int a, int b)
    {
        return a + b;
    }
}
public class MultiplyStrategy : CalculationStrategy
{
    public override int Calculate(int a, int b)
    {
        return a * b;
    }
}
public class Calculator
{
    private CalculationStrategy strategy;
    public Calculator(CalculationStrategy strategy)
    {
        this.strategy = strategy;
    }
    public void SetStrategy(CalculationStrategy strategy)
    {
        this.strategy = strategy;
    }
    public int Execute(int a, int b)
    {
        return strategy.Calculate(a, b);
    }
}
class Program
{
    static void Main()
    {
        Calculator calculator = new Calculator(new AddStrategy());
        Console.WriteLine($"加算結果: {calculator.Execute(3, 5)}");
        calculator.SetStrategy(new MultiplyStrategy());
        Console.WriteLine($"乗算結果: {calculator.Execute(3, 5)}");
    }
}

加算結果: 8
乗算結果: 15

public abstract class Repository<T>
{
    // 抽象メソッドで型Tのデータを取得する
    public abstract T GetById(int id);
    // 仮想メソッドでデータを保存する共通処理
    public virtual void Save(T item)
    {
        Console.WriteLine($"{typeof(T).Name}を保存しました。");
    }
}
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class UserRepository : Repository<User>
{
    public override User GetById(int id)
    {
        // ここでは簡単にダミーデータを返す例
        return new User { Id = id, Name = "山田太郎" };
    }
}
class Program
{
    static void Main()
    {
        Repository<User> userRepo = new UserRepository();
        User user = userRepo.GetById(1);
        Console.WriteLine($"ユーザーID: {user.Id}, 名前: {user.Name}");
        userRepo.Save(user);
    }
}

ユーザーID: 1, 名前: 山田太郎
Userを保存しました。

public interface IProcessor<in T>
{
    void Process(T item);
}

// コンパイルエラー: 抽象クラスの型パラメータにin/outは使えない
public abstract class Processor<in T>
{
    public abstract void Process(T item);
}

public abstract class EntityRepository<T> where T : IEntity, new()
{
    public abstract T GetById(int id);
    public virtual void AddNew()
    {
        T entity = new T();
        Console.WriteLine($"{typeof(T).Name}の新規エンティティを追加しました。");
    }
}
public interface IEntity
{
    int Id { get; set; }
}
public class Product : IEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class ProductRepository : EntityRepository<Product>
{
    public override Product GetById(int id)
    {
        return new Product { Id = id, Name = "サンプル商品" };
    }
}
class Program
{
    static void Main()
    {
        EntityRepository<Product> repo = new ProductRepository();
        Product product = repo.GetById(10);
        Console.WriteLine($"商品ID: {product.Id}, 名前: {product.Name}");
        repo.AddNew();
    }
}

商品ID: 10, 名前: サンプル商品
Productの新規エンティティを追加しました。

public abstract class Logger
{
    public abstract void Log(string message);
}
public abstract class ErrorLogger : Logger
{
    public abstract void LogError(string errorMessage);
}

public abstract class A { /* 基本機能 */ }
public abstract class B : A { /* 追加機能 */ }
public abstract class C : B { /* さらに追加 */ }
public abstract class D : C { /* さらに追加 */ }
public class Concrete : D { /* 実装 */ }

public interface ILogger
{
    void Log(string message);
}
public interface IErrorLogger
{
    void LogError(string errorMessage);
}
public abstract class BaseLogger : ILogger
{
    public virtual void Log(string message)
    {
        Console.WriteLine($"ログ: {message}");
    }
}
public class FileLogger : BaseLogger, IErrorLogger
{
    public void LogError(string errorMessage)
    {
        Console.WriteLine($"エラーログ: {errorMessage}");
    }
}

public abstract class PaymentProcessor
{
    public abstract void ProcessPayment(decimal amount);
}
public class CreditCardProcessor : PaymentProcessor
{
    public override void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"クレジットカードで{amount}円を処理しました。");
    }
}
class Program
{
    static void Main()
    {
        var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
        // 抽象クラスをサービス型として登録し、具象クラスを指定
        services.AddTransient<PaymentProcessor, CreditCardProcessor>();
        var provider = services.BuildServiceProvider();
        // PaymentProcessor型で解決され、CreditCardProcessorのインスタンスが返る
        var processor = provider.GetService<PaymentProcessor>();
        processor.ProcessPayment(1000);
    }
}

クレジットカードで1000円を処理しました。

public abstract class DataFetcher
{
    public abstract string FetchData(int id);
    public virtual string FetchDefault()
    {
        return "デフォルトデータ";
    }
}
class Program
{
    static void Main()
    {
        var mock = new Moq.Mock<DataFetcher>();
        // 抽象メソッドの戻り値を設定
        mock.Setup(m => m.FetchData(It.IsAny<int>())).Returns("モックデータ");
        var fetcher = mock.Object;
        Console.WriteLine(fetcher.FetchData(10));      // モックデータ
        Console.WriteLine(fetcher.FetchDefault());     // デフォルトデータ(基底クラスの実装が呼ばれる)
    }
}

モックデータ
デフォルトデータ

// 独自例外のベース抽象クラス
public abstract class ApplicationExceptionBase : Exception
{
    protected ApplicationExceptionBase(string message) : base(message)
    {
    }
    protected ApplicationExceptionBase(string message, Exception innerException) : base(message, innerException)
    {
    }
    // 共通のログ出力メソッドなどを追加可能
    public void LogError()
    {
        Console.WriteLine($"エラー発生: {Message}");
    }
}
// 具体的な例外クラス
public class DataNotFoundException : ApplicationExceptionBase
{
    public DataNotFoundException(string message) : base(message)
    {
    }
}
public class ValidationException : ApplicationExceptionBase
{
    public ValidationException(string message) : base(message)
    {
    }
}

try
{
    throw new DataNotFoundException("データが見つかりません。");
}
catch (ApplicationExceptionBase ex)
{
    ex.LogError();
    // 共通の例外処理
}

public abstract class ReportGenerator
{
    // 仮想メソッドで既定実装は未対応として例外をスロー
    public virtual void GeneratePdfReport()
    {
        throw new NotImplementedException("PDFレポート生成は未実装です。");
    }
    // 抽象メソッドは必ず実装が必要
    public abstract void GenerateHtmlReport();
}
public class HtmlReportGenerator : ReportGenerator
{
    public override void GenerateHtmlReport()
    {
        Console.WriteLine("HTMLレポートを生成しました。");
    }
    // GeneratePdfReportはオーバーライドしないため例外がスローされる
}

class Program
{
    static void Main()
    {
        ReportGenerator generator = new HtmlReportGenerator();
        generator.GenerateHtmlReport();
        try
        {
            generator.GeneratePdfReport();
        }
        catch (NotImplementedException ex)
        {
            Console.WriteLine($"例外: {ex.Message}");
        }
    }
}

HTMLレポートを生成しました。
例外: PDFレポート生成は未実装です。

public abstract class BaseClass
{
    // protected抽象メソッドは派生クラス内でのみ実装・呼び出し可能
    protected abstract void DoWork();
}
public class DerivedClass : BaseClass
{
    public override void DoWork()
    {
        Console.WriteLine("処理を実行");
    }
    public void Execute()
    {
        DoWork(); // OK
    }
}
class Program
{
    static void Main()
    {
        DerivedClass obj = new DerivedClass();
        // obj.DoWork(); // コンパイルエラー: protectedなので外部から呼べない
        obj.Execute();  // これを通じてDoWorkが呼ばれる
    }
}

// 過剰な抽象化の例(イメージ)
public abstract class BaseA { public abstract void MethodA(); }
public abstract class BaseB : BaseA { public abstract void MethodB(); }
public abstract class BaseC : BaseB { public abstract void MethodC(); }
// さらに派生クラスが続く...
// これにより設計が複雑化し、保守が困難に

public abstract class Base
{
    public abstract void DoWork();
}
public class Derived : Base
{
    public override void DoWork()
    {
        // 処理内容
    }
}

public abstract record Shape
{
    public abstract double GetArea();
}
public record Circle(double Radius) : Shape
{
    public override double GetArea() => Math.PI * Radius * Radius;
}