１４．Javaのジェネリクスプログラミング完全ガイド

Javaのジェネリクス（Generics）は、データ型をパラメータとして扱う強力な機能であり、型安全性を確保し、コードの再利用性を高めます。この記事では、Javaのジェネリクスの基本的な概念から応用までを詳しく解説し、具体的なサンプルコードを使って理解を深めます。

ジェネリクスとは何か？

ジェネリクスは、クラスやメソッドにおいて、扱うデータの型をパラメータとして抽象化できる仕組みです。これにより、特定の型に依存しないコードを記述でき、型安全性を確保しながら再利用性の高いコードを実現します。典型的な例として、コレクションフレームワーク（ListやSetなど）はジェネリクスを活用しており、異なるデータ型のリストを安全に扱うことができます。

// Listを使用したジェネリクスの例
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // String型のリストを作成
        List stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("Generics");

        // Integer型のリストを作成
        List intList = new ArrayList<>();
        intList.add(100);
        intList.add(200);

        // リストの要素を表示
        System.out.println(stringList); // 出力: [Hello, Generics]
        System.out.println(intList);    // 出力: [100, 200]
    }
}

上記のコードでは、`List`はジェネリクスを使って定義されています。`List`は文字列を扱うリストであり、`List`は整数を扱うリストです。これにより、異なる型のリストを同じコードベースで効率的に扱うことができます。

ジェネリクスクラスの作成

ジェネリクスクラスとは、データ型をパラメータとして受け取るクラスのことです。クラス定義時に型引数を指定することで、異なるデータ型を柔軟に扱うことができます。以下に、ジェネリクスクラスの簡単な例を示します。

// ジェネリクスクラスの例
class Box {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        // Integer型のBoxを作成
        Box intBox = new Box<>();
        intBox.set(123);
        System.out.println("Integer Box: " + intBox.get()); // 出力: Integer Box: 123

        // String型のBoxを作成
        Box strBox = new Box<>();
        strBox.set("Generics");
        System.out.println("String Box: " + strBox.get()); // 出力: String Box: Generics
    }
}

この例では、`Box`クラスがジェネリクスとして定義されています。`T`は型引数であり、`Integer`や`String`など、オブジェクトの型に応じて動的に決定されます。異なる型の`Box`オブジェクトを作成することで、柔軟に様々なデータ型を扱えるようになります。

ジェネリクスメソッドの作成

ジェネリクスメソッドは、メソッドレベルで型引数を指定することで、様々な型に対して動的に処理を行うことができます。これにより、型安全性を維持しつつ、メソッドの汎用性を高めることが可能です。

// ジェネリクスメソッドの例
class Utility {
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        // Integer型の配列を表示
        Integer[] intArray = {1, 2, 3, 4, 5};
        Utility.printArray(intArray); // 出力: 1 2 3 4 5 

        // String型の配列を表示
        String[] strArray = {"A", "B", "C"};
        Utility.printArray(strArray); // 出力: A B C
    }
}

上記の例では、`Utility`クラスにジェネリクスメソッド`printArray`を定義しています。このメソッドは、渡された配列の要素を順に表示する汎用的なメソッドです。型引数`T`により、異なる型の配列を同じメソッドで処理できることがわかります。

ワイルドカードによるジェネリクスの柔軟性向上

Javaのジェネリクスでは、ワイルドカード（`?`）を使用することで、より柔軟な型指定が可能です。ワイルドカードには「上限境界」と「下限境界」があり、これらを使ってクラスやメソッドのジェネリクスの型引数を制限することができます。

上限境界ワイルドカード

上限境界ワイルドカードは、ある型のサブクラスのみを許可する場合に使用します。`<? extends T>`という形式で指定され、`T`またはそのサブクラスに制限されます。

// 上限境界ワイルドカードの例
import java.util.List;

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }
}

class SoundPlayer {
    public static void playSound(List<? extends Animal> animals) {
        for (Animal animal : animals) {
            animal.sound();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        List dogs = List.of(new Dog(), new Dog());
        List cats = List.of(new Cat(), new Cat());

        SoundPlayer.playSound(dogs); // 出力: Dog barks Dog barks
        SoundPlayer.playSound(cats); // 出力: Cat meows Cat meows
    }
}

この例では、`playSound`メソッドは`<? extends Animal>`という上限境界ワイルドカードを使用しています。これにより、`Animal`のサブクラスである`Dog`や`Cat`のリストをメソッドに渡すことができ、動的な多態性を実現しています。

下限境界ワイルドカード

下限境界ワイルドカードは、ある型のスーパークラスを許可する場合に使用します。`<? super T>`という形式で指定され、`T`またはそのスーパークラスに制限されます。これにより、型の下限を指定して柔軟な処理を行うことが可能です。

// 下限境界ワイルドカードの例
import java.util.List;
import java.util.ArrayList;

class Animal {}
class Dog extends Animal {}

public class Main {
    public static void addDogs(List<? super Dog> list) {
        list.add(new Dog());
    }

    public static void main(String[] args) {
        List animals = new ArrayList<>();
        addDogs(animals);
        System.out.println("List size: " + animals.size()); // 出力: List size: 1
    }
}

この例では、`addDogs`メソッドに`<? super Dog>`という下限境界ワイルドカードを使用しています。この設定により、`Dog`のスーパークラスである`Animal`のリストに対して、`Dog`を安全に追加できるようになっています。

まとめ

Javaのジェネリクスプログラミングは、型安全性を確保しつつ、コードの再利用性を高める非常に強力な機能です。ジェネリクスクラスやメソッドを使用することで、型に依存しない汎用的なプログラムを記述でき、ワイルドカードを活用することで柔軟な型指定が可能になります。Javaのコレクションフレームワークや、他の多くのAPIではジェネリクスが活用されており、その理解はJavaプログラマーにとって必須です。この記事で紹介したサンプルコードを元に、さらにジェネリクスの応用力を高めてください。