型変数名の慣例

E
- element
T
- type
K
- key
V
- value

名称について

//この<E>が型パラメータ
    public class Event<E>{
        //型変数
        //型パラメータ内に並ぶ変数のこと
        E value;
    }

    public void useEvent(){
        //型引数
        //ジェネリック型を使うときに<>に渡す具体的な型
        //実際に使えるようになったジェネリック型のことをパラメータ化された型という
        Event<String> event = new Event<>();
    }

内部的には型変数の部分をObjectに置き換えたクラスが1つ生成される

境界のある型パラメータ

内部的にObject型に置き換えられますが、別の型を指定することもできます

public interface Character{
        void show();
    }
    public class Hoge<E extends Character>{
        E chacter;
        public void execute(){
            // 型が限定されているのでshowメソッドが呼出せる
            chacter.show();
        }
    }

extendsとして型を指定すれば、境界のあるパラメータとして置き換える型を限定できます。

ジェネリックメソッド

文法が面倒くさいというジェネリックメソッド

[修飾子] <型パラメータ> 戻り値メソッド名(引数) { }

型パラメータの型変数がメソッド呼出し時に、実型に置き換わる
クラスの型パラメータと考え方は同じ

public <T> List<T> add(T elm){
        return List.of(elm);
    }

    public void test(){
        List<String> list = add("御坂美琴");
    }

ジェネリッククラスとジェネリックメソッドは独立している

以下のTはジェネリッククラスの型変数と、そのクラス内のジェネリックメソッドの型変数が独立している→同じTでも結果的に型が違う

public class Home<T>{
        T value;
        void set(T value){
            this.value = value;
        }
        <T> List<T> add(T t){
            return List.of(t);
        }
    }
    public void homeTest(){
        Home<String> home = new Home<>();
        home.set("家");
        List<Integer> list = home.add(34);

    }

上限境界ワイルドカード

境界のある型パラメータと同じ考えです。

適合できるようになる型

ワイルドカードに指定した型
ワイルドカードに指定した型のサブクラス

Userクラスを継承したAdminUserクラスとTenantUserクラスがあります。

public class User{
        public String name;
        public int lank;
        public User(String name, int lank){
            this.name = name;
            this.lank = lank;
        }
    }
    public class AdminUser extends User{
        public AdminUser(String name, int lank) {
            super(name, lank);
        }
    }
    public class TenantUser extends User{
        public TenantUser(String name, int lank) {
            super(name, lank);
        }
    }

以下のようなコードはエラーになりませんが、型パラメータの型が合わないとエラーになってしまいます。

 User user = new TenantUser(&quot;初春&quot;,2);

addUserメソッドはListを引数に取ります。以下は型パラメータが合わずエラーになる

private List<User> myUsers = new ArrayList<>();
    public void addUser(List<User> list) {
        this.myUsers.addAll(list);
        System.out.println("追加しました");
    }
    @Test
    public void testssss(){
        List<TenantUser> tenantUsers = List.of(new TenantUser("佐天",3));
        addUser(tenantUsers); // エラー
    }

そこでワイルドカードを使います。以下はUserクラスかそのサブクラスであることを保証します。

private List<User> myUsers = new ArrayList<>();
    public void addUser(List<? extends User> list) {
        this.myUsers.addAll(list);
        System.out.println("追加しました");
    }
    @Test
    public void testssss(){
        List<TenantUser> tenantUsers = List.of(new TenantUser("佐天",3));
        addUser(tenantUsers);
    }

下限境界ワイルドカード

適合できる型

ワイルドカードに指定した型
ワイルドカードに指定した型のスーパークラス

// AdminUserを継承したSuperUserクラス
    public class SuperUser extends  AdminUser{
        public SuperUser(String name, int lank) {
            super(name, lank);
        }
    }
    private List<User> myUsers = new ArrayList<>();
    public void addUser(List<? super AdminUser> list) {
        this.myUsers.addAll((Collection<? extends User>) list);
        System.out.println("追加しました");
    }
    @Test
    public void testssss(){
        List<User> users = List.of(new User("初春",3));
        List<AdminUser> adminUsers = List.of(new AdminUser("佐天",3));
        List<TenantUser> tenantUsers = List.of(new TenantUser("白井",3));
        List<SuperUser> superUsers = List.of(new SuperUser("御坂",3));

        addUser(users);
        addUser(adminUsers);
        addUser(tenantUsers); // ここTenantUserはAdminUserのスーパークラスではないのでエラー
        addUser(superUsers); // サブクラスもエラーになる
    }

TenantUserとSuperUserはここでは指定できません。またaddUserメソッドではキャストを行っています

public void addUser(List<? super AdminUser> list) {
        this.myUsers.addAll((Collection<? extends User>) list);
        System.out.println("追加しました");
    }

これはObject型も指定が可能になっているため、Listに適合させるためにはキャストが必要になります。

柔軟なAPI設計

上記のワイルドカードを利用することでAPIを設計する際にも柔軟なAPIを提供できます。

参考記事

参考

例えば以下のような２つのリストを合算するメソッドがあります

public <T> List<T> addAll(List<T> groupa,List<T> groupb){
        List<T> newList = new ArrayList<>();
        newList.addAll(groupa);
        newList.addAll(groupb);
        return newList;
    }

同じ型ならば問題ないですが、継承関係にあっても型が違うと動きません。

public void test(){
        // StringのリストA
        List<String> aGroup = new ArrayList<>();
        aGroup.add("takasi");
        // StringのリストB
        List<String> bGroup = new ArrayList<>();
        bGroup.add("kousei");
        // 合算したリストを返す
        List<String> allGroup = addAll(aGroup,bGroup);
        System.out.println("a");

        // Userのリスト
        List<User> users = new ArrayList<>();
        users.add(new User("御坂",3));
        // Userを継承したAdminUserのリスト
        List<AdminUser> adminUsers = new ArrayList<>();
        adminUsers.add(new AdminUser("白井",3));
        // 合算したリストを返す
        List<User> allUser = addAll(users,adminUsers); //ここでエラー
        // エラー: クラス SampleTestのメソッド addAllは指定された型に適用できません
    }

しかしワイルドカードを利用すれば動きます

ただワイルドカードに<? extends User>のようなことをすれば、Stringが動かなくなります。そのため<? extends T>とします。こうすれば柔軟に対応できます

public <T> List<T> addAll(List<? extends T> groupa,List<? extends T> groupb){
        List<T> newList = new ArrayList<>();
        newList.addAll(groupa);
        newList.addAll(groupb);
        return newList;
    }

参考書籍

改訂2版　パーフェクトJava

Effective Java 第3版

ワイルドカードについてはここがとても勉強になります

https://www.javaroad.jp/java_generics3.htm

Java | ジェネリック