/*
泛型:JDK1.5版本之后出现新特性,用于解决安全问题,是
一个类型安全机制。
好处:
1,将运行时期出现的问题ClassCastException,转移到了
编译时期。
2,避免了强制转换麻烦
泛型格式:通过<>来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见。只有见到<>就要定义泛型
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
*/
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class LenComparator implements Comparator<String>
{
public int compare(String s1, String s2)
{
int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
if(num == 0)
return s2.compareTo(s1);
else
return num;
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
class Worker
{}
class Student
{}
//泛型前做法
class Tool
{
private Object obj;
public void setObject(Object w)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
/*泛型类
什么时候定义泛型?
当类中要操作的引用数据类型不确定的时候。
早起定义Objec来完成扩展。
现在定义泛型来完成扩展。
*/
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 Worker);
Worker w = (Worker)t.getWorker();
*/
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*
class Demo<T> //泛型定义在类上
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(T t)
{
System.out.println("println: "+t);
}
}
*/
//泛型类定义的泛型,在整个类中有效,如果被方法使用,
//那么泛型类的对象明确要操作的具体类型后,所有要操作
//的类型就已经固定了,
//为了让不同方法可以操作不同类型,而且类型还不确定。
//那么将泛型定义在方法上
/*
特殊之处:
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上
*/
class Demo1 //泛型定义在方法上
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)
{
System.out.println("print: "+q);
}
}
class Demo<T>//泛型定义在类上和方法上,不冲突
{
public void show(T t)//泛型随类
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)//泛型不随类
{
System.out.println("print: "+q);
}
public static <W> void method(W t)//静态方法定义泛型
{
System.out.println("method: "+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo d = new Demo();
d.show("haha");
d.show(4);
d.print("haha");
d.print(4);
Demo.method("hahah ");
/*
Demo<String> d = new Demo<String>();
d.show("haha");
d.print("hehe");
*/
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//泛型定义在接口上
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<Integer> i = new InterImpl<Integer>();
i.show(4);
/*
InterImpl i = new InterImpl();
i.show("haha");
*/
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*
?通配符。也可以理解为占位符。
泛型限定:
?extends E: 可以接受E类型或者E的子类型。上限。
?super E:可以接受E类型或者E的父类型。下限。
*/
import java.util.*;
class GenericDemo7
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("abc03"));
ts.add(new Student("abc02"));
ts.add(new Student("abc01"));
ts.add(new Student("abc04"));
Iterator<Student> it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
ts1.add(new Worker("wbc--03"));
ts1.add(new Worker("wbc--02"));
ts1.add(new Worker("wbc--01"));
ts1.add(new Worker("wbc--04"));
Iterator<Worker> it1 = ts1.iterator();
while(it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
class Comp implements Comparator<Person>//自定义比较器,泛型为Person
{
public int compare(Person s1, Person s2)
{
return s1.getName().compareTo(s2.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String toString()
{
return "person: "+name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
个人总结:掌握泛型的基本应用,可以自定义泛型,可以将泛型定义在类上、方法上、和接口上,
掌握静态方法定义泛型的使用。泛型定义在方法上注意书写格式,在返回值前,在修饰符后。掌
握泛型限定,向上限定和向下限定。