JAVA-泛型的使用以及泛型限定

一、泛型的简单使用

1、泛型类的使用：</strong></span></p><pre name="code" class="java"><span style="font-size:18px;">class Demo<T>{
	public void Show(T t){
		System.out.println("show:"+t);
	}
	public void Print(T t){
		System.out.println("print:"+t);
	}
}

2、泛型方法的使用：

//泛型方法
class Demos{
	public <T> void Show(T t){
		System.out.println("show:"+t);
	}
	public <T> void Print(T t){
		System.out.println("print:"+t);
	}
}

3、添加数据内容以及编写一个泛型迭代器：

public static void Demo2(){
		ArrayList<String> list =new ArrayList<String>();
		list.add("abc");
		list.add("adc");
		list.add("acd");
		biaoli(list);
		System.out.println("=======================");
		
		ArrayList<Integer> list2 = new ArrayList<Integer>();
		list2.add(3);
		list2.add(6);
		list2.add(5);
		biaoli(list2);
		
	}
	
	//使用<?>表示通配符，也可以理解是通用符
	public static void biaoli(ArrayList<?> list){
		Iterator<?> iterator = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}

在main方法中调用以上内容：

public static void main(String[] args) {
		Demo<String> demo= new Demo<String>();
		demo.Show("diaobao");
		System.out.println("---------------");
		Demos demos = new Demos();
		demos.Show(1);
		demos.Show("爱死你了");
		System.out.println("-----------------");
		Demo2();
	}

得到下面结果：

show:diaobao
---------------
show:1
show:爱死你了
-----------------
abc
adc
acd
=======================
3
6
5
二、泛型的高级使用：泛型限定

/*
 *泛型的高级使用：
 * ? 通配符或者说是通用符
泛型限定：
<? extends E> :可以接送E类型或者E的子类型：上限
<? super E> 可以接收E类型或者E的父类型：下限
 */

例子一：

1、定义两个类，一个子类和一个父类并且子类继承父类，实现父类方法

class FanPerson{
	private String name;
	FanPerson(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

class FamStudent extends FanPerson{

	FamStudent(String name) {
		super(name);
	}
}

2、在main方法中添加数据以及编写泛型迭代器

public class FanXingDemo {
	public static void main(String[] args) {
		ArrayList<FanPerson> al = new ArrayList<FanPerson>();
		al.add(new FanPerson("ai1"));
		al.add(new FanPerson("ai2"));
		al.add(new FanPerson("ai3"));
		printColl(al);
		
		System.out.println("-------");
		
		ArrayList<FamStudent> a1 = new ArrayList<FamStudent>();
		a1.add(new FamStudent("ai---1"));
		a1.add(new FamStudent("ai---2"));
		a1.add(new FamStudent("ai---3"));
		printColl(a1);
	}
	
	//这就是传说中的泛型限定
	public static void printColl(ArrayList<? extends FanPerson> list){
		Iterator<? extends FanPerson> iterator = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next().getName());
		}
	}

得到以下结果：

ai1
ai2
ai3
-------
ai---1
ai---2
ai---3

例子二：使用TreeSet添加数据的泛型限定

1、同样先编写基本类：

class Fperson{
	private String name;
	public Fperson(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}
class Fstudent extends Fperson{
	public Fstudent(String name) {
		super(name);
	}
	
}
class Fwoker extends Fperson{
	
	public Fwoker(String name) {
		super(name);
	}
	
}

   <strong>2、在main方法中数据的添加以及迭代器、TreeSet中比较器的编写</strong>

public static void main(String[] args) {
		TreeSet<Fstudent> set= new TreeSet<Fstudent>(new camp());
		set.add(new Fstudent("abc1"));
		set.add(new Fstudent("adc2"));
		set.add(new Fstudent("acc9"));
		set.add(new Fstudent("abc5"));
		PrintColl(set);
	}
	//迭代器
	public static void PrintColl(TreeSet<? extends Fperson> p){
		 Iterator<? extends Fperson> iterator = p.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next().getName());
		}
	}
}

//TreeSet方法中比较器
class camp implements Comparator<Fperson>{
	
	public int compare(Fperson arg0, Fperson arg1) {
		
		return arg0.getName().compareTo(arg1.getName());
	}

最后输出：

abc1
abc5
acc9
adc2