java--泛型
泛型：
JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
1.将运行时期出现问题ClassCastException，转移到了编译时期。，
方便于程序员解决问题。让运行时问题减少，安全。，
2，避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList<String> a=new ArrayList<String>();
a.add("aaa");
a.add("bbbb");
a.add("ccc");
//a.add(3);
Iterator<String> t=a.iterator();
while(t.hasNext())
{
String s=t.next();
sop(s);
}
}
public static void sop(Object o)
{
System.out.println(o);
}
}
定义泛型类：
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
class Worker
{
}
class Student
{
}
//泛型出现的前做法。
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
//泛型类。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker w = u.getObject();//避免了强转
/*
Tool t = new Tool();
t.setObject(new Student());
Worker w = (Worker)t.getObject();
*/
}
}
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
public class Test16
{
public static void main(String[] args)
{
Demo16<Integer> d=new Demo16<Integer>();
//d.print("fafersdf"); //编译失败
d.print(new Integer(3));
d.print(4);
d.show("gsergdfgvd");
d.show(6);
d.mathod("fewafve");
d.mathod(8);
}
}
class Demo16<T>
{
public void print(T t)
{
System.out.println("print:"+t);
}
public <T> void show(T q)
{
System.out.println("show:"+q);
}
public static <W> void mathod(W w)
{
System.out.println("mathod:"+w);
}
}结果是：
print:3
print:4
show:gsergdfgvd
show:6
mathod:fewafve
mathod:8
泛型定义在接口上。
interface Inter<T>
{
void show(T t);
}
class Impl implements Inter<String>
{
public void show(String t)
{
System.out.println("Impl show :"+t);
}
}
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("InterImpl show :"+t);
}
}
class Test
{
public static void main(String[] args)
{
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
Impl i1 = new Impl();
i1.show("haha");
}
}结果：
InterImpl show :4
Impl show :haha
? 通配符。也可以理解为占位符。
示例1：
import java.util.*;
class Test
{
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(7);
al1.add(1);
printColl(al);
printColl(al1);
printColll(al);
printColll(al1);
printCollll(al);
printCollll(al1);
}
public static void printColl(ArrayList<?> a)
{
Iterator<?> it = a.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
public static void printColll(ArrayList a)//老版本的，不安全
{
Iterator it = a.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
public static <T> void printCollll(ArrayList<T> a)//可以操纵T
{
Iterator<T> it = a.iterator();
while(it.hasNext())
{
T t=it.next();
System.out.println(t);
}
}
}泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限
示例2：
import java.util.*;
class Test
{
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<Student> al1 = new ArrayList<Student>();
al1.add(new Student("abc--1"));
al1.add(new Student("abc--2"));
al1.add(new Student("abc--3"));
printColl(al1);
}
public static void printColl(ArrayList<? extends Person> a)
{
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);
}
}