Java 泛型

2021-10-09 本文已影响0人 Mr_panmin

为什么使用泛型

泛型就是“参数化类型”，就是把类型当作参数传递

对于为什么要使用泛型，我们先来举几个栗子

🌰1:

    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

上面两个方法的方法体实现都是一样的，但是因为参数的类型和返回值的类型不同就需要定义两个方法。

🌰2:

    public class MainActivity extends AppCompatActivity{
      @Override
      protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initViews();
        initData();
      }
    }

        public class TestActivity extends AppCompatActivity{
      @Override
      protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initViews();
        initData();
      }
    }

上面两个activity类中实现的方法是一样的，但是由于属于不同的页面导致我们要实现多个重复的代码。

🌰3:

List list = new ArrayList();
list.add(1);
list.add("a");
System.out.println((String)list.get(0) + (String)list.get(1));

报错：

 java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

在编译过程中，List中的类型应该是Object，强制类型转换就有可能出错。

泛型的好处：

1、多种数据类型执行相同的代码

2、实例化时指定类型，不需要强制类型转换

泛型类、泛型接口、泛型方法

泛型类：

public class T1<T>{}

泛型接口：

public interface T2<T>{}

泛型方法：

// 1. 普通泛型方法

// 1.1 方法调用时指定类型
public <T> T test1(T t){
  return t;
} 

// 1.2 类初始化时指定类型
public class T1<T>{
  public T test1(T t){
    return t;
  }
}

// 2. 静态泛型方法
public class T2<T>{
  
  // 此处的T和T2后面的T没有任何关系，
  // T2中的T需要在初始化时指定类型，
  // 此处的静态方法是在方法调用时指定的
  public static <T> T test(T t){
    return t;
  }
}

限定类型变量

有的时候，我们需要对类型变量（泛型）进行约束，比如取两个变量的最小值

public <T> T min(T a, T b) {
    if (a.compareTo(b) > 0) return b;
    else return a;
}

如何保证传入的T有compareTo方法呢？

public <T extends Comparable> T min(T a, T b) {
  if (a.compareTo(b) > 0) return b;
  else return a;
}

T extends Comparable & Serializable 泛型可以支持多个接口，如果限定类型有类，这个类必须是在限定列表的第一个。

泛型中的约束和局限性

不能实例化基本数据类型的泛型

// Test<double> t = new Test<double>();// 不允许这种写法
Test<Double> t = new Test<Double>();

不能实例化类型变量
```
// T t = new T();
```

运行时类型查询，只能适用于原始类型

Test<Double> t = new Test<>();
//if(t instanceof Test<Double>) //不允许
//if(t instanceof Test<T>) //不允许
t.getClass();

泛型类静态上下文中类型变量失效

class Test<T> {
  //此处的T和Test<T>不是同一个
  public static <T> T getInstance(){
    ...
  }
}

不能创建参数化类型的数组

// Test<Double> ts = new Test<Double>[]; //不允许

不能捕获泛型类型的实例

// class MyException<T> extends Exception //编译器报错
// class MyThrowable<T> extends Throwable //编译器报错

//public <T extends Throwable> void test(){
//  try {
//
//  }catch (T e){//此处T报错
//
//  }
//}

public <T extends Throwable> void test(){
  try {

  }catch (Throwable e){//可以这么写

  }
}

通配符类型

? extends X

表示类型的上界，类型参数是X的子类
? super X

表示类型的下界，类型参数是X的超类

无限定的通配符

Pair<?>。初看起来，这好像与原始的 Pair 类型一样。实际上，有很大的不同。类型 Pair<?> 有以下方法:

? getFi rst() 
void setFirst(?)

getFirst 的返回值只能赋给一个 Object ，setFirst 方法不能被调用，甚至不能用 Object 调用。Pair<?> 和 Pair 本质的不同在于: 可以用任意 Object 对象调用原始 Pair 类的 setObject；

为什么要使用这么脆弱的类型？

它对于许多简单的操作非常有用。例如，下面这个方法将用来测试一个 pair 是否包含一个 null 引用，它不需要实际的类型。

public static boolean hasNulls(Pair<?> p){
    return p.getFirstO = null || p.getSecondO = null;
}

也可以使用：

public static <T> boolean hasNulls(Pair<T> p)

但带有通配符可读性更强一些。

虚拟机中是如何实现泛型的？

在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。

C#中的泛型和Java中的泛型有什么区别？

C#在编译成中间语言时List<int>和List<String>是两种不同的类型，而在Java中，泛型只是一种语法糖，编译成class文件后泛型就会被擦除，变成List<Object>。