泛型
使用尖括号 <类型> 说明集合存储的数据类型
书写在返回值前边，定义后边。
import java.util.*;
/*
泛型：JDK1.5 版本以后出现新特性。用于解决安全问题，是一个安全机制。
好处：
1.将运行时期出现问题ClassCastException，转移到了编译时期
方便程序员解决问题。让运行时问题减少，安全
2.避免了强制转换麻烦。
*/
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("abc1");
al.add("abc2");
Iterator<String> it = al.iterator();
while(it.hasNext())
{
String s=it.next();
System.out.println(s);
}
}
}泛型使用
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
LenComparator lc=new LenComparator();
TreeSet<String> ts=new TreeSet<String>(lc);
ts.add("abcdefg");
ts.add("abcde");
ts.add("abcg");
ts.add("abefg");
ts.add("cdefg");
ts.add("efg");
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)
{
if(o1.length()>o2.length())
return 1;
if(o1.length()<o2.length())
return -1;
return o1.compareTo(o2);
}
}泛型类
import java.util.*;
/* class Tool
{
private Worker w;
public void setWorker(Worker w)
{
this.w=w;
}
public Worker getWorker()
{
return w;
}
} */
class Worker
{
}
class Student
{
}
//泛型前做法
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj=obj;
}
public Object getObject()
{
return obj;
}
}
//泛型类
/*
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候
早期定义 Object 来完成扩展
现在定义泛型来完成扩展
*/
class Utils<T>
{
private T t;
public void setObject(T t)
{
this.t=t;
}
public T getObject()
{
return t;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> ut = new Utils<Worker>();
ut.setObject(new Worker());
Worker w=ut.getObject();
/* Tool t=new Tool();
t.setObject(new Worker());
Worker w=(Worker)t.getObject();
Tool t2=new Tool();
t2.setObject(new Student());
Student stu=(Student)t.getObject(); */
}
}泛型方法
在类中函数void之后定义 泛型
该泛型 T只在当前函数内生效.不影响类中其他方法的泛型
import java.util.*;
/* class Demo<T>
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(T t)
{
System.out.println("print:"+t);
}
} */
//泛型类定义的泛型在整个类中有效，如果被方法使用，
//那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
//为了让不同方法可以操作不同类型，而且类型还不确定
//那么可以将泛型定义在方法上。
class Demo
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <T> void print(T t)
{
System.out.println("print:"+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
/* Demo<Integer> d1 = new Demo<Integer>();
d1.show(567);
d1.print(new Integer(555));
Demo<String> d2 = new Demo<String>();
d2.show("abc");
d2.print(new String("haha")); */
Demo d = new Demo();
d.show("haha");
d.show(new Integer(5));
d.print("ok");
}
}泛型类和泛型方法同时定义
class Demo<T>
{
public void show(T t) //show使用类的泛型定义T
{
System.out.println("show:"+t);
}
public <E> void print(E e) //print使用方法的局部泛型定义E,改成T也可以正常使用,和类定义的T是不同的泛型。因为方法名定义的是局部泛型
{
System.out.println("print:"+e);
}
}在main方法中使用下面方式使用该类
Demo<String> d = new Demo<String>();//定义了T是String类型
d.show("haha");
//d.show(new Integer(5));//传入非String类型编译失败
d.print("ok");//传入不同类型不影响
d.print(5);//静态泛型方法
静态泛型方法定义
/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
*/
class Demo<T>
{
public void show(T t)
{
System.out.println("show:"+t);
}
public <T> void print(T e)
{
System.out.println("print:"+e);
}
public static <W> void method(W t)//静态泛型方法
{
System.out.println("method:"+t);
}
}调用方法：
Demo.method("static");泛型接口
泛型定义在接口上
import java.util.*;
interface Inter<T>
{
void show(T t);
}
/* class InterImpl implements Inter<String>
{
public void show(String t)
{
System.out.println("Show:"+t);
}
} */
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("Show:"+t);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
/* InterImpl i= new InterImpl();
i.show("ok"); */
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
}
}输出:
Show:4
泛型限定 ? 占位符
import java.util.*;
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
ArrayList<Integer> al1 = new ArrayList<Integer>();
al1.add(4);
al1.add(5);
al1.add(6);
printColl2(al);
printColl2(al1);
}
public static void printColl(ArrayList<?> al)//使用?代表占位符,不明确具体类型,
{
Iterator<?> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
public static <T> void printColl2(ArrayList<T> al)//使用T可以在函数内对该类型进行操作
{
Iterator<T> it = al.iterator();
while(it.hasNext())
{
T t=it.next();
System.out.println(t);
}
}
}泛型限定1 < ? extends 类型>
泛型的限定:
? extends E: 可以接受 E 类型或者E的子类型,上限
? super E:可以接受E类型或者E的父类型,下限
import java.util.*;
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<Person> al2 = new ArrayList<Person>();
ArrayList<Student> al3= new ArrayList<Student>();
al2.add(new Person("lili"));
al2.add(new Person("nana"));
al3.add(new Student("kiki"));
al3.add(new Student("qqqq"));
printColl3(al2);
printColl3(al3);
}
public static void printColl3(ArrayList<? extends Person> al)//使用? extends 限定类型
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
//Person p=(Person)it.next();
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}输出:
lili
nana
kiki
qqqq
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
