一、泛型概述

1、什么是泛型？

泛型意味着参数化类型。允许类型（整数、字符串等，以及用户定义的类型）作为方法、类和接口的参数。使用泛型，可以创建使用不同数据类型的类。对参数化类型进行操作的实体（例如类、接口或方法）是泛型实体。

Object是所有其他类的超类，Object 引用可以引用任何对象。这些功能缺乏类型安全性。泛型添加了这种类型的安全功能。

Java 中的泛型类似于 C++ 中的模板。比如HashSet、ArrayList、HashMap等类，就很好的使用了泛型。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

2、类型参数命名约定

按照惯例，类型参数名称是单个大写字母。这与变量命名约定形成鲜明对比，并且有充分的理由：没有这种约定，就很难区分类型变量和普通类或接口名称之间的区别。

最常用的类型参数名称是：

E - 元素（被 Java 集合框架广泛使用，比如上面的ArrayList<E>）

K - 键

N - 数字

T - 类型

V - 价值

S、U、V 等 - 第 2、第 3、第 4 类型

3、使用泛型的优点

1、代码重用：我们可以编写一次方法/类/接口，然后将其用于我们想要的任何类型。

2、类型安全：泛型使错误在编译时出现而不是在运行时出现（在编译时知道代码中的问题总是比让代码在运行时失败更好）。

二、泛型的类型

1、泛型的限制

（1）泛型不能使用基本数据类型

当我们声明泛型类型的实例时，传递给类型参数的类型参数必须是引用类型。我们不能使用基本数据类型，如int、char。

比如下面的代码会导致编译时错误。

Test<int> obj = new Test<int>(20);

但是基本类型数组可以传递给类型参数，因为数组是引用类型。

ArrayList<int[]> a = new ArrayList<>();

（2）避免使用原始类型

public class Box<T> {
    public void set(T t) { /* ... */ }
    // ...
}

参考使用

扫描二维码关注公众号，回复： 13761249 查看本文章

Box<Integer> intBox = new Box<>();

请避免下面的用法

Box rawBox = new Box();

（3）无法创建类型参数的实例

编译错误

public static <E> void append(List<E> list) { 
    E elem = new E(); // 编译时错误
    list.add(elem); 
}

可以通过反射创建类型参数的对象

public static <E> void append(List<E> list, Class<E> cls) throws Exception { 
    E elem = cls.newInstance(); // OK 
    list.add(elem); 
}

List<String> ls = new ArrayList<>();
append(ls, String.class);

（4）不能声明类型为类型参数的静态字段

编译错误示例

public class MobileDevice<T> {
    private static T os;

    // ...
}

（5）不能将 Casts 或instanceof与参数化类型一起使用

编译错误示例

public static <E> void rtti(List<E> list) { 
    if (list instanceof ArrayList<Integer>) { // 编译时错误
        // ... 
    } 
}

（6）不能创建参数化类型的数组

List<Integer>[] arrayOfLists = new List<Integer>[2]; // 编译时错误

（7）无法创建、捕获或抛出参数化类型的对象

编译时错误示例

// 例1：间接扩展 Throwable 
class MathException<T> extends Exception { /* ... */ } // 编译时错误

// 例2：直接扩展 Throwable 
class QueueFullException<T> extends Throwable { /* ... */ // 编译时错误

// 例3：方法不能捕获类型参数的实例：
public static <T extends Exception, J> void execute(List<J> jobs) { 
    try { 
        for (J job : jobs) 
            // ... 
    } catch (T e) { // 编译时错误
        // .. . 
    } 
}

可以在throws子句中使用类型参数

class Parser<T extends Exception> { 
    public void parse(File file) throws T { // OK 
        // ... 
    } 
}

（8）无法重载形式参数类型擦除为相同原始类型的方法

public class Example {
    public void print(Set<String> strSet) { }
    public void print(Set<Integer> intSet) { }
}

2、单参数示例

class Test<T> {
    // 对象
    T obj;
    // 构造函数
    Test(T obj) 
    { 
        this.obj = obj; 
    }

    public T getObject() { return this.obj; }
}
  

class Main {
    public static void main(String[] args)
    {
        // 实例化Integer类型
        Test<Integer> iObj = new Test<Integer>(15);
        System.out.println(iObj.getObject());
  
        // 实例化String类型
        Test<String> sObj
            = new Test<String>("泛型的简单示例");
        System.out.println(sObj.getObject());
    }
}

输出

15
泛型的简单示例

3、多参数示例

class Test<T, U>
{
	T obj1; // T 类型 对象
	U obj2; // U 类型 对象

