Java基础教程——泛型

2023-01-10 17:49:02

泛型

Generics：泛型，愿意指“无商标的”。

泛型，可以理解为“宽泛的数据类型”，就是将类型由原来的具体的类型泛化。

泛型在建立对象时不指定类中属性的具体类型，而是在声明及实例化对象时由外部指定。泛型可以提高数据安全性。

List中应用了泛型，在编译期对数据类型进行严格 检查，如果类型不匹配，编译无法通过。

示例 :

public interface List<E> extends Collection<E>

E:Element

T:Type

泛型的本质是为了参数化类型,即在不创建新类型的情况下，通过泛型指定的不同类型（类型形参），调用时传入具体的类型（类型实参）。

在使用泛型过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型类

public class 泛型_类 {

	public static void main(String[] args) {

		车<Girl> v = new 车<Girl>();

		v.add(new Girl());

		// 不让上车

		// v.add(new Boy());

	}

}

abstract class Person {

}

class Boy extends Person {

}

class Girl extends Person {

}

class 车<T> {

	public T add(T arg) {

		System.out.println(arg.getClass());

		return arg;

	}

}

泛型接口

泛型接口与泛型类的定义及使用基本相同。

public interface Generator<T> {

    public T getS();

}

泛型接口的两种使用方法（以ArrayList和Scanner为例）：

import java.util.*;

interface IGenerics<E> {

	void m(E e);

}

// 仿照ArrayList<E>，implements List<E>

// 实现类还是泛型

class MyList<E> implements IGenerics<E> {

	@Override

	public void m(E e) {

		List<E> lst = new ArrayList<>();

	}

}

// 仿Scanner类， implements Iterator<String>

// 直接指定泛型为String

class MyScanner implements IGenerics<String> {

	@Override

	public void m(String e) {

		Scanner sc = new Scanner(System.in);

	}

}

public class 泛型接口 {

	public static void main(String[] args) {

		// 定义时未指定类型，实例化需要指定类型

		MyList<Integer> my1 = new MyList<>();

		my1.m(1);

		// 定义时已经指定类型，实例化不用指定

		MyScanner my2 = new MyScanner();

		my2.m("A");

	}

}

泛型方法

泛型定义在修饰符和返回类型之间，在参数列表中使用泛型。

泛型方法主要针对参数有泛型（如集合）的场景，如果把下例的参数List改为数组则和Object没有太大区别

import java.util.*;

public class 泛型方法 {

	public static <T> int find(List<T> lst, T a) {

		int indexOf = -1;

		if (lst != null) {

			indexOf = lst.indexOf(a);

		}

		return indexOf;

	}

	public static void main(String[] args) {

		int find = find(new ArrayList<String>(), "A");

		System.out.println(find);

		// 编译不通过：find(new ArrayList<Integer>(), "A");

	}

}

说明：

泛型的参数类型只能是类类型，不能是简单类型。比如，<int>是不可使用的。

可以声明多个泛型参数类型，比如<T,P,Q…>，同时还可以嵌套泛型，例如：<List<String>>。

泛型的参数类型可以使用extends语句，例如<T extends superclass>。

使用extends语句将限制泛型参数的适用范围，只能是指定类型的子类。

|-例如：<T extends Collection> ，则表示该泛型参数的使用范围是所有实现了Collection接口的calss。如果传入<String>则程序编译出错。

示例【T extends Collection】：

import java.util.*;

public class 泛型extends {

	public static <A extends Collection> void find(A arg1, int arg2) {

	}

	public static void main(String[] args) {

		find(new ArrayList(), 5);

		// 不是Collection的子类，编译不通过：

		// find(new String(), 5);

	}

}

<?>通配符

用于承接不同类型的泛型对象。

不知道使用什么类型接收数据时，使用？通配符。

此时只能接收数据，不能往该集合中存储数据。

import java.util.*;

public class 泛型_通配符 {

