一般的类和方法，只能使用具体的类型（基本类型或者自定义的类）。这种情况下要编写可以应用多种类型的代码就有很大的束缚。多态也算是一种泛化机制，将方法的形参设为某个父类，那么继承该父类的任意子类都可以作为参数传入该方法。如果方法的形参是一个接口，任何实现该接口的类都可以满足该方法。有时候即是使用接口对程序的约束性还是太强了，我们需要编写更加通用的代码，使代码能应用于“某种不具体的类型”。
======================================================================
Java在没有泛型之前，泛型程序设计是通过继承来实现的。ArrayList类只维护一个Object引用的数组：
public class ArrayList { //没有泛型之前
private Object[] elementData;
public Object get(int i) {…};
public Object add(Object obj){…};
}
public class GenericTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add(“Generic”);
list.add(“Wolffy”);
list.add(new Person());
for (int i = 0; i < list.size(); i++) {
String name = (String) list.get(i); // 1
System.out.println(“name:” + name);
}
}
}
-
定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Person类型的对象。这是完全允许的，因为此时list默认的类型为Object类型。但是以上代码存在两个问题：
-
获取一个值时必须进行强制类型转换：将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
-
没有错误检查：由于不小心加入了其他类型的值或其他编码原因，使用强制类型装换很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。
-
为了解决以上存在的问题（在编译阶段就可以解决），泛型应运而生，它提供一种更好的解决方案：类型参数
====================================================================
-
泛型的意思是：“适用于许多的类型”，它实现了“参数化类型”的概念。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
-
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
List list = new ArrayList();
list.add(“Wolffy”);
list.add(new Person());//1、在编译阶段，编译器就会报错
for (int i = 0; i < list.size(); i++) {
String name = list.get(i); // 2、不需要强制类型转换
System.out.println(“name:” + name);
- 我们可以看到，使用泛型之后，在//1处加入一个其他类型的对象时会出现编译错误，通过
List<String>直接限定了list集合中只能含有String类型的元素，从而在//2处无须进行强制类型转换，因为此时集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。
注意：泛型只在编译阶段有效。泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型
===================================================================
-
泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法
-
泛型的类型参数必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。如果实例化时，没指明泛型的类型，默认类型为Object类型。
- 泛型类型用于类的定义中，即有一个或者多个类型变量的类，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。
一个简单的泛型类：
//T为变量类型，在实例化泛型类时，必须指定T的具体类型
public class Pair{
private T first;
private T second;
public Pair(){//构造器
};
public Pair(T first, T second) {
this.fist = fist;
this.second = second;
}
public T getFisrt(){
return first;
}
…
public T getSecond(T newValue) {
first = newValue;
}
}
-
Java中使用T来表示任意类型，E来表示集合中的元素，K和V分别表示键和值的类型。
-
泛型类可以有多个类型参数
注意：①泛型的类型参数只能是类类型，不能是基本属性类型；②不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
if(ex_num instanceof Generic<Number>){ }
泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生成器（专门负责创建对象的类）中，一个生成器一般只定义一个next方法，用于产生新的对象。可以看一个例子：
//定义一个泛型接口
public interface Generator {
public T next();
}
当实现泛型接口的类，未传入泛型实参时：
/**
-
未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
-
即：class FruitGenerator implements Generator{
-
如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错：“Unknown class”
*/
class Generator implements Generator{
@Override
public T next() {
return null;
}
}
当实现泛型接口的类，传入泛型实参时：
/**
-
传入泛型实参时：
-
定义一个生成器实现这个接口,虽然只创建了一个泛型接口Generator
-
但是可以为T传入无数个实参，形成无数种类型的Generator接口。
-
在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
-
即：Generator，public T next();中的的T都要替换成传入 的String类型。
*/
public class Generator implements Generator {
private String[] fruits = new String[]{“Apple”, “Banana”, “Pear”};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
上面介绍了泛型类，还可以定义带有参数类型的方法，即泛型方法。定义泛型方法，只需要将泛型参数列表置于方法返回值之前，就像下面：
/**
-
1）泛型参数 可以理解为声明此方法为泛型方法
-
2）只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
-
3）泛型的数量也可以为任意多个
*/
public class GenericMethods {
public void f(T x) {
System.out.println(x.getClass.getName());
}
public static void main(sring[] args) {
GenericMethods gm = new GenericMethods();
gm.f(“”);//java.lang.String
gm.f(1);//java.lang.Integer
gm.f(1.0);//java.lang.Double
gm.f(‘a’);//java.lang.Character
gm.f(gm);//GenericMethods
}
}
-
使用泛型类时必须在创建对象时指定类型参数的值，而使用泛型方法时通常不必指明类型参数 。因为编译器会我们找出具体的类型，可以向调用普通方法一样调用泛型方法。
-
泛型方法使得方法能独立于类而产生变化，无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该使用泛型方法.
4.3.1 泛型方法与可变参数
泛型方法与可变参数列表能够很好的共存：
public class GenericTest {
//使用可变参数的泛型方法
public static void printMsg(T… args) {
for (T t :args) {
System.out.print(t + " ");
}
}
public static void main(String[] args) {
GenericTest.printMsg(“111”, 222, ‘A’, 100.000);
}
}
4.3.2 静态方法与泛型
静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法不能使用泛型类的类型参数；如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
public class StaticGenerator {
…
/**
-
如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
-
即使静态方法要使用泛型类中已经声明过的泛型也不可以。
-
如：public static void show(T t){…},此时编译器会提示错误信息：
“StaticGenerator cannot be refrenced from static context”
*/
public static void show(T t){
}
}
4.3.3 泛型方法总结
-
泛型方法可以在普通类中定义，也可以在泛型类中定义
-
无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该使用泛型方法.
-
static修饰的方法无法访问泛型类的类型参数。所以如果static方法需要使用泛型能力，就必须使其成为泛型方法。
-
在泛型方法中出现了泛型的结构，泛型参数与类的泛型参数没任何关系。即泛型方法所属的类是不是泛型类都没关系。
扫一扫
223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
