泛型（二）

对集合中存放元素的类型进行限定，防止后期出错。如果限定某个集合只能存放Person类对象（因为后期会把元素取出来当作Person对象来处理)，这样放其它类型的对象在编译时就会报错。相当于把一个类泛化成很多个不同类型（具体化，限定化）的类。泛型使用的代码如：

List<Person> persons = new ArrayList<Person>;

Map<String,String> m = new
HashMap<String,String>;

在定义泛型类或声明泛型类的变量时，使用尖括号来指定形式类型参数，称为类型形参，在调用时传递的实际类型成为类型实参。类型形参与类型实参之间的关系类似于形式方法参数与实际方法参数之间的关系，只是类型参数表示类型，而不是表示值。

注意：当一个变量被声明为泛型时，只能被实例变量和方法调用，而不能被静态变量和方法调用。原因很简单，参数化的泛型是一些实例。静态成员是被类的实例和参数化的类所共享的，所以静态成员不应该有类型参数和他们关联。

什么时候使用泛型类呢？只要类中操作的引用数据类型不确定的时候，就可以定义泛型类。有了泛型类，省去了曾经的强转和类型转换异常的麻烦。

package cn.hncu.generic.two;

public class Demo2 {

public static void main(String[] args) {

Myvessel<Student> u=new Myvessel<Student>();

Student s=new Student();

// u.setObject("aaa");//编译错误

Myvessel<Object> u2=new Myvessel<Object>();

u2.setObject("aaa");//String 属于Object

u2.setObject(new Work());

// String s=(String)u2;//错误！不能强转

System.out.println();

t1();

//1类上的泛型演示(方法上的泛型和类上的捆绑)

t2();

//2方法上的泛型演示(独立于类上的泛型)

t3();

//3方法上的泛型演示(静态方法上的)

}

private static void t1() {

Myvessel<String> m=new Myvessel<String>();

// m.show1(123);Error类型不同

}

private static void t2() {

Myvessel<String> m=new Myvessel<String>();

m.show2(123);//Error类型不同

}

private static void t3() {

String a = null;

Myvessel.show4(a);//不需要加泛型

Myvessel.show5();

}

}

class Myvessel<E>{

private E e;

public void setObject(E e){

this.e=e;

}

public E getObject(){

return e;

}

public <X> void show2(X e){

System.out.println("show:"+e.toString());

}

public void show1(E e){//不需要加

System.out.println("show:"+e.toString());

}

public <X> E show3(X e){//不需要加

System.out.println("show:"+e.toString());

return (E) e;

}/*

public static void show4(W a){

}错误*/

public static<W> void show4(W a){

}

public static void show5(){

}

}

class Work{

}

class Student{

}

下面演示接口的泛型

//“有泛型的接口”的实现类

/////////////※1※明确具体类型/////////////////

//否则类也要写泛型

class imple implements Inter<String>{

@Override

public void show() {

// TODO Auto-generated method stub

}

}

////////////※2※也不明确具体类型/////////////////

//如果实现类自己也想带泛型并且和接口中的一致，可以写成如下形式

//此处的第一个<C>是类的泛型(形参),第二个<C>是实参

class imple2<X> implements Inter<X>{

@Override

public void show() {

// TODO Auto-generated method stub

}

}

/*错2---“泛型实参”必须是引用类型，基本数据类型不行(如果要用，得用对应的包装类)

class imple3 implements Inter<Integer>{

@Override

public void show() {

// TODO Auto-generated method stub

}

}

*/

class imple4<C> implements Inter<Integer>{//这样也行

@Override

public void show() {

// TODO Auto-generated method stub

}

}