	public static void main(String[] args) {

		List<String> lst1 = new ArrayList<String>();

		lst1.add("A");

		List<Integer> lst2 = new ArrayList<Integer>();

		lst2.add(1);

		printList_T(lst1);

		printList_T(lst2);

		System.out.println("----------");

		printList(lst1);

		printList(lst2);

	}

	// 用常规泛型写，比较麻烦

	private static <T> void printList_T(List<T> list) {

		list.add(list.get(0));

		for (int i = 0; i < list.size(); i++) {

			Object o = list.get(i);

			System.out.println(o);

		}

	}

	// 用泛型通配符写简单

	private static void printList(List<?> list) {

		// ?不能写入，此处编译错误：list.add(list.get(0));

		for (int i = 0; i < list.size(); i++) {

			Object o = list.get(i);

			System.out.println(o);

		}

	}

}

通配符界限

<? extends T>：是 “上界通配符（Upper Bounds Wildcards）”，泛型只能是T的子类/本身

<? super T>：是 “下界通配符（Lower Bounds Wildcards）”，泛型只能是T的父类/本身

参见：泛型通配符界限问题: https://www.cnblogs.com/tigerlion/p/10659515.html

定义三个类，Fruit->Apple->RedApple，声明ArrayList，有如下现象：

import java.util.*;

public class 泛型_通配符边界2 {

	public static void main(String[] args) {

		ArrayList<Apple> p1 = new ArrayList<Apple>();

		// 【震惊！装得了苹果，装不了红苹果】

		// ↓Type mismatch:

		// cannot convert from ArrayList<RedApple> to ArrayList<Apple>

		// ArrayList<Apple> p2 = new ArrayList<RedApple>();

	}

}

class Fruit {

}

class Apple extends Fruit {

}

class RedApple extends Apple {

}

解决方案就是

【1.<? extends Fruit>，定类型继承关系的上界】

【2.<? super Apple>，确定类型继承关系的下界】

解决方案如下，照着注释看便是

package ah;

import java.util.*;

// 先定义三个类：水果、苹果、红苹果

class Fruit {

}

class Apple extends Fruit {

}

class RedApple extends Apple {

}

public class 泛型_通配符边界 {

	public static void main(String[] args) {

		ArrayList<Apple> p1 = new ArrayList<Apple>();

		// 【震惊！装得了苹果，装不了红苹果】

		// ↓Type mismatch:

		// cannot convert from ArrayList<RedApple> to ArrayList<Apple>

		// ArrayList<Apple> p2 = new ArrayList<RedApple>();

		// 【1.<? extends Fruit>，定类型继承关系的上界：】

		// 能装Apple以及一切Apple的派生类

		ArrayList<? extends Apple> p3 = new ArrayList<Apple>();

		p3 = new ArrayList<RedApple>();

		// ↓上层的类不接受

		// Type mismatch:

		// cannot convert from ArrayList<Fruit> to ArrayList<? extends Apple>

		// p3 = new ArrayList<Fruit>();

		// 【然而，extends是只读的，不能写入】

		// p3.add(new Apple());

		if (p3.size() != 0) {

			Apple apple = p3.get(0);

		}

		// 【2.<? super Apple>，确定类型继承关系的下界】

		// 能装苹果以及一切苹果的基类

		ArrayList<? super Apple> p4 = new ArrayList<Apple>();

		p4 = new ArrayList<Fruit>();

		p4 = new ArrayList<Apple>();

		// Type mismatch:

		// cannot convert from ArrayList<RedApple> to ArrayList<? super Apple>

		// p4 = new ArrayList<RedApple>();

		// 【可读可写，读出来的是Object类型】

		p4.add(new RedApple());// 子类对象但是可以写进入，因为默认向上转型

		Object object = p4.get(0);

		System.out.println(object);

		// 最后，其实JDK 7之后,后面的<>里什么都不用写

		List<Apple> p2 = new ArrayList<>();

	}

}
上一篇：Java基础2-基本语法


下一篇：no ocijdbc11 in java.library.path linux