泛型：
JDK1.5版本的新特性，用于解决安全问题，是一个类型安全机制
泛型的好处
1，将运行时期出现的问题ClassCastException转移到了编译时期；便于程序员解决问题，减小安全隐患
2，避免了强转的麻烦，
使用场景：
格式：通过<>来定义要操作的引用数据类型
在集合框架中比较常见，见到<>就定义了泛型，<>就是用来接收类型的；在迭代器，比较器，容器中使用
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
例如描述学生类时复写hashCode()、equals()、compare()方法。HashSet、TreeSet中都可以存入
泛型使用示例
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
TreeSet<String> al = new TreeSet<String>(new LenComparator()); //泛型，只能传入String类对象，否则编译报错
al.add("add1");
al.add("fa2");
al.add("ddgxa3");
al.add("dda3");
Iterator<String> it = al.iterator();//迭代器中使用泛型
while (it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
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; //如要换位将o1、o2换位即可
}
}
泛型类
当类中要操作的引用数据不确定时：早期定义Object完成扩展，而且会在运行时引发安全隐患；需要类型强转现在定义泛型来完成扩展，将错误转移到编译时期，安全隐患会在编译时就排除；而且不用强转类型
示例：
class Worker
{}
class Student
{}
class Utils<haha> //泛型类，作为获取不同对象的工具
{
private haha h;
public void set(haha h)
{
this.h = h;
}
public haha get()
{
return h;
}
}
class GenericDemo2
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.set(new Student()); //定义泛型为Worker，传入Student时编译报错
Worker w = u.get(); //如果不定义泛型，传入Student，编译时正常，运行时抛异常
}
}
泛型类的优点 ：
强大之处在于可以传入任何类型的对象引用，而不需要再定义多个重载函数
泛型类的局限性：
泛型类定义的泛型在整个类中都有效，被方法调用泛型类的对象要操作的类型一旦确定，就固定了，如下示例：
Demo<Integer> d = new Demo<Integer>();//只能操作Integer型，要想操作其他类型必须new一个Demo出来
d.show(new Integer(4));
d.print(9);
Demo<String> s = new Demo<String>();//只能操作String型，否则编译出错
s.show(new String("haha"));
s.print("bbb");
泛型方法
为了让让不同方法可以操作不同的类型，且类型不确定，可以将泛型定义在方法上；打破了泛型类的局限性在泛型类中可以同时存在泛型方法；
该类中的方法如果不自定义泛型就与类的泛型一致，
而如果该类中的方法也定义了泛型，该方法就不受类泛型的限制，可以传入任意对象。
特殊之处：静态方法不可以访问类上的泛型，如果静态方法操作的应用数据类型不确定，就将泛型定义在方法上
示例：
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 <S> void method(S s)//静态方法不能访问类的泛型，泛型类中必须将泛型定义在方法上
{
System.out.println("method:"+s);
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Demo<String> d = new Demo<String>();
d.show("haha");
d.print(6);
d.print("bbs");//访问类的泛型
//d.print(true);可以通过
d.method("hahhaha");//静态
}
}
泛型接口
泛型定义在接口上，作为了解interface Inter<T>
{
void show(T t);
}/*
class Demo implements Inter<String>//泛型的类型确定
{
public void show(String t)
{
System.out.println("show:"+t);
}
}*/
class Demo<T> implements Inter<T> //类型不确定
{
public void show(T t)
{
System.out.println("show:"+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo<Integer> d = new Demo<Integer>();//由调用者来确定类型
i.show();
/* Demo d = new Demo();
d.show("haha");
d.show(4); //类型错误
*/ }
}
泛型限定
高级应用? 通配符，也可理解为占位符，可以传入任意类型
？extends E：可以接受E类型或E的子类型。 上限 <? extends Person>
？ super E ：可以接收E类型或者E的父类型。下限<? super Student>
上限示例：
import java.util.*;
class GenericDemo5
{
public static void main(String[] args)
{
ArrayList<Person> a1 = new ArrayList<Person>();
a1.add(new Person("aaa1"));
a1.add(new Person("aaa2"));
a1.add(new Person("aaa3"));
print(a1);
ArrayList<Student> a2= new ArrayList<Student>();
a2.add(new Student("bbb1"));
a2.add(new Student("bbb2"));
a2.add(new Student("bbb3"));
print(a2); //ArrayList<Person> = new ArrayList<Student>();
}
public static void print(ArrayList<? extends Person> a)//<? extends E>限定为Person和Person的子类
{
Iterator<? extends Person> it = a.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 Student extends Person
{
Student(String name)
{
super(name);
}
}
下限示例：
class Student implements Comparable<Student>//<? super E>
{
public int compareTo(Person s)
{
this.getName();
}
}
class Comp implements Comparator<Person>//下限
{
public int compare(Person s1,Person s2)
{
//Person s1 = new Student("hahha");
return s1.getName().compareTo(s2.getName());
}
}
//在主函数中的操作中：
TreeSet<Student> ts = new TreeSet<Student>(new Comp());//下限可以接收Person及其子类Student
ts.add(new Student("aaa1"));
ts.add(new Student("aaa2"));
ts.add(new Student("aaa3"));泛型下限时用到了对象的多态性，只能访问父类方法，而不能访问子类特有方法；提高扩展性的同时也会有局限性