一、泛型接口
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());
}
};