泛型的基本使用

泛型

什么是泛型

泛型的本质是类型参数化，解决不确定具体对象类型的问题。泛型可以定义在类、接口、方法中，编译器通过识别尖括号和尖括号内的字母来解析泛型。

泛型符号

• T：代表type，表示某个类
• K：代表Key
• V：代表Value
• E：代表Element，用于集合中的元素

K、V通常用于键值对元素。

泛型类

public interface List<E> extends Collection<E> {
    
}

public interface Map<K,V> {
    
}

public class Gen<T> {

    private T t;

    public Gen(T t) {
        System.out.println("T = " + t);
    }

    public static void main(String[] args) {
        Gen<String> gen1 = new Gen<String>("String"); // T = String
        Gen<Integer> gen2 = new Gen<Integer>(2); // T = 2
        Gen gen3 = new Gen(1.1); // T = 1.1
    }
}

• 泛型尖括号在类名之后
• 在不指定泛型类型时，T会被当成object处理

泛型方法

public class Gen<T> {

    private T t;

    public Gen() {
    }

    public <T> void test(T t) {
        System.out.println("泛型方法");
    }

    public static void main(String[] args) {
        Gen gen = new Gen();
        gen.<Gen>test(gen);// 泛型方法
    }

}

• 方法上的<T>在返回值之前，这个<T>个类名Gen<T>上面的没有关系。

public class Gen {

    
    public void test(List<Object> obj) {

    }

    public static void main(String[] args) {
        Gen gen = new Gen();
        gen.test(new ArrayList<Object>());
        gen.test(new ArrayList<String>()); // 编译不通过
    }

} 

• 泛型方法这里只接收List<Object> 作为参数类型，不能接收以外的参数类型，即使Object是超类。

public void test(List<?> obj) {

}

• ?表示通配符，也是可以代表任意类型。改成通配符编译就可以通过。

泛型的上下边界

上边界<? extends T>

当泛型要界定一个类型范围时，就产生泛型的上下边界。

限制**?为T或T的子类，最高只能为T**，即限制了上边界。

public class Grandfather {

}

public class Parent extends Grandfather{

}

public class Son extends Parent {

}

public class User {

}

<? extends T>修饰类

public class Gen<T extends Parent> {

    public static void main(String[] args) {
        Gen<Son> gen = new Gen<Son>();
        Gen<Parent> gen2 = new Gen<Parent>();
        Gen<Grandfather> gen2 = new Gen<Grandfather>(); // 编译不通过
        Gen<User> gen2 = new Gen<User>(); // 编译不通过
    }
}

<? extends T>修饰方法

public class Gen2<T> {

}

public class Gen {
    
    public void test01(Gen2<? extends Parent> gen) {

    }

    public static void main(String[] args) {
        Gen gen = new Gen();
        gen.test01(new Gen2<Son>());
        gen.test01(new Gen2<Parent>());
        gen.test01(new Gen2<Grandfather>()); // 编译不通过
        gen.test01(new Gen2<User>()); // 编译不通过
    }
}

• <T extends Parent>修饰类或者，只能使用Parent类型或者Parent子类

下边界<? super T>

限制**?为T的或T的父类，最低都要为T**，即限制了下边界。

public class Gen {

    public void test01(Gen2<? super Parent> gen) {

    }


    public static void main(String[] args) {
        Gen gen = new Gen();
        gen.test01(new Gen2<Son>()); // 编译不通过
        gen.test01(new Gen2<Parent>());
        gen.test01(new Gen2<Grandfather>());
        gen.test01(new Gen2<User>()); // 编译不通过
    }
}

• <T super Parent>修饰类或者，只能使用Parent类型或者Parent超类