	// 构造函数
	Test(T obj1, U obj2)
	{
		this.obj1 = obj1;
		this.obj2 = obj2;
	}

	// 打印
	public void print()
	{
		System.out.println(obj1);
		System.out.println(obj2);
	}
}


class Main
{
	public static void main (String[] args)
	{
		Test <String, Integer> obj =
			new Test<String, Integer>("多参数泛型", 15);

		obj.print();
	}
}

输出

多参数泛型
15

三、通用方法

泛型方法是引入自己的类型参数的方法。这类似于声明泛型类型，但类型参数的范围仅限于声明它的方法。允许使用静态和非静态泛型方法，以及泛型类构造函数。

class Test {
	// 泛型方法
	static <T> void genericDisplay(T element)
	{
		System.out.println(element.getClass().getName()
						+ " = " + element);
	}

	// Driver method
	public static void main(String[] args)
	{
		// 调用方法，传递Integer类型参数
		genericDisplay(11);

		// 调用方法，传递String类型参数
		genericDisplay("泛型方法");

		// 调用方法，传递Double类型参数
		genericDisplay(1.0);
	}
}

输出

java.lang.Integer = 11
java.lang.String = 泛型方法
java.lang.Double = 1.0

四、有界类型参数

有时您可能想要限制可用作参数化类型中的类型参数的类型。例如，对数字进行操作的方法可能只想接受 Numbers 或其子类的实例。这就是有界类型参数的用途。

1、有界类型

class Bound<T extends A>
{
	
	private T objRef;
	
	public Bound(T obj){
		this.objRef = obj;
	}
	
	public void doRunTest(){
		this.objRef.displayClass();
	}
}

class A
{
	public void displayClass()
	{
		System.out.println("Inside super class A");
	}
}

class B extends A
{
	public void displayClass()
	{
		System.out.println("Inside sub class B");
	}
}

class C extends A
{
	public void displayClass()
	{
		System.out.println("Inside sub class C");
	}
}

public class BoundedClass
{
	public static void main(String a[])
	{
		Bound<C> bec = new Bound<C>(new C());
		bec.doRunTest();

		Bound<B> beb = new Bound<B>(new B());
		beb.doRunTest();

		Bound<A> bea = new Bound<A>(new A());
		bea.doRunTest();
		
		Bound<String> bes = new Bound<String>(new String());
		bea.doRunTest();
	}
}

说明，最后的Bound<String> bes = new Bound<String>(new String());是编译不过去的。因为类型只限定类型 A 及其子类。

2、多重界限

有界类型参数可以与方法以及类和接口一起使用。

前面的示例说明了使用具有单个边界的类型参数，但类型参数可以具有多个边界。

class Bound<T extends A & B>
{
	
	private T objRef;
	
	public Bound(T obj){
		this.objRef = obj;
	}
	
	public void doRunTest(){
		this.objRef.displayClass();
	}
}

interface B
{
	public void displayClass();
}

class A implements B
{
	public void displayClass()
	{
		System.out.println("Inside super class A");
	}
}

public class BoundedClass
{
	public static void main(String a[])
	{
		Bound<A> bea = new Bound<A>(new A());
		bea.doRunTest();
		
	}
}

具有多个边界的类型变量是边界中列出的所有类型的子类型。如果其中一个边界是一个类，则必须首先指定它。

如果未首先指定 bound A，则会出现编译时错误：

class D <T extends B & A> { /* ... */ } // 编译时错误

3、泛型方法和有界类型参数

编译错误的示例，因为大于运算符 ( > ) 仅适用于原始类型，例如short、int、double、long、float、byte和char。

public static <T> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e > elem)  // compiler error
            ++count;
    return count;
}

但是Long、Integer等均实现了Comparable接口，所以可以使用Comparable<T>接口限定的类型参数。

public interface Comparable<T> {
    public int compareTo(T o);
}

public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e.compareTo(elem) > 0)
            ++count;
    return count;
}

五、泛型、继承和子类型

1、子类型的误区

看一段示例代码，下面的代码编译不过去，是因为Box<Integer>和Box<Double>不是Box<Number>的子类型。

给定两个具体类型A和B（例如Number和Integer），Box<A>与Box<B>没有关系，无论A和B是否相关。MyClass<A>和MyClass<B>的共同父对象是Object。

public class Box<Bumber>{ }

public void boxTest(Box<Number> n) { /* ... */ }

public void test()
{
    boxTest(new Box<Integer>());
}

2、泛型类和子类型

interface PayloadList<E,P> extends List<E> {
  void setPayload(int index, P val);
  ...
}

