public static <T> void iTool(ArrayList<T> al)// 为什么这里需要在函数上声明
                {
                        Iterator<T> it=al.iterator();
                        while(it.hasNext())
                        {
                                T t=it.next();//
                                System.out.println(t);
                        }
                       
                       
                       
                }
               
                        public static void print(ArrayList<? extends Person2> l)
//为什么这里不需要声明  是不是已经明确了类型就不需要声明
                        {
                                Iterator<? extends Person2> i=l.iterator();
                                while(i.hasNext())
                                {
                                        System.out.println(i.next().getName());
                                }
                        }


public static void iteratorTool(ArrayList<?> al)//?不确定传入什么参数是 用通配符? 为什么这里不需要再函数上声明
                {
                        Iterator<?> ir=al.iterator();//注意格式
                        while(ir.hasNext())
                                System.out.println(ir.next());//弊端   不能使用类型特有方法 比如  ir.next().length()  error
                }

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

为了让不同方法可以操作不同类型  而且类型还不确定
那么可以将泛型定义在方法上  
静态方法泛型：
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上


*/  
  
class Demo<T>  
{  
    public void method(T t)  
    {  
        System.out.println("method :"+ t);  
    }  
  
    public static <W> void staticMethod(W w)  
    {  
        System.out.println("staticMethod :"+ w);  
    }  
  
    public <K> void show( K  k)  
    {  
        System.out.println("Show :"+ k);  
    }  
  
    public <Q> void print(Q q)  
    {  
            System.out.println("Print :"+ q);  
    }  
}  
  
class TestDemo  
{  
    public static void main(String [] arags)  
    {  
        Demo<Double> d = new Demo<Double>();  
  
        d.method(3.4);  
         
        d.staticMethod(true);  
  
        d.show("haha");  
  
        d.print(new Integer(4));  
    }  
}  

public static <T> void iTool(ArrayList<T> al)// 为什么这里需要在函数上声明
这个地方声明<T>表示该方法持有一个类型 T ，同时也申明是泛型方法 ，ArrayList<T> 这个则表示你要传入的集合所泛型的对象，同时也明确T是属于什么类型 ----》一般这种方式不是泛型的具体应用，不推荐
  public static void print(ArrayList<? extends Person2> l)
//为什么这里不需要声明  是不是已经明确了类型就不需要声明
这个为什么不需要加<T>，首先： 此方法已经不是泛型方法 其次：? extends Person2 这表是所泛型的对象必须要是Person2 的子类对象
public static void iteratorTool(ArrayList<?> al)//?不确定传入什么参数是 用通配符? 为什么这里不需要再函数上声明  说实话我不觉得 ？ 与object 有什么区别 你也可以理解为 ？就是Object 对象 所以当然没有具体对象的方法  ----------》泛型方法现在在jdk中用的非常少，一般不推荐使用泛型方法
一个简单的具体实例
class Generic {
        /**
         * 泛型方法
         * @param <T> 声明一个泛型T
         * @param c 用来创建泛型对象
         * @return
         * @throws InstantiationException
         * @throws IllegalAccessException
         */
        public <T> T getObject(Class<T> c) throws InstantiationException, IllegalAccessException{
                //创建泛型对象
                T t = c.newInstance();
                return t;
        }
}
/**
* 测试实体模型
*/
public class User {
        private String uid;
        private String pwd;
       
        public String getUid() {
                return uid;
        }
        public void setUid(String uid) {
                this.uid = uid;
        }
        public String getPwd() {
                return pwd;
        }
        public void setPwd(String pwd) {
                this.pwd = pwd;
        }
       
}

/**
* 泛型调用演示
*/
public class GenericTest {
        public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
               
                Generic generic = new Generic();               
                //调用泛型方法
                Object obj = generic.getObject(Class.forName("com.cnblogs.test.User"));
                //判断obj的类型是否是指定的User类型
                System.out.println(obj instanceof User);
        }
}

函数上是否声明泛型，是和你的需求相关的。
如果函数中多次用到泛型，并且每次用到的泛型必须是同一种类型，这个时候就需要在函数上声明。
如果函数中多次用到泛型，泛型的类型不确定，并且不需要都是同一种类型，这个时候就用？通配符。
如果函数中多次用到泛型，并且其中几个用的是同一种类型，另外几个用的是另一种相同类型，这个时候就可以在函数上声明两个泛型。

T在定义是表示任意类型，自定义泛型方法时，传入的参数为任意类型，返回值为参数类型的最大公约数
如：

1. class Demo{
   
2.         public static void main(String[] args){
   
3.                 Number x = add(3.5,3);
   
4.                 Object y = add(3,"abc");
   
5.         }
   
6. 
   
7.         public static <T> T add(T x,T y){
   
8.                 return null;
   
9.         }
   
10. }

复制代码

为了让不同方法可以操作不同类型  而且类型还不确定
那么可以将泛型定义在方法上  
如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

1. public class GenericDao<T> {
   
2.         private T field1;
   
3.         public void save(T obj){}
   
4.         public T getById(int id){}
   
5. }

复制代码

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，如：
GenericDao<String> = null;
new GenericDao<String>();
当使用通配符时，参数值可以是任意的类型，不是<T>在参数实例化后，只能使用T所表示的类型。
使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。