JAVA-泛型的简单使用方法以及高级使用

一、通常使用类泛型方法：

1.类泛型方法的使用

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、arrayList方法中迭代使用泛型

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 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);
}

3.使用泛型的限定编写迭代器：

//这就是传说中的泛型限定
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);
}
}

2、为TreeSet编写一个比较器：

//TreeSet方法中比较器
class camp implements Comparator<Fperson>{

public int compare(Fperson arg0, Fperson arg1) {
//这里使用的升序的方法两边交换则为降序
return arg0.getName().compareTo(arg1.getName());
}
}

3、在Main方法中添加内容并且编写一个泛型限定的迭代器：

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());
}
}

最后得到如下结果：

abc1
abc5
acc9
adc2