泛型概述
一、概述 泛型:JDK1.5版本以后出现的新特性。用于解决安全问题,是一个安全机制。二、好处 1.将运行时期出现的问题ClassCastException,转移到了编译时期。 方便与程序员解决问题。让运行时问题减少,更加安全。
2.避免了强制转换的麻烦。
三、代码
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> a1=new ArrayList<String>();
a1.add("abc01");
a1.add("abc0991");
a1.add("abc");
Iterator<String> it=al.iterator();
while(it.hasNext())
{
String s=it.next();
}
}
}
泛型类
一、概述泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型,而且类型还不确定,可以将泛型定义在方法上,如下一节所示。二、代码
class Worker
{
}
class Utils<QQ>
{
private QQ q;
public void set(QQ q)
{
this.q=q;
}
public QQ get()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u=new Utils<Worker>();
u.set(new Worker());
Worker w=u.get();
}
}
泛型方法
一、代码(泛型方法)泛型定义在方法上时放在—— 修饰符的后面,返回值类型的前面泛型方法的使用之前,需要在方法上定义,否则不可以使用。class Demo二、代码(泛型类中的泛型方法)
{
public <T> void show(T t)
{
System.out.println(t);
}
public <Q> void print(Q q)
{
System.out.println(q);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo d=new Demo();
d.show("haha");
d.show(1);
d.print("hehe");
}
}
class Demo<T>
{
public void show(T t)
{
System.out.println(t);
}
public <Q> void print(Q q)
{
System.out.println(q);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo d=new Demo();
d.show("haha");
d.show("hehe");
d.print(1);
}
}
三、代码(泛型类中的静态方法泛型)
class Demo<T>
{
public void show(T t)
{
System.out.println(t);
}
public <Q> void print(Q q)
{
System.out.println(q);
}
public static<W> void method(W w)//静态方法不可以访问类上定义的泛型。只可以在方法上定义泛型。
{
System.out.println("method"+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo d=new Demo();
d.show("haha");
d.show("hehe");
d.print(1);
Demo.method("hahahah");
}
}
泛型接口
一、代码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
{
public static void main(String[] args)
{
InterImpl<Integer> i=new InterImpl<Integer>();
i.show(1);
}
}
泛型限定
一、通配符(?)import java.util.*;二、泛型限定
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> a1=new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a2=new ArrayList<Integer>();
a2.add(4);
a2.add(5);
a2.add(6);
printColl(a1);
printColl(a2);
printColl1(a1);
printColl1(a2);
}
/*以下两种方法都可以*/
/*①*/public static void printColl(ArrayList<?> al)//ArrayLise<String> a1=new ArrayList<Integer>();是错误的,类型不匹配。
{
Iterator<?> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
//System.out.println(it.next().length());//不可以使用,因为不是每个对象都有length()方法。
System.out.println(it.next().toString());//可以使用,因为每个对象都有这个方法。
}
}
/*②*/public static<T> void printColl1(ArrayList<T> al)
{
Iterator<T> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
1. ? extends E 限定类型是E或者E的子类。(上限)
import java.util.*;2. ? super E 限定类型是E或者E的父类。(下限)
class GenericDemo7
{
public static void main(String[] args)
{
ArrayList<Person> a1=new ArrayList<Person>();
a1.add(new Person("abc"));
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
printColl(a1);
ArrayList<Student> a2=new ArrayList<Student>();
a2.add(new Student("abc___"));
a2.add(new Student("abc___1"));
a2.add(new Student("abc___2"));
printColl(a2);//ArrayList<Person> a1=new ArrayList<Student>();不可以,必须是相同类型
}
public static void printColl(ArrayList<? extends Person> p)
{
Iterator<? extends Person> it=p.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 this.name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
import java.util.*;
class GenericDemo8
{
public static void main(String[] args)
{
TreeSet<Student> ts=new TreeSet<Student>(new Com());//根据TreeSet构造方法,可以使用Student的父类的比较器来对Student进行比较。
ts.add(new Student("zhangsan3"));
ts.add(new Student("zhangsan2"));
ts.add(new Student("zhangsan1"));
Iterator<Student> it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Com implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Comp implements Comparator<Student>
{
public int compare(Student p1,Student p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}