------- <a href="http://www.itheima.com"target="blank">android培训</a>、<a href="http://www.itheima.com"target="blank">java培训</a>、期待与您交流! ----------
泛型
Jdk1.5版本以后出现了这个新特性,它用来解决安全问题,是一个类型安全机制。
泛型格式<>,<>中定义要操作的引用数据类型。
好处:1.将运行时期出现问题ClassCastException转移到了编译时期。方便在编译时就能解决问题,使得运行时更安全高效。
2.避免再进行强制转换
何时使用泛型:当类中要操作的引用数据类型不确定的时候,早期用Object来扩展,现在定义泛型来扩展。比如在集合框架中泛型定义很常见,我们也可以根据需要在自己的类中,方法中使用泛型。
代码示例:
<span style="font-size: 14px;">package com.gzj.io;
/*用到泛型示例
* 定义一个集合,存储字符串,并按照字符串长度进行升序排序*/
import java.util.*;
class </span><span style="font-family: Arial;"><span style="font-size: 14px;"> </span><span style="font-size:12px;">Generic</span></span><span style="font-size: 14px;">
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());
ts.add("abcde");
ts.add("cc");
ts.add("cb");
ts.add("aaa");
ts.add("z");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String s = it.next();//不需要再强转了
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>
{
public int compare(String o1,String o2)//传入的对象也是String类型,与上面比较器保持一致
{
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num==0)
return o1.compareTo(o2);
return num;
}
}</span>
如上代码可以看出,java的迭代器,比较器,集合都是泛型,我们也可以在自定义的类中定义泛型。
代码示例如下:
泛型类
class Utils<QQ>//定义一个工具类,用来操作对象,但什么对象不确定,所以可以加泛型
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
class GenericDemo
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker w = u.getObject();;
}
}<strong style="color: rgb(0, 112, 192);">
</strong>
泛型方法:
泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。
代码示例如下:
class Demo
{
Public<T> void show(T t)
{
System.out.println("show:"+t);
}
Public<Q> void print(Q q)
{
System.out.println("print:"+t);
}
}
class GenericDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
d.show(new Integer(4));
d.print(5);
d.print(“haha”);
}
}
注:可以既有泛型类又有泛型方法
静态方法泛型
代码示例:
class Demo<T>
{
public 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);
}
}
class GenericDemo
{
public static void main(String[] args)
{
Demo <String> d = new Demo<String>();
d.show("haha");
d.print(5);
d.print("haha");
Demo.method("hahahahha");
}
}
接口泛型
1.泛型定义在接口上,实现时再制定类型
interface Inter<T>
{
void show(T t);
}
class InterImpl implements Inter<String>
{
public void show(String t)
{
System.out.println("show :"+t);
}
}
class GenericDemo
{
public static void main(String[] args)
{
InterImpl i = new InterImpl ();
i.show(“haha”);
}
}
2.泛型定义在接口上,类实现时也不明确,方法被调用时再指定
interface Inter<T>
{
void show(T t);
}
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show :"+t);
}
}
class GenericDemo
{
public static void main(String[] args)
{
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
//InterImpl i = new InterImpl();
//i.show("haha");
}
}
泛型限定
当传入的对象类型不确定时,用一个通配符来表示
?extends E:可以接收E类型或E的子类型。上限
?super E:可以接收E 或E的父类型。下限
代码示例如下:
package com.gzj.jihe;
import java.util.*;
class Xianding
{
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<Student1> al1 = new ArrayList<Student1>();
al1.add(new Student1("abc--1"));
al1.add(new Student1("abc--2"));
al1.add(new Student1("abc--3"));
printColl(al1); //ArrayList<? extends Person> al = new ArrayList<Student>();error
}
public static void printColl(ArrayList<? extends Person> al)//把 从存储不同类型元素操作单独封装成一个方法,
{ //这个方法接收的参数类型是接收Person类或他的子类型元素的集合,属上限
Iterator<? extends Person> it = al.iterator();
//泛型限定
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student1 extends Person
{
Student1(String name)
{
super(name);
}
}