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); }
2.带有两个泛型类型
和普通的泛型使用基本一样,只是我们可以在使用类的时候定义两个不同的泛型类型,当然我们也可以定义多个,只要我们业务需要。
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.含有通配符的泛型
这里面又包含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>(); }
5.泛型接口的使用
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); }
6.泛型方法的使用
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); }
7.泛型数组
/** * 泛型数组的使用 */ @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; }
8.嵌套泛型
/** * 嵌套泛型 */ @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 实现泛型List的源码,基本实现了List接口的全部所有方法。欢迎大家发表自己的观点和建议。
Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战...
下面我们将深入探讨Java泛型方法的概念、语法以及使用示例。 **一、泛型方法概念** 泛型方法是一种具有类型参数的方法,这些类型参数可以在方法声明时指定,并在方法体内部使用。与类的泛型类似,它们提供了编译时...
2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip...
在Java中,泛型同样使用尖括号表示,但它的类型擦除特性使得编译后的字节码并不包含类型参数信息,而是使用Object或其他基础类型作为替代。这意味着Java的泛型不支持协变和逆变,但可以通过通配符(如?)来放宽类型...
感谢所有为Java泛型做出贡献的人们,包括设计者、实现者以及提供反馈和支持的社区成员。泛型是Java语言的一个重要特性,极大地提高了代码的质量和可维护性。 以上就是基于给定文件信息对Java 1.5泛型指南的主要知识...
2. **通配符**:泛型中使用通配符可以增加类型参数的灵活性。例如,`?`表示任何类型,`? extends Number`则限制为Number或其子类。这在处理多种类型的集合时非常有用,如方法参数的定义。 3. **类型擦除**:由于...
4. **利用`Class<T>`作为泛型约束**:有时候,我们可以在泛型类中使用`Class<T>`作为参数或字段,这样可以在运行时获取类型信息。例如: ```java public class MyClass<T> { private final Class<T> clazz; ...
泛型接口允许在接口声明中使用类型参数,实现此接口的类或接口必须提供具体的类型。 ### 泛型的优势 引入泛型的主要目的是在编译时提供更严格的类型检查,并且减少强制类型转换的需要。使用泛型后,在集合操作中...
这是一个使用JAVA实现的泛型编程,分为两部分,第一部分创建泛型类,并实例化泛型对象,得出相加结果。 第二部分用户自行输入0--4,选择要进行的加减乘除运算或退出,再输入要进行运算的两个数,并返回运算结果及...
Java泛型是Java编程语言中的一种重要特性,它允许开发者在编写代码时指定类型参数,从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析。 一、泛型的基本概念 泛型是Java 5中...
}`,这里的 `T` 是类型参数,可以在类的方法和成员变量中使用。 - 实例化:`MyClass<String> myObj = new MyClass();` - 类型擦除:Java编译器会进行类型擦除,将泛型类的实例转换为无参数类型,但会在编译时进行...
泛型允许我们在类、接口和方法中使用类型参数,这样我们可以在编译时检查类型,避免了运行时类型转换的麻烦和潜在的ClassCastException风险。 在Java中,泛型的主要目的是为了实现参数化类型,这意味着我们可以创建...
Java泛型是Java编程语言中的一个强大特性,它允许在定义类、接口和方法时使用类型参数,从而实现参数化类型。这使得代码更加安全、可读性更强,并且能够减少类型转换的必要。在“java泛型的内部原理及更深应用”这个...
Java反射和泛型是两种强大的编程特性,它们在开发中有着广泛的应用,特别是在数据库操作的动态化场景下。本文将详细介绍如何结合这两种技术实现在Java中对MySQL、SQL Server或Oracle数据库进行动态的增删改查操作。 ...