java 泛型%3c %3e_Java学习笔记_26_泛型概述

泛型概述

在Java中存入容器中的对象再取出时需要转换类型，因为对象加入容器会被转换成Object类型，而取出时要转换成实际类型。但向 下类型转换都 是存在潜在危险的，因此应该尽量避免它们。

Java的泛型：

所谓泛型就是在定义(类、方法、形参、成员变量等等)的时候，指 定它们为通用类型，也就是数据类型可以是任意类型。

泛型为提高大型程序的类型安全和维护带来了很大的潜力。

使用泛型的目的：

· 努力将运行时异常转换成编译时的错误，减少运行时异常的数量。

· 解决模板编程的问题。

1. 泛型的声明：

在定义泛型类的时候，在<>中定义形式类型参数，例如：

Class TestJava、Class TestList、Class TestVector,

其中

K：键，比如映射的键。

V：值，比如Set、List、Map中的值。

E：异常类。

T : 泛型。

在实例化泛型对象的时候，一定要在类名后面指定类型参数的值，如：

Listlist = new ArrayList():

2. 泛型的使用：

1>消除类型的转换：

下面是消除类型转换的例子：

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class CollectionsTest {

public static void main(String[] args) {

// 声明ArrayList对象 ,且list中只能存储String类元素

Listlist = new ArrayList();

// 向数组列表中添加元素

list.add("1abc");

list.add("2def");

list.add("3hij");

list.add("4klm");

// 取得list元素并输出,无须类型转换

System.out.print("输出第四个元素：");

String str = list.get(3);

System.out.println(str);

System.out.println("\n输出列表中的所有元素：");

for (String s : list) {

System.out.println(s);

}

System.out.println();

// 声明一个HashMap对象，指定键的类型为Integer、值的类型为String

Mapmap = new HashMap();

// 向对象中添加元素

map.put(1, "zhao");

map.put(2, "qian");

map.put(3, "sun");

map.put(4, "li");

// 取得键集

Setkeys = map.keySet();

// 由键取得对应的值，并输出

System.out.println("输出： key=value");

for (Integer i : keys) {

String value = map.get(i);

System.out.println(i + "=" + value);

}

}

}

输出结果：

输出第四个元素：4klm

输出列表中的所有元素：

1abc

2def

3hij

4klm

输出： key=value

1=zhao

2=qian

3=sun

4=li

注：

·属性中使用集合时不指定泛型，默认为 ,如定义属性： Listlist=null;

· 泛型不同的引用不能相互赋值。

· 加入集合中的对象类型必须与指定的泛型类型一一致。

2>限制泛型中类型参数的使用：

· >: 允许所有泛型的引用调用。

· Extends Number>: 只允许泛型为Number及Number子类的引用调用。

· Super Number>: 只允许泛型为Number及Number父类的引用调用。

· Extends Comparable>: 只允许泛型为实现Comparable接口的实现类的引用调用。

注：

· 方法参数中使用集合时不指定泛型默认为>.

· 方法参数中 Extends Number&Comparable>这种修饰符是不 支持的。

下面的例子演示限制类型的参数的范围：

import java.util.ArrayList;

import java.util.List;

public class CollectionsTest {

public static void main(String[] args) {

Listl1 = new ArrayList();

l1.add("China");

Listl2 = new ArrayList();

l2.add(99);

Listl3 = new ArrayList();

l3.add(3.3);

Listl4 = new ArrayList();

l4.add(83);

Listl5 = new ArrayList();

l5.add(93.67);

printView(l1);//String类型的泛型对象

printView(l2);//Object类型的泛型对象

printView(l3);//Number类型的泛型对象

printView(l4);//Integer类型的泛型对象

printView(l5);//Double类型的泛型对象

}

//方法参数中使用集合时不指定泛型，默认为>

@SuppressWarnings("rawtypes")

private static void printView(List list) {

for (Object o : list) {

System.out.println(o);

}

}

}

输出结果：

China

99

3.3

83

93.67

(1)当上面例子中的方法变为：

//允许所有的泛型的引用调用

@SuppressWarnings("rawtypes")

private static void printView(List> list) {

for (Object o : list) {

System.out.println(o);

}

}

时，输出结果：

China

99

3.3

83

93.67

可见输出结果是不变的。

(2)当上面例子中的方法变为：

//允许Number及Number的自类的引用调用

@SuppressWarnings("rawtypes")

