import java.util.*;
/*
泛型:JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制。
好处:
1,将运行时出现的类型准换换错误(ClassCastException)转移到编译时期,程序员刻可以及时发现错误并解决。
2,避免了强制转换的麻烦。
*/
class GenericDemo //泛型
{
public static void main(String[] args)
{
ArrayList<String> al=new ArrayList<String>();
al.add("agdjk");
al.add("agdjk");
al.add("agdjk");
al.add("agdjk");
al.add("agdjk");
//al.add(2);//如果不做泛型处理,在编译时期不会出错,在运行时期会出现类型转换错误,所以存在很严重的安全隐患。
Iterator<String> it=al.iterator();
while(it.hasNext())
{
//String str=(String)it.next(); //使用了泛型就不用再做强制类型转换的操作。
sop(it.next());
}
System.out.println("Hello World!");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
泛型类:
/*
泛型类:
带参数的类。
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型类来完成扩展。
*/
class Worker
{
}
class Student
{
}
class Teacher
{
}
class Utils<QQ> //QQ就是引用类型参数,QQ可以是Worker、Student、Teacher类型的
{
private QQ q;
public void setQQ(QQ q)
{
this.q=q;
}
public QQ getQQ()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> w=new Utils<Worker>();
w.setQQ(new Worker());
Worker ww=w.getQQ();
Utils<Teacher> t=new Utils<Teacher>();
t.setQQ(new Teacher());
Teacher tt=t.getQQ();
//System.out.println("Hello World!");
}
}
泛型类和泛型方法:
class Demo<T> //将泛型定义在类上
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(T t)
{
System.out.println("print"+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 Demo2<T> //泛型类和泛型方法的混合使用。在泛型类中定义泛型方法。
{
public void show(T t)
{
System.out.println("show"+t);
}
public <Q> void print(Q q)
{
System.out.println("print"+q);
}
public static void method(T t) //无法从静态方法上下文中应用非静态变量
{
System.out.println("静态方法:"+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
/*泛型类
Demo<String> d=new Demo<String>();
d.show("String...1");
d.print("String...2");
*/
/*泛型方法
Demo1 d1=new Demo1();
d1.show("String............1");
d1.show(3333);
d1.print("nihao/");
d1.print(2222);
*/
//泛型类和泛型方法
Demo2<String> d2=new Demo2<String>();
d2.show("Hellllllllo");
d2.print("hhhhhhhhhh");
d2.print(456);
d2.method("HEooooooo");
}
}
泛型接口:
/*泛型接口*/
interface Inter<T>
{
void show(T 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(3);
//System.out.println("Hello World!");
}
}
泛型的限定:
import java.util.*;
/*
泛型的限定:
?通配符,也可以理解为占位符。
泛型的限定:
? extends E:可以接收E类型或E的子类型。上限
? super E:可以接收E类型或E的父类型。下限
*/
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class Student extends Person
{
Student(String name,int age)
{
super(name,age);
}
}
class GenericDemo6
{
public static void main(String[] args)
{
//stringDemo();
personDemo();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
///
public static void stringDemo()
{
ArrayList<String> al1=new ArrayList<String>();
ArrayList<Integer> al2=new ArrayList<Integer>();
al1.add("hello1");
al1.add("hello2");
al1.add("hello3");
al2.add(2);
al2.add(3);
al2.add(1);
al2.add(4);
printColl_String(al1);
sop("______________________");
printColl_String(al2);
}
public static void printColl_String(ArrayList<?> al) //类型不明确 //T也可以用“?”来代替。
{
Iterator<?> it=al.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
/
public static void personDemo()
{
ArrayList<Person> al1=new ArrayList<Person>();
ArrayList<Student> al2=new ArrayList<Student>();
al1.add(new Person("person1",20));
al1.add(new Person("person2",25));
al1.add(new Person("person3",30));
al2.add(new Student("student1",10));
al2.add(new Student("student2",11));
al2.add(new Student("student3",12));
printColl_Person(al1);
sop("______________________");
printColl_Person(al2);
}
public static void printColl_Person(ArrayList<? extends Person> al) //
{
Iterator<? extends Person> it=al.iterator();
while(it.hasNext())
{
Person p=it.next();
sop(p.getName()+"..."+p.getAge());
}
}
//
}
泛型实现比较器的通用:
import java.util.*;
//泛型实现比较器的通用。但是需要注意的是比较器中用到的是父类的方法。
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 Worker extends Person
{
Worker(String name)
{
super(name);
}
}
class GenericDemo7
{
public static void main(String[] args)
{
//Student
TreeSet<Student> ts=new TreeSet<Student>(new Comp());
ts.add(new Student("sudent001"));
ts.add(new Student("sudent006"));
ts.add(new Student("sudent003"));
ts.add(new Student("sudent008"));
Iterator<Student> it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
System.out.println("-----------------------------");
//Worker
TreeSet<Worker> ts1=new TreeSet<Worker>(new Comp());
ts1.add(new Worker("worker0028"));
ts1.add(new Worker("worker0033"));
ts1.add(new Worker("worker0090"));
ts1.add(new Worker("worker0027"));
Iterator<Worker> it1=ts1.iterator();
while(it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
//构造比较器
class Comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}