通过代码理解java泛型

泛型数据java基础,但真正理解需要悉心品尝。毕竟在工作中用到的是在是太多了。

不要以为new ArrayList<>这就是泛型,这只能属于会使用。

在工作中,相对于现有的项目源码的数据库操作层,无论是mybatis,hibernate或者是自己封装的baseModel层,都会使用到泛型。

以及<? extends T> 和 <? super T>这个屌东西。

泛型使用情况分为三类

1. 泛型类。

2. 泛型方法。

3. 泛型接口。

出于规范的目的,Java 还是建议我们用单个大写字母来代表类型参数。常见的如:

1. T 代表一般的任何类。

2. E 代表 Element 的意思,或者 Exception 异常的意思。

3. K 代表 Key 的意思。

4. V 代表 Value 的意思,通常与 K 一起配合使用。

5. S 代表 Subtype 的意思,文章后面部分会讲解示意。

最直接的一段代码。

List<String> l1 = new ArrayList<String>();
  List<Integer> l2 = new ArrayList<Integer>();
  System.out.println(l1.getClass() == l2.getClass());

打印的判断为TRUE,因为泛型信息被擦除了。

泛型擦除实例。

List<String> listErasure = new ArrayList<String>() {
   // 直接初始化,这也是一种方式。直接传入一个collection。
   {add("aaa");add("bbb");}
  };
  listErasure.add("ccc");
  Class<? extends List> class1 = listErasure.getClass();
  Method method = class1.getMethod("add",Object.class);
  method.invoke(listErasure, 123);
  System.out.println(listErasure)

输出结果  [aaa, bbb, ccc, 123]

明明是接收String类型,但是却可以通过反射对其进行Integer类型的操作。

可见泛型只是在编译期间有效。

<?> 代表着类型未知

<? extends T> 和 <? super T>这个东西经常见到,但是并没有字面意义那么简单。

通配符有 3 种形式。

  1. <?> 被称作无限定的通配符。
  2. <? extends T> 被称作有上限的通配符。
  3. <? super T> 被称作有下限的通配符。
class A{}
class B extends A{}
class C extends B{}
List<? extends B> listExtends = new ArrayList<B>();
//  listExtends.add(new A()); 全部编译错误。因为使用的是extends,丧失了写的操作能力。跟f3方法一样,是未知类型,只是确定了里面对象的范围。是B的子类。
//  listExtends.add(new B());
//  listExtends.add(new C());

  // 能进行对B以及B的子类操作。这是super的神奇之处。
  List<? super B> listSuper = new ArrayList<B>();
//  listSuper.add(new A());//会编译错误。
  listSuper.add(new B());
  listSuper.add(new C());

以及方法泛型的返回

泛型作为参数的传递。

public static <TTT>TTT f1(TTT t) {
  return t;
 }

 // 传递指定的A类型,对应的list可以进行对应的list应有的方法。
 public static void f2(List<A> list) {
  list.add(new A());
  System.out.println(list.size());
 }

 public static void f3(List<?> list) {
//  list.add(new A()); //当传入的是?通配符的话表示只能进行跟?无关的操作,类似于size方法,增加代码的可读性。
  System.out.println(list.size());
 }

 public static void f4(List<? extends B> listExtends) {
//  listExtends.add(new B());//不能进行写做操,因为是?,增加了可读性。
  System.out.println(listExtends.size());
 }

测试代码,很全面

package com.javaSE.fanxing;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

class A{}
class B extends A{}
class C extends B{}
public class Demo<T,TT> {
 T value;
 TT value2;
 public TT getValue2() {
  return value2;
 }
 public void setValue2(TT value2) {
  this.value2 = value2;
 }
 public T getValue() {
  return value;
 }
 public void setValue(T value) {
  this.value = value;
 }
 public static <TTT>TTT f1(TTT t) {
  return t;
 }
 // 传递指定的A类型,对应的list可以进行对应的list应有的方法。
 public static void f2(List<A> list) {
  list.add(new A());
  System.out.println(list.size());
 }
 public static void f3(List<?> list) {
//  list.add(new A()); //当传入的是?通配符的话表示只能进行跟?无关的操作,类似于size方法,增加代码的可读性。
  System.out.println(list.size());
 }
 public static void f4(List<? extends B> listExtends) {
//  listExtends.add(new B());//不能进行写做操,因为是?,增加了可读性。
  System.out.println(listExtends.size());
 }
 public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
  // 打印的判断为TRUE,因为泛型信息被擦除了。
  List<String> l1 = new ArrayList<String>();
  List<Integer> l2 = new ArrayList<Integer>();
  System.out.println(l1.getClass() == l2.getClass());
  // 泛型擦除实例。
  List<String> listErasure = new ArrayList<String>() {
   // 直接初始化,这也是一种方式。直接传入一个collection。
   {add("aaa");add("bbb");}
  };
  listErasure.add("ccc");
  Class<? extends List> class1 = listErasure.getClass();
  Method method = class1.getMethod("add",Object.class);
  method.invoke(listErasure, 123);
  System.out.println(listErasure);
  Demo<String,Integer> demo = new Demo<String,Integer>();
  demo.setValue("string");
  System.out.println(demo.getValue());