private static void printView(List extends Number> list) {

for (Object o : list) {

System.out.println(o);

}

}

此时需要注释掉两行：

// printView(l1);//String类型的泛型对象

// printView(l2);//Object类型的泛型对象

运行，

输出结果：

3.3

83

93.67

(3)当上面例子的方法变为：

//只允许实现了Comparable接口的类的引用调用

@SuppressWarnings("rawtypes")

private static void printView(List extends Comparable> list)

{

for (Object o : list) {

System.out.println(o);

}

}

此时需要注释掉两行：

// printView(l2);//Object类型的泛型对象

//printView(l3);//Number类型的泛型对

运行，

输出结果：

China

83

93.67

(4)当上面的例子的方法变为：

// 只允许Number和Number的父类的引用调用

@SuppressWarnings("rawtypes")

private static void printView(List super Number> list) {

for (Object o : list) {

System.out.println(o);

}

}

此时需要注释掉三行：

//printView(l1);// String类型的泛型对象

//printView(l4);// Integer类型的泛型对象

//printView(l5);// Double类型的泛型对象

运行，

输出结果：

99

3.3

3>泛型的方法(也被称为Java中的多态)：

在类的定义中添加一个形式类型参数列表，可以将类泛型化。方法也 可以被泛型化，不管它们所在的类是不是泛型化的。

泛型方法的格式为：

修饰符 泛型 返回类型 方法名 参数表 抛出的异常

泛型的样式有如下几种：

· : 允许所以泛型的引用调用。

· : 只允许泛型为Number及Number子类的引用调用。

· : 只允许泛型为实现了Comparable接口的实现类的引用调用。

· : 只允许泛型为即是Number及Number子类又实现了Comparable几接口的

实现类的引用调用。

注：泛型方法中 super Number>这种修饰符是不支持的。

下面是泛型方法使用的例子：

import java.util.ArrayList;

import java.util.List;

public class CollectionsTest {

public static void main(String[] args) {

//声明各类的对象

Listl1 = new ArrayList();

Listl2 = new ArrayList();

Listl3 = new ArrayList();

Listl4 = new ArrayList();

Listl5 = new ArrayList();

//创建各类的数组

String[] a1 = new String[1];

a1[0] = "a1";

Object[] a2 = new Object[1];

a2[0] = "Object";

Number[] a3 = new Number[1];

a3[0] = 3;

Integer[] a4 = new Integer[1];

a4[0] = 4;

Double[] a5 = new Double[1];

a5[0] = 5.5;

//将相同类的数组copy到对象

copyFromArray(l1, a1);

copyFromArray(l2, a2);

copyFromArray(l3, a3);

copyFromArray(l4, a4);

copyFromArray(l5, a5);

//显示对象元素

printView(l1);

printView(l2);

printView(l3);

printView(l4);

printView(l5);

}

//显示方法

private static void printView(List> l) {

for (Object o : l) {

System.out.println(o);

}

}

//copy的方法

private static void copyFromArray(Listl, T[] a) {

for (T o : a)

l.add(o);

}

}

输出结果：

a1

Object

3

4

5.5

4>泛型类：

泛型类的写法：

class Person{

public void show(E e) {

System.out.println(e);

}

public E get() {

return null;

}

}

编写泛型类的时候要注意：

·静态方法中不能使用类的泛型，原因是泛型类中的泛型在创建类的对象时被替换成确定的类型。

静态方法可以通过类名直接访问，而Java是一种强类语言，没有类型的变量或对象是不允许存在的，

所以静态方法中不能使用类的泛型。

·不要创建泛型类的对象，因为泛型类有可能是一个接口或抽象类，如果不是接口或抽象类则可以创建。

·不能在Catch字句中使用泛型，因为编译时，如果try子句抛出的 是一检查的异常，编译器无法确定Catch能否不活这个异常。

下面是演示泛型类创建的技巧的例子：

类TestGenrics中的代码：

public class TestGenrics {

public static void main(String[] args) {

@SuppressWarnings({ "rawtypes" })

MyClass> test = new MyClass();

test.show();

MyClassstr = new MyClass();

str.method("323");

str.show();

MyClassi = new MyClass();

i.method(323);

i.show();

}

}

泛型类MyClass中的代码：

class MyClass{

private T t;

public void method(T t) {

this.t = t;

}

public T method1() {

return null;

}

public void show(){

System.out.println(t);

}

}

输出结果：

null

323

323