JAVA——泛型类和泛型方法（静态方法泛型）

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

为了让不同的方法可以操作不同类型，而且类型还不确定。那么
可以将泛型定义在方法上。

泛型类

class Demo<T>{    public void show(T t)    {        System.out.println("show: "+t);    }    public void print(T t)    {        System.out.println("show: "+t);    }}

class GenericDemo4{    public static void main(String[] args)    {        Demo<Integer>d = new Demo<Integer>();        d.show(new Integer(4));        Demo<String>d1 = new Demo<String>();        d1.print("haha");    }}

结果：
show: 4
show: haha

泛型方法

class Demo{    public <T> void show(T t)    {        System.out.println("show: "+t);    }    public <Q> void print(Q q)    {        System.out.println("print:"+q);    }}

class GenericDemo4{    public static void main(String[] args)    {        Demo d = new Demo();        d.show("hello boy!");        d.print("Alex i love you !");    }}

结果：
show: hello boy!
print:Alex i love you !

同时定义泛型类和泛型方法

class Demo<T>{    public void show(T t)    {        System.out.println("show: "+t);    }    public <Q> void print(Q q)    {        System.out.println("print:"+q);    }}class GenericDemo4{    public static void main(String[] args)    {        Demo <String> d = new Demo<String>();        d.show("hello boy!");        d.print("Alex i love you !");        d.print(5);        d.print("heiei");    }}

结果：
show: hello boy!
print:Alex i love you !
print:5
print:heiei

特殊之处：
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo<T>{    public void show(T t)    {        System.out.println("show: "+t);    }    public <Q> void print(Q q)    {        System.out.println("print:"+q);    }    public static <W>void method(W t)    {        System.out.println("method: "+t);    }}class GenericDemo4{    public static void main(String[] args)    {        Demo <String> d = new Demo<String>();        d.show("hello boy!");        d.print("Alex i love you !");        d.print(5);        d.print("heiei");        Demo.method("hihi");    }}

结果：
show: hello boy!
print:Alex i love you !
print:5
print:heiei
method: hihi

泛型定义在接口上

interface Inter<T>{    void show(T t);}//第一种class InterImpl implements Inter<String>{       public void show(String t)    {        System.out.println("show :"+t);    }}/*第二种class InterImpl<T>implements Inter<T>{    public void show(T t)    {        System.out.println("show :"+t);    }}*/class GenericDemo5{    public static void main(String[] args)    {        /*          InterImpl<Integer> i = new InterImpl<Integer>();        i.show(4);        */        InterImpl i = new InterImpl();        i.show("haha");    }}

结果：
show :haha
第一种相对来说就比较死，固定为String类型了。而第二种可以自己定义。