Java语言之泛型

泛型:指的是在类定义的时候并不会设置类中的属性或方法的参数的具体类型,在类使用时在进行定义.想要进行泛型操作,必须做一个类型标记的声明.

<T>:其中T代表类型的参数,可指代任何类型.我们一般常见的代表类型参数的有:

T:代表一般的任何类

E:代表Element 的意思,或者Exception异常的意思

K:代表key的意思

V:代表Value的意思,通常与K一起配合使用

S:代表Subtype的意思

泛型存在泛型类与泛型方法:

对应泛型类举例:

class Myclass<T,E>{
    private T value1;
    private E value2;
}

对应泛型方法举例:

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

注:泛型方法与泛型类有一点不同的地方,泛型方法的类型参数(尖括号那一部分)在返回值的前边.<T>中的T为类型参数,方法中的T为参数化类型,它不是运行时真正的参数.

泛型类与泛型方法可以共存,对应举例如下:

class MyClass<T>{
    public void test1(T t){
        System.out.println(t);
    }
    public <T> T test2(T t){
        return t;
    }//泛型方法
}
public class Test {
    public static void main(String[] args) {
      MyClass<String> myClass = new MyClass<>();
      myClass.test1("Hello");
      Integer i = myClass.test2(20);
      System.out.println(i);
    }
}

由上可知,泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的.

对于增加泛型的定义后,虽然解决了两个无关对象进行强行类型转换问题(ClassCastException),但出现了参数不统一的问题

(1)解决ClassCastException问题:

class MyClass<T>{
    private T value1;
    private T value2;
    public void setValue1(T value1){
        this.value1 = value1;
    }
    public T getValue1(){
        return value1;
    }
    public void setValue2(T value2){
        this.value2 = value2;
    }
    public T getValue2(){
        return value2;
    }
}
public class Test {
    public static void main(String[] args) {
      MyClass<String> myClass = new MyClass<>();
      myClass.setValue1("Hello");
      myClass.setValue2("World");
      String x = myClass.getValue1();
      String y = myClass.getValue2();//避免了向下转型
      System.out.println("x = "+x+"  "+"y = "+y);
    }
}

(2)解决参数不统一问题(通配符)

通配符: (?来表示 )  包含:1.泛型上限  ? extends 类    2.泛型下限   ? super 类

对应举例为:

//泛型上限

class MyClass<T extends Number>{
    private T value1;
    public void setValue1(T value1){
        this.value1 = value1;
    }
    public T getValue1(){
        return value1;
    }
}
public class Test {
    public static void main(String[] args) {
      MyClass<Integer> myClass = new MyClass();
      myClass.setValue1(50);
     fun(myClass);
    }
    public static void fun(MyClass<? extends Number> myClass){
        System.out.println(myClass.getValue1());
    }
}

//泛型下限

class MyClass<T>{
    private T value1;
    public void setValue1(T value1){
        this.value1 = value1;
    }
    public T getValue1(){
        return value1;
    }
}
public class Test {
    public static void main(String[] args) {
      MyClass<String> myClass = new MyClass();
      myClass.setValue1("Hello");
     fun(myClass);
    }
    public static void fun(MyClass<? super String> myClass){
        System.out.println(myClass.getValue1());
    }
}

注:上限可以用在声明,不能修改;下限只能用在方法参数,可以修改内容.

泛型还可以实现接口:

interface IMessage<T>{
    public void print(T t);
}
class Message<T> implements IMessage<T>{
    public void print(T t){
        System.out.println(t);
    }
    public void testMethod1(T t){
        System.out.println(t);
    }
}
public class Test {
    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.print("Hello");
        message.testMethod1("world");
    }
}

泛型擦除:泛型的信息只存在于代码编译阶段,在进入JVM之前,与泛型相关的信息会被擦掉(类型擦除).

在泛型类被类型擦除时,若之前的泛型类中的类型参数部分没有指定上限,<T>被转译为普通的Object类型.

若存在上限如<T extends String> 则类型会被代替成类型上限.