Java泛型使用详解

一、泛型接口

  1、第一种：在子类的定义上也声明泛型类型。

package com.xieke.generics.impl.demo1;

interface Info<T>
{ // 在接口上定义泛型
    public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl<T> implements Info<T>
{ // 定义泛型接口的子类
    private T var; // 定义属性

    public InfoImpl(T var)
    { // 通过构造方法设置属性内容
        this.setVar(var);
    }

    public void setVar(T var)
    {
        this.var = var;
    }

    @Override
    public T getVar()
    {
        return this.var;
    }
};

/**
 * 泛型接口实现的两种方式
 * 
 * 第一种：在子类的定义上也声明泛型类型
 * 
 * @author xieke
 *
 */
public class GenericsDemo1
{
    public static void main(String arsg[])
    {
       Info<String> i = null; // 声明接口对象
        i = new InfoImpl<String>("xieke"); // 通过子类实例化对象
        System.out.println("内容：" + i.getVar());
    }
};

   2、第二种：子类不使用泛型声明，在实现接口的时候直接指定好其具体的操作类型。

package com.xieke.generics.impl.demo2;

interface Info<T>
{ // 在接口上定义泛型
    public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl implements Info<String>
{ // 定义泛型接口的子类
    private String var; // 定义属性

    public InfoImpl(String var)
    { // 通过构造方法设置属性内容
        this.setVar(var);
    }

    public void setVar(String var)
    {
        this.var = var;
    }

    @Override
    public String getVar()
    {
        return this.var;
    }
};

/**
 * 泛型接口实现的两种方式
 * 
 * 第二种：子类不使用泛型声明，在实现接口的时候直接指定好其具体的操作类型
 * 
 * @author xieke
 *
 */
public class GenericsDemo2
{
    public static void main(String arsg[])
    {
       Info i = null; // 声明接口对象
        i = new InfoImpl("xieke"); // 通过子类实例化对象
        System.out.println("内容：" + i.getVar());
    }
};

 二、泛型方法

  1、第一种形式：接收任意类型的数据。

package com.xieke.generics.method.demo1;

class Demo
{
    public <T> T fun(T t)
    { // 可以接收任意类型的数据
        return t; // 直接把参数返回
    }
};

/**
 * 定义泛型方法
 * 
 * @author xieke
 *
 */
public class GenericsDemo1
{
    public static void main(String args[])
    {
       Demo d = new Demo(); // 实例化Demo对象
        String str = d.fun("xieke"); // 传递字符串
        int i = d.fun(22); // 传递数字，自动装箱
        System.out.println(str); // 输出内容
        System.out.println(i); // 输出内容
    }
};

   2、第二种形式：指定上限数据类型。

package com.xieke.generics.method.demo2;

class Info<T extends Number>
{ // 指定上限，只能是数字类型
    private T var; // 此类型由外部决定

    public T getVar()
    {
        return this.var;
    }

    public void setVar(T var)
    {
        this.var = var;
    }

    @Override
    public String toString()
    { // 覆写Object类中的toString()方法
        return this.var.toString();
    }
};

/**
 * 通过泛型方法返回泛型类的实例
 * 
 * @author xieke
 *
 */
public class GenericsDemo2
{
    public static void main(String args[])
    {
        Info<Integer> i = fun(22);
        System.out.println(i.getVar());
    }

    public static <T extends Number> Info<T> fun(T param)
    {
        Info<T> temp = new Info<T>(); // 根据传入的数据类型实例化Info
        temp.setVar(param); // 将传递的内容设置到Info对象的var属性之中
          return temp; // 返回实例化对象
    }
};

   3、第三种形式：使用泛型统一传入参数的类型。

package com.xieke.generics.method.demo3;

class Info<T>
{  private T var; // 此类型由外部决定

    public T getVar()
    {
        return this.var;
    }

    public void setVar(T var)
    {
        this.var = var;
    }

    @Override
    public String toString()
    { // 覆写Object类中的toString()方法
        return this.var.toString();
    }
};

/**
 * 使用泛型统一传入参数的类型
 * 
 * @author xieke
 *
 */
public class GenericsDemo3
{
    public static void main(String args[])
    {
        Info<String> i1 = new Info<String>();
        Info<String> i2 = new Info<String>();
        i1.setVar("hujun"); // 设置内容
          i2.setVar("xieke"); // 设置内容
          add(i1, i2);
    }

    public static <T> void add(Info<T> i1, Info<T> i2)
    {
        System.out.println(i1.getVar() + " " + i2.getVar());
    }
};

 三、泛型数组

package com.xieke.generics.array.demo;

public class GenericsDemo
{
    public static void main(String args[])
    {
        Integer i[] = fun1(1, 2, 3, 4, 5, 6); // 返回泛型数组
          fun2(i);
    }

    public static <T> T[] fun1(T... arg)
    { // 接收可变参数
        return arg; // 返回泛型数组
    }

    public static <T> void fun2(T param[])
    { // 输出
        System.out.print("接收泛型数组：");
        for (T t : param)
        {
            System.out.print(t + "、");
        }
    }
};

 四、泛型嵌套

package com.xieke.generics.nest.demo;

class Info<T, V>
{ // 接收两个泛型类型
    private T var;
    private V value;

    public Info(T var, V value)
    {
        this.setVar(var);
        this.setValue(value);
    }

    public void setVar(T var)
    {
        this.var = var;
    }

    public void setValue(V value)
    {
        this.value = value;
    }

    public T getVar()
    {
        return this.var;
    }

    public V getValue()
    {
        return this.value;
    }
};

class Demo<S>
{
    private S info;

    public Demo(S info)
    {
        this.setInfo(info);
    }

    public void setInfo(S info)
    {
        this.info = info;
    }

    public S getInfo()
    {
        return this.info;
    }
};

public class GenericsDemo
{
    public static void main(String args[])
    {
        Demo<Info<String, Integer>> d = null; // 将Info作为Demo的泛型类型
        Info<String, Integer> i = null; // Info指定两个泛型类型
        i = new Info<String, Integer>("xieke", 22); // 实例化Info对象
        d = new Demo<Info<String, Integer>>(i); // 在Demo类中设置Info类的对象
        System.out.println("内容一：" + d.getInfo().getVar());
        System.out.println("内容二：" + d.getInfo().getValue());
    }
};

 

   转载请注明出处: http://xieke90.iteye.com/blog/2310772