java中的泛型浅析

泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。可以简化程序代码，降低程序日后的维护成本。

java中的泛型就像c++中的template，在最后放了c++中template的使用，有兴趣的可以看看。

先看两个例子：

泛型类

package pc;
//  定义一个bug的兄弟 泛型八嘎类
class Baga<T1, T2> {
    private T1 lala;  // T1类型的拉拉
    private T2[] duoduo;    // T2类型的多多集合

    public Baga() {
    }

    public Baga(T1 lala) {
        this.lala = lala;
    }

    public void setDuoduo(T2[] duoduo) {
        this.duoduo = duoduo;
    }
    
	public void setLala(T1 lala) {
        this.lala = lala;
    }

    public T1 getLala() {
        return lala;
    }
}

public class demo1 {
    public static void main(String[] args) {
        // 设T1为Integer类型  T2为String类型
        Baga<Integer, String> baga0 = new Baga<Integer, String>(); 
        Baga<Integer, String> baga1 = new Baga<>();  // 可以省略后面<>中的内容 编译器可以自动推断类型 
        baga1.setLala(6);
        System.out.println(baga1.getLala());
        
        // 设 T1为Character
        Baga<Character, String> baga2 = new Baga<>();
        baga2.setLala('a');
        System.out.println(baga2.getLala());
    }
}
// 结果为 ：
// 6
// a

​

泛型方法

package pc;

public class demo2 {
    public <T> void myPrint(T lala){
        System.out.println(lala);
    }

    public static void main(String[] args) {
        demo2 d = new demo2();
        d.<Integer>myPrint(5);
        d.myPrint(5);    //可以省略<Integer> 编译器可以自动推断类型
    }
}

// 结果为 ：
// 5
// 5

• <>里一般是 T (Type)，也可以是别的，如E、K、V
• 常用的被泛型化的集合类：ArrayList<E>, HashMap<K,V>,HashSet<E>,Vector<E>
• 可以使用泛型声明一个数组，但不能使用泛型建立数组实例，private T[] array=new T[10]; 是错误的
• 泛型的类型参数只能是类类型，不能是简单类型，比如int就不行，得是Integer
• 可以继承泛型类和实现泛型接口，但是子类的泛型数量需要大于等于父类
• 单独的T 代表一个类型 ，而 Class<T>代表这个类型所对应的类， Class<？>表示类型不确定的类

限制泛型类型

1、通过类型参数T的继承限制泛型类型：class 类名称<T extends 接口或类>

例：

class Limit<T extends List>{   // 这的Limit类的泛型类型必须是实现了List接口的类型

}

public class demo3 {
    
    public static void main(String[] args){
        Limit<ArrayList> l = new Limit<ArrayList>(); //ArrayList实现了List接口，如果这是一个没有实现List的泛型类型则会报错
    }
}

2、通过类型通配符的继承限制泛型类型：泛型类名称<? extends 接口或类>

例：

class Limit1<T> {

}

public class demo4 {
    public static void main(String[] args) {
        Limit1<? extends List> l = null;  // 限制泛型类型必须是实现了List接口的类型
        l = new Limit1<ArrayList>();
//        l = new Limit1<HashMap>();  报错
    }
}

例：放置在参数中

public void setCombinerClass(Class<? extends Reducer> cls) throws IllegalStateException {
  ensureState(JobState.DEFINE);
  conf.setClass(COMBINE_CLASS_ATTR, cls, Reducer.class);
}
/* 这是org.apache.hadoop.mapreduce.Job里的一个方法
 * 要求使用setCombinerClass方法时，传入的参数必须是继承了Reducer类的类型
 */

• 使用通配符的声明的名称实例化的对象不能对其加入新的信息,只能获取或删除
• 上面都是向下限制，还可以向上限制，A<? super List> a = null   这的a只接受List接口或List的上层类型

=====================================================================================================

以前用c++写的

模板类：（这个好像是照着人家的代码写的）

#include <iostream>
using namespace std;

/**
 * 定义一个矩形类模板Rect
 * 成员函数：calcArea()、calePerimeter()
 * 数据成员：m_length、m_height
 */
template<typename T>
class Rect
{
public:
	Rect(T length, T height); 
    T calcArea();
    T calePerimeter();
    
	T m_length;
	T m_height;
};

/**
 * 构造函数
 */
template<typename T>  //如果在类里直接写出函数体的话就不需要在声明一次 template<typename T> 了
Rect<T>::Rect(T length, T height)
{
	m_length = length;
	m_height = height;
}

/**
 * 面积方法实现
 */
template<typename T>
T Rect<T>::calcArea()
{
	return m_length * m_height;
}

/**
 * 周长方法实现
 */
template<typename T>
T Rect<T>::calePerimeter()
{
	return ( m_length + m_height) * 2;
}

int main(void)
{
	Rect<int> rect(3, 6);
	cout << rect.calcArea() << endl;
	cout << rect.calePerimeter() << endl;
	return 0;
}

模板函数

#include<iostream>
using namespace std;

template<typename T, class S>    // typename 和 class 效果一样
void display(T t, S s){
	cout<<t<<endl;
	cout<<s<<endl;
} 

template<typename T, int I>
void display(T t){
	cout<<t<<endl;
	cout<<I<<endl;
}

int main(){
	display<int ,char>(6,'h');
	display<int ,int>(5,5);
	display<int ,3>(4);
}

本文部分参考《java从入门到精通》明日学院编著