//下面示例都是List<String>有效的的子类型
PayloadList<String,String>
PayloadList<String,Integer>
PayloadList<String,Exception>

六、类型推断

类型推断是 Java 编译器查看每个方法调用和相应声明以确定使调用适用的类型参数（或参数）的能力。推理算法确定参数的类型，以及分配或返回结果的类型（如果可用）。最后，推理算法试图找到适用于所有参数的最具体的类型。

1、类型推断

泛型方法类型推断，它使您能够像调用普通方法一样调用泛型方法，而无需在尖括号之间指定类型。

Pair<Integer, String> p1 = new Pair<>(1, "apple");

上下文推断，只要编译器可以从上下文推断类型参数，您就可以用一组空的类型参数 () 替换调用泛型类的构造函数所需的类型参数。

Map<String, List<String>> myMap = new HashMap<>();

推断构造函数的参数类型，它推断该泛型类的构造函数的形式类型参数 T 的类型为 String。

class MyClass<X> {
        <T> MyClass(T t) {
            // ...
        }
    }

    public void test()
    {
        MyClass<Integer> myObject = new MyClass<>("");
    }

2、目标类型

// 下面两句都可以，但是第二句是没有必要的，Java SE 7 和 8都有效
List<String> listOne1 = Collections.emptyList();
List<String> listOne2 = Collections.<String>emptyList();

void processStringList(List<String> stringList) {
    // 处理 stringList
}

void test()
{
    //Java SE 7 和 8都有效
    processStringList(Collections.<String>emptyList());
    //Java SE 7中编译不过去， Java SE 8有效
    processStringList(Collections.emptyList());
}

七、通配符

在通用代码中，称为通配符 的问号 ( ? )表示未知类型。通配符可用于多种情况：作为参数、字段或局部变量的类型；有时作为返回类型（尽管更具体的是更好的编程实践）。通配符永远不会用作泛型方法调用、泛型类实例创建或超类型的类型参数。

1、上界通配符

表示可以匹配匹配Foo和 Foo 的任何子类型。

public static void process(List <? extends Foo> list) { /* ... */ }

2、无界通配符

可以使用printList打印任何类型的列表

public static void printList(List<?> list) {
    for (Object elem: list)
        System.out.print(elem + " ");
    System.out.println();
}

3、下限通配符

表示可以匹配匹配Integer和其超类。

public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

八、类型擦除

为了实现泛型，Java 编译器将类型擦除应用于：

1、如果类型参数是无界的，则将泛型类型中的所有类型参数替换为其边界或Object 。因此，生成的字节码只包含普通的类、接口和方法。

2、必要时插入类型转换以保持类型安全。

3、生成桥方法以保留扩展泛型类型中的多态性。

1、擦除泛型类型

在类型擦除过程中，Java 编译器擦除所有类型参数，如果类型参数是有界的，则将每个类型参数替换为其第一个边界，如果类型参数是无界的，则将其替换为Object。

2、擦除通用方法

Java 编译器还会删除泛型方法参数中的类型参数。如果类型参数是无界的，则将其替换为Object。

如果参数是有界的

class Shape { /* ... */ }
class Circle extends Shape { /* ... */ }
class Rectangle extends Shape { /* ... */ }

// 泛型方法
public static <T extends Shape> void draw(T shape) { /* ... */ }

// 被替换为
public static void draw(Shape shape) { /* ... */ }

3、桥接方法

当编译扩展参数化类或实现参数化接口的类或接口时，编译器可能需要创建一个合成方法，称为桥方法，作为类型擦除过程的一部分。您通常不需要担心桥接方法，但如果出现在堆栈跟踪中，您可能会感到困惑，所以需要了解是如何产生的。

泛型类

public class Node<T> {

    public T data;

    public Node(T data) { this.data = data; }

    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}

public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

下面代码运行时会报异常

MyNode mn = new MyNode(5);
Node n = mn;            // 原始类型
n.setData("Hello");     // 这句会报类型转换异常
Integer x = mn.data;

原因是：类型擦除后，Node和MyNode类变为

public class Node {

    public Object data;

    public Node(Object data) { this.data = data; }

    public void setData(Object data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}

public class MyNode extends Node {

    public MyNode(Integer data) { super(data); }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

类型擦除后，方法签名不匹配；Node.setData (T)方法变为Node.setData(Object)。因此，MyNode.setData(Integer)方法不会覆盖 Node.setData(Object)方法。

为了解决这个问题并在类型擦除后保留泛型类型的多态性，Java 编译器生成了一个桥接方法以确保子类型按预期工作。

class MyNode extends Node {

