泛型问题

Question

public T fun(T t){
   return t;
}
这个我理解，如果传入的是User，然后返回User对象但是下面这个我就不理解了：
public <T> T fun(T t){
   return t;
}
为什么前面还有一个<T>？是什么意思?

Answer 1

public T fun(T t){
   return t;
}
这个方法是在一个泛型类的内部定义的，泛型类本身就说明了这是一个泛型，方法就不用再说明一次了
public <T> T fun(T t){
   return t;
}
这个是单独定义的一个泛型方法，当然也可以是在泛型类的内部定义，也可以是在普通的类内部，因此需要<T>来说明这是一个泛型方法，T是泛型类型。

Answer 2

public <T> T fun(T t){
return t;
}
<T>是你要指定的类型

Answer 3

class TT
{
    public <T> T get()
    {
        T t = null;
        return t;
    }
}class TTT<T>
{
    public T get()
    {
        T t = null;
        return t;
    }
}

Answer 4

class TTT<T>
{
    public <T>T get()
    {
        T t = null;
        return t;
    }
}请问这样可以吗.和没有<T>有区别吗?

Answer 5

package a;import java.math.BigDecimal;public class Test {    /**
     * 泛型方法
     * 
     * @param <T>
     * @param t
     * @return
     * @author kakukyowu
     */
    public <T> T fun(T t) {        return t;
    }    /**
     * Object方法
     * 
     * @param o
     * @return
     * @author kakukyowu
     */
    public Object fun2(Object o) {        return o;
    }    /**
     * main
     * 
     * @param args
     * @author kakukyowu
     */
    public static void main(String args[]) {        Test test = new Test();        /** 泛型方法 **/
        String str = (String) test.fun("test2222"); // 其实这里不用强转也行，但要求必须参数与返回值是相同的类型
        BigDecimal big = (BigDecimal) test.fun("test2222"); // 如果参数和返回值是不同类型，即便强转也不允许
        System.out.println(str);        /** Object方法 **/
        String str2 = (String) test.fun2("test2222");
        BigDecimal big2 = (BigDecimal) test.fun2(111); // 无论返回值与参数是否一致，只要强转了都可以
    }
}
当然，前提是参数与返回类型都是对象，而不是int这样的基本数据类型

Answer 6

当然有区别，我觉得 写<T>代表任意对象类型，不写<T>就只是代表只是T类型的对象class TTT<T> {    public <T> T get() {        T t = new T();
        TT tt = new TT();        return tt.T;
    }
}class T {    String str = "test333";
}class TT {    String T = "test44444";
}

Answer 7

这里时候到点了如果非泛型类定义一个泛型的方法 就要用你说的public <T> T fun(T t){
   return t;来说明这个是泛型的方法哦如果是泛型的类， 泛型参数中已经有声明T了 所以方法返回类型前就不需要 <T>

Answer 8

class A{
   public <T> T func(T t){//这个方法就是在一个非泛型类内部定义的一个泛型方法
     return t;
 }
}
class B<T>{
 public T func(T t){//这个方法就是在一个泛型类内部定义的一个泛型方法,<T>在类上就已经指明了，所以方法中就不用再说明了
     return t;
 }
}
class C<T>{
  public T func(T t){//这个方法就是在一个泛型类内部定义的一个泛型方法,<T>在类上就已经指明了，所以方法中就不用再说明了
     return t;
 }
 public <E> E func2(E e){//这个方法就是在一个泛型类内部定义的一个泛型方法,方法的泛型类型和类的泛型类型不一样
     return e;
 }
 public <T> T func3(T t){//同func2，只不过恰好同名字而已
     return t;
 }
}
public class FanXing{
   public static void main(String args[]){
       System.out.println(new A().func("hello"));//hello
       System.out.println(new B().func("hello"));//hello,但是编译的时候会有警告：
       //注意：FanXing.java 使用了未经检查或不安全的操作。
         //注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
       System.out.println(new B<String>().func("hello"));//hello,没有警告了
       System.out.println(new C<String>().func("hello"));//hello,没有警告
       //System.out.println(new C<String>().func(new Integer(2)));//编译不通过，泛型约定了是String，但是却传入了一个Integer
       System.out.println(new C<String>().func2(new Integer(2)));//2,因为此时方法的泛型类型跟类的泛型类型不是同一个，实际上，也可以叫T,只是为了防止混淆，看起来方便
       System.out.println(new C<String>().func3(new Integer(2)));//2,方法的参数类型和类的参数类型并不是一个，只不过是恰好重名而已。
   }
}

Answer 9

public class Test {
public T fun(T t){ // 这里不加<T> 出错
   return t;
}
}也可以这么写:
public class Test <T> {
public T fun(T t){ 
   return t;
}
}<T>的作用就是确定T的类型"范围".可以是明确的String,也可以是所有类的父类Object

Answer 10

长见识了啊！以前看的视频里说到泛型主要用的是hasNext()方法进行历遍，Iterator！

Answer 11

public <T> T fun(T t){
是指返回的必须为T类型或者T的子类