您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记
【第10章：泛型】_泛型的其他应用
发布时间：2020-12-22 19:34:19编辑：雪饮阅读（）
泛型接口
泛型不仅仅可以用在形参上做为泛型实例引用传递，也不仅可以用于定义泛型类声明泛型变量处，还可以用于声明泛型接口中。
interface Info<T>{
public T getVar();
}
class InfoTmpl implements Info{
public String getVar(){
return null;
}
}
public class Hello{
public static void main(String args[]){
System.out.println(new InfoTmpl().getVar());
}
}
D:\>javac Hello.java
D:\>java Hello
null
泛型接口及实现的标准
泛型接口及实现可以像上面一样很简单的实现，但是不够装逼，不够权威。
泛型接口的实现标准做法是实现的子类中类也要声明泛型并且implements关键字后面也要声明泛型，包括子类属性、方法的形参、返回值等能用泛型尽量都用泛型。最后子类实例化为对象的时候同样要用泛型构造。
interface Info<T>{
public T getVar();
}
class InfoTmpl<T> implements Info<T>{
private T var;
public InfoTmpl(T var){
this.setVar(var);
}
public void setVar(T var){
this.var=var;
}
public T getVar(){
return this.var;
}
}
public class Hello{
public static void main(String args[]){
System.out.println(new InfoTmpl<String>("kasumi").getVar());
}
}
D:\>javac Hello.java
D:\>java Hello
kasumi
泛型方法
泛型不仅仅用于类、方法形参、接口等还可以用在方法上，称之为泛型方法。
class Demo{
//声明格式 <泛型变量名> 泛型变量名（若和声明的泛型变量名一致则表示接收外部传参的泛型类型）
public <T> T fun(T t){
return t;
}
}
public class Hello{
public static void main(String args[]){
System.out.println(new Demo().fun("kasumi"));
}
}
D:\>javac Hello.java
D:\>java Hello
kasumi
利用泛型方法可以方便调用者自定义传递符合要求的参数类型返回符合条件情况下调用者自定义的泛型类型实例。
class Demo<T extends Number>{
private T var;
public T getVar(){
return this.var;
}
public void setVar(T var){
this.var=var;
}
}
public class Hello{
public static void main(String args[]){
Demo<Integer> i=fun(30);
System.out.println(i.getVar());
}
//泛型方法 泛型变量标识并限定上限 泛型变量并限定指定泛型类
public static <T extends Number> Demo<T> fun(T param){
Demo<T> temp=new Demo<T>();
temp.setVar(param);
return temp;
}
}
D:\>javac Hello.java
D:\>java Hello
30
泛型方法可用于对于输入参数定义一个标准
先看看一个正常的泛型方法应用
class Demo<T>{
private T var;
public T getVar(){
return this.var;
}
public void setVar(T var){
this.var=var;
}
}
public class Hello{
public static void main(String args[]){
Demo<String> s1=new Demo<String>();
Demo<String> s2=new Demo<String>();
s1.setVar("kasumi");
s2.setVar("snowDrink");
add(s1,s2);
}
//泛型方法 泛型变量标识并限定上限 泛型变量并限定指定泛型类
public static <T> void add(Demo<T> l1,Demo<T> l2){
System.out.println(l1.getVar()+" "+l2.getVar());
}
}
D:\>javac Hello.java
D:\>java Hello
kasumi snowDrink
当两个输入的泛型参数类型不一致的时候
class Demo<T>{
private T var;
public T getVar(){
return this.var;
}
public void setVar(T var){
this.var=var;
}
}
public class Hello{
public static void main(String args[]){
Demo<String> s1=new Demo<String>();
Demo<Integer> s2=new Demo<Integer>();
s1.setVar("kasumi");
s2.setVar(24);
add(s1,s2);
}
public static <T> void add(Demo<T> l1,Demo<T> l2){
System.out.println(l1.getVar()+" "+l2.getVar());
}
}
D:\>javac Hello.java
Hello.java:16: 无法将 Hello 中的 <T>add(Demo<T>,Demo<T>) 应用于 (Demo<java.lang.String>,Demo<java.lang.Integer>)
add(s1,s2);
^
1 错误
编译无法通过，没错就只是形参的约束而已
泛型数组
你以为泛型这就完了？不泛型还支持数组的定义。
public class Hello{
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[]){
for(T t:param){
System.out.println(t);
}
}
}
D:\>javac Hello.java
D:\>java Hello
1
2
3
4
5
6
泛型的嵌套
当一个泛型类中的某个属性是另外一个泛型类的实例的时候就形成了泛型嵌套，不过这东西貌似用处不大吧。
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 Hello{
public static void main(String args[]){
Demo<Info<String,Integer>> d = new Demo<Info<String,Integer>>(new Info<String,Integer>("snowDrink",24));
System.out.println("内容一：" + d.getInfo().getVar()) ;
System.out.println("内容二：" + d.getInfo().getValue()) ;
}
}
关键字词：java,泛型
上一篇：【第10章：泛型】_通配符