    // 编译器生成的桥接方法
    public void setData(Object data) {
        setData((Integer) data);
    }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }

    // ...
}

桥接方法MyNode.setData(object)委托给原始MyNode.setData(Integer)方法。结果， n.setData("Hello");语句调用了方法 MyNode.setData(Object)，并且 aClassCastException被抛出，因为"Hello"不能强制转换为Integer。

九、例题

1、问：下面的类

class Node<T> implements Comparable<T> {
    public int compareTo(T obj) { /* ... */ }
    // ...
}

这样调用，是否可以编译

Node<String> node = new Node<>();
Comparable<String> comp = node;

答：可以

2、问：给定下面的类

class Shape { /* ... */ }
class Circle extends Shape { /* ... */ }
class Rectangle extends Shape { /* ... */ }

class Node<T> { /* ... */ }

问是否可以编译。

Node<Circle> nc = new Node<>();
Node<Shape>  ns = nc;

答：不可以，因为Node<Circle>不是Node<Shape>的子类型。

3、问：下面的代码是否可以编译？

public class Singleton<T> {

    public static T getInstance() {
        if (instance == null)
            instance = new Singleton<T>();

        return instance;
    }

    private static T instance = null;
}

答：不可以，您不能创建类型参数T的静态字段。

4、问：类型擦除后下面的方法转换成什么？

public static <T extends Comparable<T>> 
    int findFirstGreaterThan(T[] at, T elem) { 
    // ... 
}

答：

public static int findFirstGreaterThan(Comparable[] at, Comparable elem) { 
    // ... 
    }

5、问：类型擦除后下面的类转换成什么？

public class Pair<K, V> {

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey(); { return key; }
    public V getValue(); { return value; }

    public void setKey(K key)     { this.key = key; }
    public void setValue(V value) { this.value = value; }

    private K key;
    private V value;
}

答：

public class Pair {

    public Pair(Object key, Object value) {
        this.key = key;
        this.value = value;
    }

    public Object getKey()   { return key; }
    public Object getValue() { return value; }

    public void setKey(Object key)     { this.key = key; }
    public void setValue(Object value) { this.value = value; }

    private Object key;
    private Object value;
}

6、问：如果编译器在编译时擦除了所有类型参数，为什么还要使用泛型？

答：因为
        Java 编译器在编译时对泛型代码执行更严格的类型检查。
        泛型支持编程类型作为参数。
        泛型使您能够实现泛型算法。

Java基础知识点汇总四泛型

一、泛型概述

1、什么是泛型？

2、类型参数命名约定

3、使用泛型的优点

二、泛型的类型

1、泛型的限制

（1）泛型不能使用基本数据类型

（2）避免使用原始类型

（3）无法创建类型参数的实例

（4）不能声明类型为类型参数的静态字段

（5）不能将 Casts 或instanceof与参数化类型一起使用

（6）不能创建参数化类型的数组

（7）无法创建、捕获或抛出参数化类型的对象

（8）无法重载形式参数类型擦除为相同原始类型的方法

2、单参数示例

3、多参数示例

三、通用方法

四、有界类型参数

1、有界类型

2、多重界限

3、泛型方法和有界类型参数

五、泛型、继承和子类型

1、子类型的误区

2、泛型类和子类型

六、类型推断

1、类型推断

2、目标类型

七、通配符

1、上界通配符

2、无界通配符

3、下限通配符

八、类型擦除

1、擦除泛型类型

2、擦除通用方法

3、桥接方法

九、例题

猜你喜欢

Java基础知识点汇总 四 泛型

一、泛型概述

1、什么是泛型？

2、类型参数命名约定

3、使用泛型的优点

二、泛型的类型

1、泛型的限制

（1）泛型不能使用基本数据类型

（2）避免使用原始类型

（3）无法创建类型参数的实例

（4）不能声明类型为类型参数的静态字段

（5）不能将 Casts 或instanceof与参数化类型一起使用

（6）不能创建参数化类型的数组

（7）无法创建、捕获或抛出参数化类型的对象

（8）无法重载形式参数类型擦除为相同原始类型的方法

2、单参数示例

3、多参数示例

三、通用方法

四、有界类型参数

1、有界类型

2、多重界限

3、泛型方法和有界类型参数

五、泛型、继承和子类型

1、子类型的误区

2、泛型类和子类型

六、类型推断

1、类型推断

2、目标类型

七、通配符

1、上界通配符

2、无界通配符

3、下限通配符

八、类型擦除

1、擦除泛型类型

2、擦除通用方法

3、桥接方法

九、例题

猜你喜欢

Java基础知识点汇总四泛型