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中泛型的各种使用的更多相关文章

  1. Java中泛型 类型擦除

    转自:Java中泛型是类型擦除的 Java 泛型(Generic)的引入加强了参数类型的安全性,减少了类型的转换,但有一点需要注意:Java 的泛型在编译器有效,在运行期被删除,也就是说所有泛型参数类 ...

  2. Java中泛型使用

    Java中泛型使用 泛型作用: 泛型:集合类添加对象不用强转 反射机制:将泛型固定的类的所有方法和成员全部显示出来 核心代码: ArrayList<Ls> ff=new ArrayList ...

  3. Java中泛型在集合框架中的应用

    泛型是Java中的一个重要概念,上一篇文章我们说过,当元素存入集合时,集合会将元素转换为Object类型存储,当取出时也是按照Object取出的,所以用get方法取出时,我们会进行强制类型转换,并且通 ...

  4. Java 中泛型的全面解析(转)

    Java泛型(generics) 是JDK 5中引入的一个新特性,允许在定义类和接口的时候使用类型参数(type parameter).声明的类型参数在使用时用具体的类型来替换.泛型最主要的应用是在J ...

  5. Java中泛型的理解

    Java中的泛型,本质上来说,就是是参数化类型,就是说所操作的数据类型被指定为一个参数,而不是确定的某种类型.这种数据类型可以用在类.接口和方法创建中.即泛型类.泛型接口.泛型方法.这样说可能不够生动 ...

  6. Java中泛型数组创建总结

    在java中,可以声明一个泛型数组,不能通过直接通过T[] tarr=new T[10]的方式来创建数组,最简单的方式便是通过Array.newInstance(Classtype,int size) ...

  7. Java中泛型Class<T>、T与Class<?>、 Object类和Class类、 object.getClass()和Object.class

    一.区别 单独的T 代表一个类型(表现形式是一个类名而已) ,而 Class<T>代表这个类型所对应的类(又可以称做类实例.类类型.字节码文件), Class<?>表示类型不确 ...

  8. Java中泛型区别以及泛型擦除详解

    一.引言 复习javac的编译过程中的解语法糖的时候看见了泛型擦除中的举例,网上的资料大多比较散各针对性不一,在此做出自己的一些详细且易懂的总结. 二.泛型简介 泛型是JDK 1.5的一项新特性,一种 ...

  9. 用反射来了解Java中泛型的本质

    这篇文章主要通过Class的Method来了解泛型的本质. 先new 两个List,一个不加类型限制,另外一个限制类型为String: ArrayList list = new ArrayList() ...

  10. Java 中 泛型的限定

         泛型 一般 出如今集合中,迭代器中 也会出现!      泛型 是为了 提高代码的 安全性. 泛型 确保数据类型的唯一性. 在我们经常使用的容器中.  越是 单一 约优点理啊!       ...

随机推荐

  1. POJ2142 The Balance (扩展欧几里德)

    本文为博主原创文章,欢迎转载,请注明出处 www.cnblogs.com/yangyaojia The Balance 题目大意  你有一个天平(天平左右两边都可以放砝码)与重量为a,b(1<= ...

  2. WinServer-IIS初始安装及发布网站

    \aspnet_regiis.exe –i 还有非常重要的一步就是给发布文件夹设置权限,到底设置那一个用户的权限我也没有弄清楚,大概是IIS_IUSERS或者IUSR用户就可以了,我设置完了之后没有反 ...

  3. [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 ...

  4. 排序(3)---------冒泡排序(C语言实现)

    说到冒泡排序,大一的时候第一次学习这个排序算法,可能大家不知道,"冒泡"在我说的方言里面是吹牛逼的意思. 所以就认为这个排序算法特吹牛逼有木有. 相信大家对全部的排序算法,这个想必 ...

  5. Remove Duplicates from Sorted List II 解答(有个比較特殊的case leetcode OJ没有覆盖)

    昨天被考了一道数据结构题,当时的实现比較一般.回来翻看leetcode,果然是上面的题.遂解之. accept之后翻看discuss别人的解法.发现非常多能够accept的代码都过不了我设计的一个ca ...

  6. linux下线程

    linux下线程 线程与进程的关系: 之前转载的微信文章,进程与线程的差别已经说得比較清楚了.能够查看之前转载的文章.linux进程与线程的差别. 创建一个线程: #include<pthrea ...

  7. 阿里云部署Docker(8)----安装和使用redmine

    安装redmine对过程进行管理. 须要说明的是:当你在docker images的时候,会说没连接到xxxx的时候,并且会提示用"docker -d".事实上这仅仅是把docke ...

  8. iOS 自己主动登录,登录过程中一直显示载入页

    iOS开发中 假设client做的人性化一点肯定会考虑自己主动登录 事实上原理非常easy,就是再首次登录成功之后将username和password存入userdefault 下次登录的时候推断us ...

  9. HDU 5273 Dylans loves sequence【 树状数组 】

    题意:给出n个数,再给出q个询问,求L到R的逆序对的个数 先自己写的时候,是每次询问都重新插入来求sum(r)-sum(l) 果断T 后来还是看了别人的代码---- 预处理一下,把所有可能的区间的询问 ...

  10. lua-C++ userdata使用

    lua-C++ userdata使用 所负责的产品使用非常灵活,可设置的参数上千个,而且还支持用户用lua进行流程控制,所以开发中要用到很多lua.C++混合编程.之前对这些也还是一知半解,只会依葫芦 ...