Java基础--泛型

凌风博客原创作品。转载请注明出处http://blog.csdn.net/q549130180/article/details/45198649

泛型:JDK1.5 版本以后出现新特性，用于解决安全问题，是一个类型安全机制

好处

1.将运行时期出现问题ClassCastException，转移到了编译时期

方便于程序员解决问题，让运行时期问题减少，安全

2.避免了强制转换麻烦

泛型格式：通过<>来定义要操作的引用数据类型

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见

只要见到<>就要定义泛型

其实<>就是用来接收类型的

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

代码实现如下：

[java] view
plaincopy





class GenericDemo

{

public static void main(String[] args)

{

ArrayList<String> al = new ArrayList<String>();

al.add("abc01");

al.add("abc02");

al.add("abc03");

//al.add(4);

Iterator<String> it = al.iterator();

while (it.hasNext())

{

String s = it.next();

System.out.println(s+":"+s.length());

}

}

}

泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候

早期定义Object来完成扩展

现在定义泛型来完成扩展

代码实现入下：

[java] view
plaincopy





class Utils<QQ>

{

private QQ q;

public void setObject(QQ q)

{

this.q = q;

}

public QQ getObject()

{

return q;

}

}

class GenericDemo2

{

public static void main(String[] args)

{

Utils<Worker> u = new Utils<Worker>();

u.setObject(new Student());

Worker w = u.getObject();

/*

Tool t = new Tool();

t.setObject(new Student());

Worker w = (Worker)t.getObject();

*/

}

}

泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

为了让不同方法可以操作不同类型，而且类型还不确定

那么可以将泛型定义在方法上

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

[java] view
plaincopy





class Demo<T>

{

public <T> void show(T t)

{

System.out.println("show:"+t);

}

public <Q> void print(Q q)

{

System.out.println("print:"+q);

}

public static <w> void method(w t)

{

System.out.println("method"+t);

}

}

public class GenericDemo3

{

public static void main(String[] args)

{

Demo <String> d = new Demo<String> ();

d.show("haha");

//d.show(4);

d.print(5);

d.print("hehe");

Demo.method("hahahahahha");

}

}

泛型接口

[java] view
plaincopy





interface Inter<T>

{

void show(T t);

}

class InterImpl<T> implements Inter<T>

{

public void show(T t)

{

System.out.println("show:"+t);

}

}

class GenericDemo4

{

public static void main(String[] args)

{

InterImpl<Integer> i = new InterImpl<Integer>();

i.show(4);

}

}

泛型限定

?:通配符，也可以理解为占位符

泛型的限定：

? extends E:可以接收E类型或者E的子类型，上限。

? super E:可以接收E类型或者E的父类型，下限。

[java] view
plaincopy





class genericDemo5

{

public static void main(String[] args)

{

ArrayList<Person> al = new ArrayList<Person>();

al.add(new Person("abc1"));

al.add(new Person("abc2"));

al.add(new Person("abc3"));

//printColl(al);

ArrayList<Student> al1 = new ArrayList<Student>();

al1.add(new Student("abc--1"));

al1.add(new Student("abc--2"));

al1.add(new Student("abc--3"));

printColl(al1);

}

public static void printColl(ArrayList<? extends Person> al)

{

Iterator<? extends Person> it = al.iterator();

while (it.hasNext())

{

System.out.println(it.next().getName());

}

}

}

class Perosn

{

private String name;

Person(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

}

class Studnet extends Person

{

Student(String name)

{

super(name);

}

}