  Demo<Integer,String> demo2 = new Demo<Integer,String>();
  demo2.setValue(100);
  System.out.println(demo2.getValue());

  System.out.println(f1(123));
//  List<A> listA = new ArrayList<A>();
//  List<B> listB = listA;//new ArrayList<B>();虽然B是A的子类,并不代表泛型之间也具备继承关系。

  ArrayList<A> listA = new ArrayList<A>();
  listA.add(new A());
  f3(listA); // 不对f3方法进行任何操作,是1.
  f2(listA); // 2对应的方法实现还进行了一次插入操作。
  f3(listA); // static ,对应的listA的集合数量是引用值。

  ArrayList<B> listB = new ArrayList<B>();
  listB.add(new B());
  f3(listB); // f3方法传递的是通配符?,不能进行add操作。

  // <? extends T> 和 <? super T>
  List<? extends B> listExtends = new ArrayList<B>();
//  listExtends.add(new A()); 全部编译错误。因为使用的是extends,丧失了写的操作能力。跟f3方法一样,是未知类型,只是确定了里面对象的范围。是B的子类。
//  listExtends.add(new B());
//  listExtends.add(new C());

  // 能进行对B以及B的子类操作。这是super的神奇之处。
  List<? super B> listSuper = new ArrayList<B>();
//  listSuper.add(new A());//会编译错误。
  listSuper.add(new B());
  listSuper.add(new C());

  // 没毛病。
  List<B> listBS = new ArrayList<B>();
  listBS.add(new B());
  f4(listBS);
 }
}
(0)

