JAVA 14（泛型）
泛型
jdk1.5之后出现的新特性，用于解决安全问题，防止集合类的各种子类中存有不同类型的对象，导致编译通过，运行出现对象类型转换异常。
好处
1，讲运行时期出现问题ClassCastException,转移到了编译时期，方便与程序员解决问题，安全。
2，避免了强制转换的麻烦。
例1
例2
迭代器，比较器，集合的子类可以定义泛型
例3
泛型类：当累着要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在订阅泛型来完成扩展。
泛型方法：
例4
泛型类定义的泛型，在整个类中有效，如果被方法使用，泛型类的对象明确了类型，方法所操作的类型也就确定了
如果想要让方法操作不同类型的对象，而且类型不确定。可以将泛型定义在方法上。
特殊：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在静态方法上。泛型放在static后，放在返回值类型前面。
泛型接口：自行脑补。
interface xxx<t>
{
}
class int<t> implements xxx<t>
{
}
格式：
通过<>来定义要操作的引用数据类型。
ArrayList<String> al =new ArrayList<String> ();
Iterator<String> it = al.iterator();
在使用java提供的对象时，什么时候使用泛型呢？
通常在集合框架中很常见。其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
举例：
import java.util.*;
public class Test {
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String> ();
al.add("zhangxu1");
al.add("zhangxu2");
al.add("zhangxu3");
al.add("zhangxu4");
Iterator<String> it = al.iterator();
while(it.hasNext())
{
String s =it.next();
sop(s+"...."+s.length());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
在比较器中的应用：
import java.util.*;
public class Test {
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new Com());
ts.add("abcd");
ts.add("dbcde");
ts.add("cbcdf");
ts.add("ebcdg");
ts.add("wbcdh");
ts.add("gbcdi");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String s =it.next();
sop(s);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Com implements Comparator<String>
{
public int compare(String o1,String o2)
{
return o1.length()-o2.length();
}
}
泛型类举例：
import java.util.*;
public class Test {
public static void main(String[] args)
{
tools<String> a = new tools<String>();
a.setObject("AAAA");
String s =a.getObjects();
sop(s);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class tools<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q=q;
}
public QQ getObjects()
{
return q;
}
}
泛型方法：
import java.util.*;
public class Test {
public static void main(String[] args)
{
Demo d = new Demo();
d.show(666);
d.show("666666");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Demo
{
public <T>void show(T t)
{
System.out.println(t);
}
}
泛型限定，把泛型限制在一定的区间内部。
？：通配符，占位符
泛型的限定：
？ extends e：可以接受e类型或者e的子类型 //上限
？ super e：可以接受e类型或者e的父类型 //下限
例子：
打印方法应用了泛型限定，比较器中传入了父类可以比较子类中从父类继承来的属性和方法的返回值。
import java.util.*;
public class Test {
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new Com());
ts.add(new Student("abc03"));
ts.add(new Student("abc02"));
ts.add(new Student("abc06"));
ts.add(new Student("abc01"));
TreeSet<Worker> ts1 = new TreeSet<Worker>(new Com());
ts1.add(new Worker("wwabc03"));
ts1.add(new Worker("wwabc02"));
ts1.add(new Worker("wwabc06"));
ts1.add(new Worker("wwabc01"));
Iterator<Student> it = ts.iterator();
while(it.hasNext())
{
sop(it.next().getname());
}
Iterator<Worker> ww = ts1.iterator();
while(ww.hasNext())
{
sop(ww.next().getname());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void printColl(ArrayList<? extends Persion> al)
{
Iterator<? extends Persion> it = al.iterator();
while(it.hasNext())
{
sop(it.next().getname());
}
}
}
class Persion
{
private String name;
Persion(String name)
{
this.name=name;
}
public String getname()
{
return name;
}
}
class Student extends Persion
{
Student(String name) {
super(name);
}
}
class Worker extends Persion
{
Worker(String name) {
super(name);
}
}
class Com implements Comparator <Persion>
{
public int compare(Persion arg0, Persion arg1)
{
return arg0.getname().compareTo(arg1.getname());
}
}
