Java中泛型的各种使用
Java中的泛型的使用:
1.普通的泛型使用 在使用类的时候后面的<>中的类型就是我们确定的类型。 public class MyClass1<T> {//此处定义的泛型是T
private T var; public T getVar() {
return var;
} public void setVar(T var) {
this.var = var;
}
}
/**
* 最普通的泛型使用,只有一个泛型类型
*/
@Test
public void testMyClass1() {
MyClass1<String> clazz = new MyClass1<String>();//此事确定对象对应的泛型T是String
clazz.setVar("stringType");
String str = clazz.getVar();
System.out.println(str);
} 和普通的泛型使用基本一样,只是我们可以在使用类的时候定义两个不同的泛型类型,当然我们也可以定义多个,只要我们业务需要。 public class MyClass2<K, V> {//此处定义两个泛型类型
private K var1;//第一个变量的类型是K对应的具体类型
private V var2;//第二个变量的类型是V对应的具体类型 public K getVar1() {
return var1;
} public void setVar1(K var1) {
this.var1 = var1;
} public V getVar2() {
return var2;
} public void setVar2(V var2) {
this.var2 = var2;
} } /**
* 含有两个泛型类型的使用
*/
@Test
public void testMyClass2() {
//此处确定定义的clazz对象的第一个泛型类型是Integer,第二个泛型类型是String
MyClass2<Integer, String> clazz = new MyClass2<Integer, String>();
clazz.setVar1(1); //此处只能用int类型的参数
clazz.setVar2("string");//此处只能用String类型的参数 System.out.println(clazz.getVar1() + "," + clazz.getVar2());
} 这里面又包含3种:没限制的通配符、使用extends限制、使用super限制 public class MyClass3<T> {
private T var; public T getVar() {
return var;
} public void setVar(T var) {
this.var = var;
} @Override
public String toString() {
return var.toString();
} }
/**
* 通配符?的使用 包括<?>、<?extends 类型>和<? super 类型>
*/
@Test
public void testMyClass3() {
MyClass3<Boolean> clazz = new MyClass3<Boolean>();
clazz.setVar(false);
fun(clazz);//调运该方法的时候,对泛型没有限制,任何类型的泛型都可以使用 MyClass3<Integer> clazzInt = new MyClass3<Integer>();
clazzInt.setVar(1);
funExtends(clazzInt);//调运该方法的时候,只能使用Number类型或者其子类型 MyClass3<Double> clazzDouble = new MyClass3<Double>();
clazzDouble.setVar(2.2);
funExtends(clazzDouble);//调运该方法的时候,只能使用Number类型或者其子类型 MyClass3<String> clazzString = new MyClass3<String>();
clazzString.setVar("string");
funSuper(clazzString);//调运该方法的时候,只能使用String类型或者其父类型 MyClass3<Object> clazzObject = new MyClass3<Object>();
clazzObject.setVar(new Object());
funSuper(clazzObject);//调运该方法的时候,只能使用String类型或者其父类型 } public void fun(MyClass3<?> clazz) {//没有限制的泛型使用
System.out.println(clazz);
} public void funExtends(MyClass3<? extends Number> clazz) {//只能使用Number及其子类的泛型
System.out.println(clazz);
} public void funSuper(MyClass3<? super String> clazz) {//只能使用String及其父类的泛型
System.out.println(clazz);
} 4.定义类的时候就对泛型进行限制 public class MyClass4<T extends Number> {//定义类的泛型的时候进行泛型的限制
private T var; public T getVar() {
return var;
} public void setVar(T var) {
this.var = var;
} @Override
public String toString() {
return this.var.toString();
} } /**
* 定义类的泛型的时候都给定泛型的限制
*/
@Test
public void testMyClass4() {
//同样只能定义Number及其子类的泛型
// MyClass4<String> clazzString = new MyClass4<String>();
MyClass4<Integer> clazzInt = new MyClass4<Integer>();
MyClass4<Double> clazzDouble = new MyClass4<Double>(); MyClass4<Float> clazzFClass4 = fun(1.1f);
//此处调运的参数是float类型,这就确定了返回类型必须是float
} public <T extends Number> MyClass4<T> fun(T arg) {
return new MyClass4<T>(); } public interface MyInterface<T> {
public T getVar();
} //两种实现方式。1,在实现的时候还是使用泛型,到具体定义对象的时候再确定
public class MyInterface1Impl<T> implements MyInterface<T> {
private T var; public MyInterface1Impl() {
} public MyInterface1Impl(T var) {
this.var = var;
} @Override
public T getVar() {
return this.var;
} }
//第二种实现方式,在实现的时候就确定泛型的类型
public class MyInterface2Impl implements MyInterface<String> {
private String varStr; public MyInterface2Impl() {
} public MyInterface2Impl(String varStr) {
this.varStr = varStr;
} @Override
public String getVar() {
return this.varStr;
}
} /**
* 泛型接口的使用
*/
@Test
public void testMyInterface() {
//实现类可以定义为任意类型的泛型
MyInterface1Impl<String> varStr = new MyInterface1Impl<String>("abc");
System.out.println(varStr.getVar());
MyInterface1Impl<Integer> varInt = new MyInterface1Impl<Integer>(123);
System.out.println(varInt.getVar()); //之前已经在类实现的时候已经确定了只能是String
MyInterface2Impl var = new MyInterface2Impl("cba");
String str = var.getVar();
System.out.println(str);
} public class MyFunction {
public <T> T fun1(T arg) {//传入参数和返回参数都是同样的泛型类型
return arg;
} public <T> void fun2(T arg) {//传入参数是泛型,不需要返回
if (arg instanceof String) {
System.out.println("T is StringType");
} else if (arg instanceof Integer) {
System.out.println("T is IntegerType");
} else {
System.out.println("T is OtherType");
}
} public <T> String fun3(T arg) {//传入的参数是泛型,返回的确定类型
return arg.toString();
}
} /**
* 泛型方法的使用
*/
@Test
public void MyFunction() {
MyFunction clazz = new MyFunction(); //传入什么类型,返回什么类型
String var1 = clazz.fun1("abc");
int var2 = clazz.fun1(12);
System.out.println(var1);
System.out.println(var2); //无论传入的是什么类型,都没关系
clazz.fun2(1);
clazz.fun2(false);
clazz.fun2("string"); //无论传入什么,都返回的是String
String var3 = clazz.fun3(123);
String var4 = clazz.fun3("string");
System.out.println(var3);
System.out.println(var4); } /**
* 泛型数组的使用
*/
@Test
public void testArray(){
Integer[] arr = fun(1,2,3); } public <T> T[] fun(T... args){//传入什么类型,T就是什么类型,并且可以使用泛型遍历
for(T t:args){
System.out.println(t.toString());
}
return args;
} /**
* 嵌套泛型
*/
@Test
public void testNest(){
//外层泛型的类型其实就是内层泛型,当内层泛型确定了,那外层泛型也就确定了
MyClass1<MyClass2<Integer, String>> nestOut = new MyClass1<MyClass2<Integer,String>>();
MyClass2<Integer, String> nestIn = new MyClass2<Integer,String>();
nestIn.setVar1(1);
nestIn.setVar2("a");
nestOut.setVar(nestIn);
System.out.println(nestOut.getVar().getVar1());
System.out.println(nestOut.getVar().getVar2());
}
Java中泛型的各种使用的更多相关文章
- Java中泛型 类型擦除
转自:Java中泛型是类型擦除的 Java 泛型(Generic)的引入加强了参数类型的安全性,减少了类型的转换,但有一点需要注意:Java 的泛型在编译器有效,在运行期被删除,也就是说所有泛型参数类 ...
- Java中泛型使用
Java中泛型使用 泛型作用: 泛型:集合类添加对象不用强转 反射机制:将泛型固定的类的所有方法和成员全部显示出来 核心代码: ArrayList<Ls> ff=new ArrayList ...
- Java中泛型在集合框架中的应用
泛型是Java中的一个重要概念,上一篇文章我们说过,当元素存入集合时,集合会将元素转换为Object类型存储,当取出时也是按照Object取出的,所以用get方法取出时,我们会进行强制类型转换,并且通 ...
- Java 中泛型的全面解析(转)
Java泛型(generics) 是JDK 5中引入的一个新特性,允许在定义类和接口的时候使用类型参数(type parameter).声明的类型参数在使用时用具体的类型来替换.泛型最主要的应用是在J ...
- Java中泛型的理解
Java中的泛型,本质上来说,就是是参数化类型,就是说所操作的数据类型被指定为一个参数,而不是确定的某种类型.这种数据类型可以用在类.接口和方法创建中.即泛型类.泛型接口.泛型方法.这样说可能不够生动 ...
- Java中泛型数组创建总结
在java中,可以声明一个泛型数组,不能通过直接通过T[] tarr=new T[10]的方式来创建数组,最简单的方式便是通过Array.newInstance(Classtype,int size) ...
- Java中泛型Class<T>、T与Class<?>、 Object类和Class类、 object.getClass()和Object.class
一.区别 单独的T 代表一个类型(表现形式是一个类名而已) ,而 Class<T>代表这个类型所对应的类(又可以称做类实例.类类型.字节码文件), Class<?>表示类型不确 ...
- Java中泛型区别以及泛型擦除详解
一.引言 复习javac的编译过程中的解语法糖的时候看见了泛型擦除中的举例,网上的资料大多比较散各针对性不一,在此做出自己的一些详细且易懂的总结. 二.泛型简介 泛型是JDK 1.5的一项新特性,一种 ...
- 用反射来了解Java中泛型的本质
这篇文章主要通过Class的Method来了解泛型的本质. 先new 两个List,一个不加类型限制,另外一个限制类型为String: ArrayList list = new ArrayList() ...
- Java 中 泛型的限定
泛型 一般 出如今集合中,迭代器中 也会出现! 泛型 是为了 提高代码的 安全性. 泛型 确保数据类型的唯一性. 在我们经常使用的容器中. 越是 单一 约优点理啊! ...
随机推荐
- POJ2142 The Balance (扩展欧几里德)
本文为博主原创文章,欢迎转载,请注明出处 www.cnblogs.com/yangyaojia The Balance 题目大意 你有一个天平(天平左右两边都可以放砝码)与重量为a,b(1<= ...
- WinServer-IIS初始安装及发布网站
\aspnet_regiis.exe –i 还有非常重要的一步就是给发布文件夹设置权限,到底设置那一个用户的权限我也没有弄清楚,大概是IIS_IUSERS或者IUSR用户就可以了,我设置完了之后没有反 ...
- [Python Test] Use pytest fixtures to reduce duplicated code across unit tests
In this lesson, you will learn how to implement pytest fixtures. Many unit tests have the same resou ...
- 排序(3)---------冒泡排序(C语言实现)
说到冒泡排序,大一的时候第一次学习这个排序算法,可能大家不知道,"冒泡"在我说的方言里面是吹牛逼的意思. 所以就认为这个排序算法特吹牛逼有木有. 相信大家对全部的排序算法,这个想必 ...
- Remove Duplicates from Sorted List II 解答(有个比較特殊的case leetcode OJ没有覆盖)
昨天被考了一道数据结构题,当时的实现比較一般.回来翻看leetcode,果然是上面的题.遂解之. accept之后翻看discuss别人的解法.发现非常多能够accept的代码都过不了我设计的一个ca ...
- linux下线程
linux下线程 线程与进程的关系: 之前转载的微信文章,进程与线程的差别已经说得比較清楚了.能够查看之前转载的文章.linux进程与线程的差别. 创建一个线程: #include<pthrea ...
- 阿里云部署Docker(8)----安装和使用redmine
安装redmine对过程进行管理. 须要说明的是:当你在docker images的时候,会说没连接到xxxx的时候,并且会提示用"docker -d".事实上这仅仅是把docke ...
- iOS 自己主动登录,登录过程中一直显示载入页
iOS开发中 假设client做的人性化一点肯定会考虑自己主动登录 事实上原理非常easy,就是再首次登录成功之后将username和password存入userdefault 下次登录的时候推断us ...
- HDU 5273 Dylans loves sequence【 树状数组 】
题意:给出n个数,再给出q个询问,求L到R的逆序对的个数 先自己写的时候,是每次询问都重新插入来求sum(r)-sum(l) 果断T 后来还是看了别人的代码---- 预处理一下,把所有可能的区间的询问 ...
- lua-C++ userdata使用
lua-C++ userdata使用 所负责的产品使用非常灵活,可设置的参数上千个,而且还支持用户用lua进行流程控制,所以开发中要用到很多lua.C++混合编程.之前对这些也还是一知半解,只会依葫芦 ...