《Java编程思想》读书笔记：泛型

Java的泛型学习备忘。

github：

【 https://github.com/cstriker1407/think_in_java 】

简单的一个泛型类

public class GenericClass<T>
{
        public GenericClass(T item)
        {
                super();
                this.item = item;
        }
        private T item;
        public T getItem()
        {
                return item;
        }
        public void setItem(T item)
        {
                this.item = item;
        }
}

调用方式

private static void GenericLearn()
{
       GenericClass<Integer> genInt = new GenericClass<Integer>(1);
       GenericClass<String> genStrClass = new GenericClass<String>("Hello");        
}

简单的一个泛型方法

public class GenericFuns
{
        public static <T> T fun(T [] a)//泛型类的类型参数(<T>) 是紧贴着类名的后面，而泛型方法的类型参数(<T>) 是紧贴着方法声明的返回类型的前面。
        {
                return a[0];
        }
        
        public static <T,U> String fun2(T [] a,U [] u)
        {
                T itemT = a[0];
                U itemU = u[0];
                return itemT.toString() + "    " + itemU.toString();
        }
        
        public static void callFun()
        {
                String [] arrs = new String[]{"a","b"};
                System.out.println( GenericFuns.fun(arrs) );
                System.out.println( GenericFuns.<String>fun(arrs) );
                
                System.out.println( GenericFuns.fun2(new Float[]{1.0f}, new Integer[]{1}) );
                System.out.println( GenericFuns.<Float,Integer>fun2(new Float[]{1.0f}, new Integer[]{1}) );
                
        }
}

比较复杂的一种泛型，同时含有接口和父类。

1）先看下具体的类

abstract class BaseClass{
        public abstract int getInt();
        
}
interface BaseInterFace
{
        public String getStr();
}
class TestClass extends BaseClass implements BaseInterFace
{

        @Override
        public String getStr()
        {
                return "TestClass";
        }

        @Override
        public int getInt()
        {
                return 1000;
        }

        @Override
        public String toString()
        {  return "TestClass";
        }
        
}

 2）泛型的定义

public class GenericExtends
{
        public static <T extends BaseClass> int fun1(T item)
        {
                return item.getInt();
        }

        public static <T extends BaseInterFace> String fun2(T item)
        {
                return item.getStr();
        }

        /*
         * 这里只表示到时的具体类型 T 是 Comparable 的一种类型，extends 后是接口，还是类都是用 extends 关键字，不在此区分接口还是类，只表示 Is-A 的关系。 
         * 如果在泛型实现中会调用到多个方法，要求泛型参数同属不同的类型，就 extends 多个接口或类，中间用 & 符号隔开。
         */
        public static <T extends BaseClass & BaseInterFace> void fun3(T item)
        {
                System.out.println(item.toString());
        }
        
        
        public static void callFun()
        {
                GenericExtends.fun1(new TestClass());
                GenericExtends.fun2(new TestClass());
                GenericExtends.fun3(new TestClass());
                
                GenericExtends.<TestClass>fun1(new TestClass());
                GenericExtends.<TestClass>fun2(new TestClass());
                GenericExtends.<TestClass>fun3(new TestClass());
        }
}

 备注：

1）泛型其实很复杂，尤其是里面的类型擦除和通配符，后面会单独记录备忘。