相关推荐

  • java泛型基本知识及通用方法

    泛型的基本使用 泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 这种参数类型可以用在类.接口和方法的创建中, 分别称为泛型类.泛型接口.泛型方法.  Java语言引入泛型的好处是安全简单. 今天就从以下几个方面介绍一下java的泛型: 基础, 泛型关键字, 泛型方法, 泛型类和接口. 基础: 通过集合的泛型了解泛型的基本使用 public void testBasis(){ List<String> list = new Array

  • Java泛型定义与用法实例详解

    本文实例讲述了Java泛型定义与用法.分享给大家供大家参考,具体如下: 1. 泛型的由来 先看如下代码: import java.util.List; import java.util.ArrayList; public class TestGeneric { @SuppressWarnings({ "rawtypes", "unchecked" }) public static void main(String[] args) { List list = new

  • 浅谈Java泛型让声明方法返回子类型的方法

    泛型典型的使用场景是集合.考虑到大多数情况下集合是同质的(同一类型),通过声明参数类型,可免去类型转换的麻烦.本文将讨论本人阅读Spring Security源码时遇到的一个关于泛型递归模式的问题. 声明方法返回子类型 在Spring Security的源码里有一个ProviderManagerBuilder接口,声明如下 public interface ProviderManagerBuilder<B extends ProviderManagerBuilder<B>> ext

  • Java总结篇系列:Java泛型详解

    一. 泛型概念的提出(为什么需要泛型)? 首先,我们看下下面这段简短的代码: public class GenericTest { public static void main(String[] args) { List list = new ArrayList(); list.add("qqyumidi"); list.add("corn"); list.add(100); for (int i = 0; i < list.size(); i++) { S

  • 重新理解Java泛型

    这篇文章的目的在于介绍Java泛型,使大家对Java泛型的各个方面有一个最终的,清晰的,准确的理解,同时也为下一篇<重新理解Java反射>打下基础. 简介 泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用.本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除. 泛型基础 泛型类 我们首先定义一个简单的Box类: public class Box { private String object; public void set(St

  • Java泛型机制的程序演示详解

    本文为大家分享了Java泛型机制的程序演示具体代码,供大家参考,具体内容如下 package packA; import java.util.*; public class GenericDemo { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>( new LenSort() ); //<String> 泛型 ts.add("hidwju&qu

  • Java泛型映射不同的值类型详解及实例代码

    Java泛型映射不同的值类型详解 前言: 一般来说,开发人员偶尔会遇到这样的情形: 在一个特定容器中映射任意类型的值.然而Java 集合API只提供了参数化的容器.这限制了类型安全地使用HashMap,如单一的值类型.但如果想混合苹果和梨,该怎样做呢? 幸运的是,有一个简单的设计模式允许使用Java泛型映射不同的值类型,Joshua Bloch在其<Effective Java>(第二版,第29项)中将其描述为类型安全的异构容器(typesafe hetereogeneous Containe

  • 浅谈java泛型的作用及其基本概念

    一.泛型的基本概念 java与c#一样,都存在泛型的概念,及类型的参数化.java中的泛型是在jdk5.0后出现的,但是java中的泛型与C#中的泛型是有本质区别的,首先从集合类型上来说,java 中的ArrayList<Integer>和ArrayList<String>是同一个类型,在编译时会执行类型擦除,及java中的类型是伪泛型,伪泛型将会在后面介绍,其次,对于像集合中添加基本类型的数据时,例如int,会首先将int转化成Integer对象,即我们通常所说的装箱操作,在取出

  • 通过代码理解java泛型

    泛型数据java基础,但真正理解需要悉心品尝.毕竟在工作中用到的是在是太多了. 不要以为new ArrayList<>这就是泛型,这只能属于会使用. 在工作中,相对于现有的项目源码的数据库操作层,无论是mybatis,hibernate或者是自己封装的baseModel层,都会使用到泛型. 以及<? extends T> 和 <? super T>这个屌东西. 泛型使用情况分为三类 1. 泛型类. 2. 泛型方法. 3. 泛型接口. 出于规范的目的,Java 还是建议我

  • 深入理解java泛型Generic

    1. 背景 泛型技术诞生之前(JDK5以前),创建集合的类型都是Object 类型的元素,存储内容没有限制,编译时正常,运行时容易出现ClassCastException 异常. public class Test { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("java"); list.add(100); list.add(true); for(int i =

  • 深入浅出理解Java泛型的使用

    目录 一.泛型的意义 二.泛型的使用 三.自定义泛型类 1.关于自定义泛型类.泛型接口: 2.泛型在继承方面的体现 3.通配符的使用 一.泛型的意义 二.泛型的使用 1.jdk 5.0新增特性 2.在集合中使用泛型: 总结: A.集合接口或集合类在jdk5.0时都修改为带泛型的结构. B.在实例化集合类时,可以指明具体的泛型类型. C.指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法.构造器.属性等)使用类的泛型的位置, 都指定为实例化的泛型类型.比如:add(E e) --

  • 深入理解java泛型详解

    什么是泛型? 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样. 可以在集合框架(Collection framework)中看到泛型的动机.例如,Map 类允许您向一个 Map 添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String)的对象. 因为 Map.get(

  • 简单理解java泛型的本质(非类型擦除)

    背景 之前在网上发现这个问题 public class GenericTest { //方法一 public static <T extends Comparable<T>> List<T> sort(List<T> list) { return Arrays.asList(list.toArray((T[]) new Comparable[list.size()])); } //方法二 public static <T extends Compara

  • Java 泛型实例详解

    理解Java泛型最简单的方法是把它看成一种便捷语法,能节省你某些Java类型转换(casting)上的操作: List<Apple> box = ...; Apple apple = box.get(0); 上面的代码自身已表达的很清楚:box是一个装有Apple对象的List.get方法返回一个Apple对象实例,这个过程不需要进行类型转换.没有泛型,上面的代码需要写成这样: List box = ...; Apple apple = (Apple) box.get(0); 很明显,泛型的主

  • Java之map的常见用法讲解与五种循环遍历实例代码理解

    目录 一.概述: 二.Map集合的功能介绍 三.map官方总结 四.实例 五.循环遍历的五种方法 一.概述: 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值 Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构针对键有效,跟值无关;Collection集合的数据结构是针对元素有效 二.Map集合的功能介绍 a:添加功能 V put(K key,V val

  • Java 泛型总结(三):通配符的使用

    简介 前两篇文章介绍了泛型的基本用法.类型擦除以及泛型数组.在泛型的使用中,还有个重要的东西叫通配符,本文介绍通配符的使用. 这个系列的另外两篇文章: Java 泛型总结(一):基本用法与类型擦除 Java 泛型总结(二):泛型与数组 数组的协变 在了解通配符之前,先来了解一下数组.Java 中的数组是协变的,什么意思?看下面的例子: class Fruit {} class Apple extends Fruit {} class Jonathan extends Apple {} class

随机推荐