Java泛型学习笔记

  泛型是Java5引进的新特征,是类和接口的一种拓展机制,主要实现参数化类型机制。Java的泛型,跟C++的类模板有很多相似的地方,或者说,就是C++类模板的升级版。 泛型类   在开发过程中...

  泛型是Java5引进的新特征,是类和接口的一种拓展机制,主要实现参数化类型机制。Java的泛型,跟C++的类模板有很多相似的地方,或者说,就是C++类模板的升级版。

泛型类

  在开发过程中,我们或许要设计一个“节点”类,在过去,我们需要为int型数据定义一个类,然后再为double类型数据定义一个点类,还需要为String类设计一个类,这样,我们就需要定义好多的类,但其实,这些类有很多相同的地方,他们只是数据的类型不同而已。有了泛型类之后,我们就不需要设计那么多的类了,只需要设计一个类,然后再根据存入的数据的类型决定创建什么类型的对象。比如,例1-1

class Node<T>{
	private T value;
	public Node() {}
	public Node(T value) {
		this.value = value;
	}
	public T getNode() {
		return value;
	}
	public void setNode(T value) {
		this.value = value;
	}
}

  

  通过泛型类,我们可以通过一行简单的代码就可以创建各种不同类型的对象。

Node<Integer> intNode = new Node<Integer>();//创建整型节点
Node<Double> douNode = new Node<Double>();//double节点
Node<String> strNode = new Node<String>();//字符串节点

  怎么样,是不是很方便了?其实不仅仅方便,还比较安全,怎么个安全法呢?

  在上面的代码中,我们创建了intNode对象,它是int类型的,如果我们要调用它的setNode("test"),系统就会在编译的时候给我们报错。从而在编译阶段就保证了类型的安全。

  由于编译器能够从上下文推断出泛型参数的类型,所以从Java se 7开始,在创建泛型类型时可以用菱形语法。上述创建语句可以写成

Node<Integer> intNode = new Node<>();
Node<Double> douNode = new Node<>();
Node<String> strNode = new Node<>();

  按照约定,类型参数名要使用单个大写字母表示,常用的类型参数名有E(表示元素)、K(便是键)、T(表示类型)、N(表示数字)、V(表示值)等。泛型可能有多个类型参数,但是在类或者接口的声明中,每个参数名必须时唯一的。

  好了,现在我们已经认识了泛型类。下面,让我们来看看泛型接口。

  这是Entry接口

public interface Entry<K, V>{
	public K getKey();
	public V getValue();
}

  

class Pair<K, V> implements Entry<K, V>{
	private K key;
	private V value;
	public Pair(K key, V value) {
		this.key = key;
		this.value = value;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public void setValue(V value) {
		this.value = value;
	}
	public K getKey() {
		return key;
	}
	public V getValue() {
		return value;
	}
}

  看到这,也就基本了解Java泛型类是什么了东西了。下面,我们来看看一个例子。

  

class Point<T> {
	T x;
	T y;
	public Point() {}
	public Point(T x, T y) {
		this.x = x;
		this.y = y;
	}
	public T getX() {
		return x;
	}
	public T getY() {
		return y;
	}
	public void setX(T x) {
		this.x = x;
	}
	public void setY(T y) {
		this.y = y;
	}
	public void translate(T x, T y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public String toString() {
		return "(" + x +", " + y + ")";
	}
}
public class test11_01 {
	public static void main(String[] args) {
		Point<Integer> intPoint = new Point<Integer>(3, 5);
		System.out.println(intPoint);
		
		Point<Double> doublePoint = new Point<Double>(3.2, 5.5);
		System.out.println(doublePoint);
		
		Point<String> strPoint = new Point(3.2, 5.5);//这里用String作为类型来创建了一个泛型类对象,但实际上我们日常使用中的并不怎么使用非数字的坐标
		System.out.println(strPoint);
	}
}

  这个程序没有报错,相反,还可以运行。运行结果如下:

(3, 5)
(3.2, 5.5)
(3.2, 5.5)  

  但是,如果我们在最后加上那么一句的话

System.out.println(strPoint.getX());

  结果就是下面这个样子

(3, 5)
(3.2, 5.5)
(3.2, 5.5)
Exception in thread "main" java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.String
	at demo.test11_01.main(test11_01.java:79)

  也就是说,在编译的时候,没有报错,但是在运行的时候发生了错误,这就存在了安全隐患。那要怎样才能解决呢?

  如果我们可以规定,类型参数只能数Number类型,那么在创建泛型类的时候传入的是String类型的时候,就会报错吧。那么,我们要怎么样规定泛型类参数呢?这就要介绍到Java中的有界类型参数了。有界类型参数分为上界,和下界。上界用extends来指定,下界用super来指定。比如上述的二维坐标类

class Point<T>  
/*改成*/
class Point<T extends Number>

就可以在编译的时候就阻止了String类型作为参数来创建对象。

  我们再来看一个例子。假如有以下代码:

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();

  在这个例子中,尽管String类是Object的一个字类,但是,List<Object> 和List<Object>却没有一点关系,如果调用下面的方法的话,会发生编译错误

public static void printList(List<Object> list) {
  for(Object element : list)
    System.out.println(element);
}

  这时候,我们就需要用到通配符(?)将上诉代码改写成

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

 再调用这个静态方法的时候,就不会报错了。使用通配符,表示该方法可以接受的元素是任何类型的List对象。

一般来说,类和方法总是关系紧密的,既然类有泛型类,那么泛型方法,也是存在的。

泛型方法

泛型方法,就是带有类型参数的方法,类的成员和构造方法都可以定义为泛型方法。泛型方法的定义可以是静态的,也可以是非静态的。

比如:

public static <T> void swap(T[] arrary, int i, int j) {
	T temp = arrary[i];
	arrary[i] = arrary[j];
	arrary[j] = temp;
}
  • 发表于 2019-04-30 22:20
  • 阅读 ( 204 )
  • 分类:网络文章

条评论

请先 登录 后评论
不写代码的码农
小编

篇文章

作家榜 »

  1. 小编 文章
返回顶部
部分文章转自于网络,若有侵权请联系我们删除