泛型

• Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
• 常见形式有泛型类、泛型接口、泛型方法。
• 语法：
  • T称为类型占位符，表示一种引用类型。
• 好处：
  • 提高代码的重用性。
  • 防止类型转换异常，提高代码的安全性。

1. 泛型类

/**
 * 泛型类
 * 语法：类名<T>
 * T是类型占位符，表示一种引用类型，编写多个使用逗号隔开
 */
public class MyGeneric<T> {
    // 1.创建泛型变量
    // 不能使用new来创建，因为泛型是不确定的类型，也可能拥有私密的构造方法。
    T t;

    // 2.泛型作为方法的参数
    public void show(T t) {
        System.out.println(t);
    }

    // 泛型作为方法的返回值
    public T getT() {
        return t;
    }
}

public static void main(String[] args) {
  //使用泛型类创建对象
  MyGeneric<String> myGeneric1 = new MyGeneric<String>();
  myGeneric1.t = "tang";
  myGeneric1.show("he");

  MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
  myGeneric2.t = 10;
  myGeneric2.show(20);
  Integer integer = myGeneric2.getT();
}

2. 泛型接口

定义

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能创建泛型静态常量
 */
public interface MyInterface<T> {
    // 创建常量
    String nameString = "tang";

    T server(T t);
}

实现接口，指定泛型

public class MyInterfaceImpl implements MyInterface<String> {
    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

实现接口，继承泛型

/**
 * 实现接口时不确定泛型类
 */
public class MyInterfaceImpl2<T> implements MyInterface<T> {
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

测试

MyInterfaceImpl myInterfaceImpl=new MyInterfaceImpl();
        myInterfaceImpl.server("xxx");
// xxx

MyInterfaceImpl2<Integer> myInterfaceImpl2=new MyInterfaceImpl2<Integer>();
        myInterfaceImpl2.server(2000);
// 2000

3. 泛型方法

/**
 * 泛型方法
 * 语法：<T> 返回类型
 */
public class MyGenericMethod {
    public <T> void show(T t) {
        System.out.println("泛型方法" + t);
    }
}

MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("tang");
myGenericMethod.show(200);
myGenericMethod.show(3.14);

4. 泛型集合

• 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
• 特点：
  • 编译时即可检查，而非运行时抛出异常。
  • 访问时，不必类型转换（拆箱）。
  • 不同泛型指尖引用不能相互赋值，泛型不存在多态。

LinkedList源码：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{//略}

它是一个泛型类，而没有传递，java语法是允许的，这个时候传递的类型是Object类，虽然它是所有类的父类，可以存储任意的类型，但是在遍历、获取元素时需要原来的类型就要进行强制转换。这个时候就会出现一些问题，假如往链表里存储了许多不同类型的数据，在强转的时候就要判断每一个原来的类型，这样就很容易出现错误。