泛型:JDK 1.5 以后出现,用于解决安全问题,是一种类型安全机制。
好处:
1. 运行时出现的问题转移到编译时期,运行时更安全。
2. 避免了强制转换麻烦
泛型格式:通过 <> 定义操作的引用数据类型
通常在集合框架中很常见。
例子:
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
//使用集合时,将集合中存储数据类型传递到<>中即可
TreeSet<Person> ts = new TreeSet<Person>(new MyComparator());
ts.add(new Person("lisa011",23));
ts.add(new Person("sa002",23));
ts.add(new Person("sa002",24));
ts.add(new Person("dsa002",24));
ts.add(new Person("dsa003432",12));
Iterator<Person> it = ts.iterator();
while(it.hasNext())
{
Person p = it.next();
System.out.println(p.getName()+"::"+p.getAge());
}
}
}
class Person implements Comparable<Person>{
private String name;
private int age ;
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
Person(String name,int age)
{
this.name = name;
this.age = age ;
}
public int compareTo(Person o1)
{
if(this.age > o1.age)
return 1;
if(this.age == o1.age)
return this.name.compareTo(o1.name);
return -1;
}
}
class MyComparator implements Comparator<Person>
{
public int compare(Person o1,Person o2)
{
int num = new Integer(o1.getName().length()).compareTo(new Integer(o2.getName().length()));
if(num==0)
return o1.getName().compareTo(o2.getName());
return num;
}
}
泛型类:当类中操作的引用数据类型不确定时,现在可以定义泛型来操作。
泛型类定义的泛型在整个类中有效,如果被方法使用,那么泛型类对象明确操作类型后,所有要操作的类型就固定。
import java.util.*;
class Teacher
{
}
class Student
{
}
class Util<T>
{
private T obj;
public void setObject(T obj)
{
this.obj = obj;
}
public T getObject()
{
return this.obj;
}
}
class GenericDemo2
{
public static void main(String[] args)
{
Util<Teacher> t = new Util<Teacher>();
t.setObject(new Teacher());
//编译时报错,Teacher无法转换成Student
Student stu = (Student)t.getObject();
}
}
为了让不同方法操作不同类型,而且类型不确定,可以将泛型定义在方法上。
import java.util.*;
class GenericDemo3
{
public static void main(String[] args)
{
Util<String> t = new Util<String>();
t.print("sads");
t.out(123);
}
}
class Util<T>
{
public <T> void print(T obj)
{
System.out.println(obj);
}
public <T> void show(T obj)
{
System.out.println(obj);
}
//静态方法不可以访问类上定义的泛型,只能定义在方法上。
public static <T> void out(T obj)
{
System.out.println(obj);
}
}
泛型定义在接口上,类实现接口也定义操作泛型
import java.util.*;
//泛型定义在接口上
interface Inter<T>
{
void show(T t);
}
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println(t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
InterImpl<String> in = new InterImpl<String> ();
in.show("aaa");
}
}
泛型限定:
< ? extends E > 可以接收 E 以及 E 的子类。
< ? super E > 可以接收 E 或 E 的父类
import java.util.*;
class GenericDemo6
{
public static void main(String[] args)
{
TreeSet<Student> al = new TreeSet<Student>(new MyComp());
al.add(new Student("lisa11",23));
al.add(new Student("lisa2",23));
al.add(new Student("lisa3",23));
printCall(al);
TreeSet<Teacher> al2 = new TreeSet<Teacher>(new MyComp());
al2.add(new Teacher("lisa11",23));
al2.add(new Teacher("lisa2",23));
al2.add(new Teacher("lisa3",23));
printCall(al2);
}
// ? 称作为 通配符 或者 占位符
public static void printCall(Collection<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person implements Comparable<Person>{
private String name;
private int age ;
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
Person(String name,int age)
{
this.name = name;
this.age = age ;
}
public int compareTo(Person o1)
{
if(this.age > o1.age)
return 1;
if(this.age == o1.age)
return this.name.compareTo(o1.name);
return -1;
}
}
class Student extends Person
{
Student(String name,int age)
{
super(name,age);
}
}
class Teacher extends Person
{
Teacher(String name,int age)
{
super(name,age);
}
}
// Comparator <? super E>
class MyComp implements Comparator<Person>
{
public int compare(Person o1,Person o2)
{
int num = new Integer(o1.getName().length()).compareTo(new Integer(o2.getName().length()));
if(num==0)
return o1.getName().compareTo(o2.getName());
return num;
}
}