泛型类定义和泛型方法以及泛型限定

1、泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

2、为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。3、特殊之处：
静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。[java] view plain copypackage tan;  
//定义泛型类（要操作的类型不确定）  
class Demo<T>{  
    public void show(T t){  
        System.out.println("show:"+t);  
    }  
    //方法中定义泛型  
    public <Q> void print(Q q){  
        System.out.println("pirnt:"+q);  
          
    }  
    //静态方法中定义泛型  
    public static <G> void method(G g){  
        System.out.println("mentod:"+g);  
    }  
}  
public class GenericDemo1 {  
    public static void main(String[] args) {  
        Demo<String> d=new Demo<String>();  
                    d.show("beijing");  
                  //d.show(6); 编译失败，因为show方法会随着对象的类型，对象是什么类型的，show方法中就只能接受什么类型  
                    d.print(888);//将泛型定义在方法上传什么类型都可以  
                    d.print("tan");  
                    //类名调用静态方法  
                    Demo.method("IT Dreamer");  
          
          
          
          
    }  
}  

4、将泛型定义在接口上[java] view plain copypackage tan;  
//将泛型定义在接口上  
interface Inter<T>{  
    public void show(T t);  
}  
//确定操作类型  
/*class InterImpl implements Inter<String>{ 
    @Override 
    public void show(String t) { 
        System.out.println("show-----"+t); 
         
    } 
}*/  
//方式二：实现接口以后仍然不知操作类型时  
class InterImpl<T> implements Inter<T>{  
    @Override  
    public void show(T t) {  
        System.out.println("show-----"+t);  
          
    }  
}  
public class GenericDemo2 {  
    public static void main(String[] args) {  
        /*InterImpl impl=new InterImpl(); 
        impl.show("Great");*/  
          
        InterImpl<Integer> i = new InterImpl<Integer>();  
        i.show(4);  
          
    }  
}  

5、? 通配符。也可以理解为占位符。[java] view plain copypackage tan;  
import java.util.*;  
public class GenericDemo3 {  
    public static void main(String[] args) {  
        ArrayList<String> al = new ArrayList<String>();  
  
        al.add("abc1");  
        al.add("abc2");  
        al.add("abc3");  
  
        ArrayList<Integer> al1 = new ArrayList<Integer>();  
        al1.add(4);  
        al1.add(7);  
        al1.add(1);  
          
        printColl(al);  
        printColl(al1);  
              
    }  
    //1、不明确类型用占位符表示  
    public static void printColl(ArrayList<?> al){  
        Iterator<?> it = al.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next().toString());  
        }  
    }     
    //2、也可以用下面这种方式：如果T是一个具体类型的话，可以接收并操作具体类型  
    public static <T>void printColl2(ArrayList<T> al){  
        Iterator<T> it = al.iterator();  
        while(it.hasNext())  
        {  
            T t=it.next();  
            System.out.println(t);  
        }  
    }     
}  

6、泛型限定
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。   下限

上限示例：[java] view plain copypackage xiao;  
import java.util.*;  
public class GenericDemo3 {  
    public static void main(String[] args) {  
        ArrayList<Person> al = new ArrayList<Person>();  
        al.add(new Person("tan11"));  
        al.add(new Person("tan13"));  
        al.add(new Person("tan21"));  
        ArrayList<Student> al1 = new ArrayList<Student>();  
        al1.add(new Student("stu01"));  
        al1.add(new Student("stu02"));  
        al1.add(new Student("stu03"));  
  
        printColl(al);  
        System.out.println();  
        printColl2(al);  
        printColl2(al1);  
  
    }  
  
    // 1、只能打印父类类型  
    public static void printColl(ArrayList<Person> al) {  
        Iterator<Person> it = al.iterator();  
        while (it.hasNext()) {  
            System.out.println(it.next().getName());  
        }  
    }  
  
    // 2.既可以打印父类也可以打印子类类型       《 上限》？ extends E: 可以接收E类型或者E的子类型  
    public static void printColl2(ArrayList<? extends Person> al) {  
        Iterator<? extends Person> it = al.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 name;  
    }  
}  
  
class Student extends Person {  
    Student(String name) {  
        super(name);  
    }  
  
}  
/* 
class Student implements Comparable<Person>//<? super E> 
{ 
    public int compareTo(Person s) 
    { 
        this.getName() 
    }*/  

下限示例：[java] view plain copypackage zheng;  
import java.util.Comparator;  
import java.util.Iterator;  
import java.util.TreeSet;  
  
public class GenericDemo5 {  
    public static void main(String[] args) {  
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());  
        ts.add(new Student("abc1"));  
        ts.add(new Student("abc2"));  
        ts.add(new Student("abc3"));  
        Iterator<Student> it = ts.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 name;  
    }  
}  
  
class Student extends Person  
{  
    Student(String name)  
    {  
        super(name);  
    }  
  
}  
class Comp implements Comparator<Person>//<? super E>  
{  
    public int compare(Person s1,Person s2)  
    {  
  
        //Person s1 = new Student("abc1");  
        return s1.getName().compareTo(s2.getName());  
    }  
}  

建立通用的比较器方法[java] view plain copypackage Qiang;  
import java.util.*;  
class GenericDemo4  
{  
    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("abc06"));  
        ts.add(new Student("abc01"));  
          
        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("wabc--03"));  
        ts1.add(new Worker("wabc--02"));  
        ts1.add(new Worker("wabc--06"));  
        ts1.add(new Worker("wabc--01"));  
  
  
        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 p2.getName().compareTo(p1.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);  
    }  
}