泛型问题

[yzk116688]

public T fun(T t){
   return t;
}

这个我理解，如果传入的是User，然后返回User对象

但是下面这个我就不理解了：

public <T> T fun(T t){
   return t;
}

为什么前面还有一个<T>？是什么意思?

[config_man]

说实话，我也一直不明白这个问题。

[若鱼1919]

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

[zhctt]

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

[TillPerfect]

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

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

[dj4kobe]

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

请问这样可以吗.和没有<T>有区别吗?

[KAKUKYOWU]

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这样的基本数据类型。。。

[24K純帥]

都写了好多代码额~

[KAKUKYOWU]

[Quote=引用 5 楼 dj4kobe 的回复:]
class TTT<T>
{
public <T>T get()
{
T t = null;
return t;
}
}

请问这样可以吗.和没有<T>有区别吗?
[/Quote]

当然有区别，我觉得 写<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";
}

[zings]

java 6新特性？

[whd3331933]

留住 有待以后学习

[magicluo]

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

这里时候到点了

如果非泛型类定义一个泛型的方法 就要用你说的

public <T> T fun(T t){
return t;

来说明这个是泛型的方法哦

如果是泛型的类， 泛型参数中已经有声明T了 所以方法返回类型前就不需要 <T>

[evan1027]

受教了！！！

[yzk116688]

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

还是没看明白，能举个实例吗？谢谢^_^

[若鱼1919]

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,方法的参数类型和类的参数类型并不是一个，只不过是恰好重名而已。
	   }
}

[mouer]

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

[lwtprogress]

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

[rypgood]

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

[yzk116688]

[Quote=引用 13 楼 yzk116688 的回复:]
引用 2 楼 goldenfish1919 的回复:
public T fun(T t){
return t;
}
这个方法是在一个泛型类的内部定义的，泛型类本身就说明了这是一个泛型，方法就不用再说明一次了
public <T> T fun(T t){
return t;
}
这个是单独定义的一个泛型方法，当然也可以是在泛型类的内部定义，也可以是在普通的类内部，因此需要<T>来说明……
[/Quote]

这回完全明白了~~彻底清楚了~谢谢，十分感谢~~~~