Java泛型在集合使用与自定义及继承上的体现和通配符的使用

泛型的概念

集合容器类在设计阶段/声明阶段不能确定这个容器实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定,其他的部分是确定的,例如关于这个元素如何保存,如何管理等是确定的,因此把元素的类型设计成一个参数,这个类型参数叫做泛型。Collection<E>ArrayList<E><E>就是类型参数,即泛型。

所谓泛型,就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如,继承或实现这个接口,用这个类型声明变量、创建对象时)确定(即传入实际的类型参数,也称为类型实参)。

从JDK1.5以后,Java引入了“参数化类型(Parameterized type)”的概念,允许在创建集合时再指定集合元素的类型,正如:List<String>,这表明该List只能保存字符串类型的对象。JDK1.5改写了集合框架中的全部接口和类,为这些接口、类增加了泛型支持,从而可以在声明集合变量、创建集合对象时传入类型实参。

集合中使用泛型

Collection中使用泛型:

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @Author: Yeman
 * @Date: 2021-09-24-15:10
 * @Description:
 */
public class GenericTest {
    public static void main(String[] args) {
    	//如下在实例化的时候在<>中填入需要的类型即可(不可以是基本数据类型)
        ArrayList<Integer> list = new ArrayList<>();
        list.add(99);
        list.add(0);
        list.add(121);

        //遍历方式一
        for (Integer integer : list){
            System.out.println(integer);
        }
        System.out.println("=====================");
        //遍历方式二
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

Map中使用泛型:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Author: Yeman
 * @Date: 2021-09-24-15:10
 * @Description:
 */
public class GenericTest {
    public static void main(String[] args) {
        //如下如下在实例化的时候在<>中填入需要的类型即可(不可以是基本数据类型)
        // 注意因为Map是键值对,因此需要分别填入“键”和“值”所需要的类型
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Jack",26);
        map.put("Marry",18);
        map.put("Tom",20);
        map.put("Lily",22);

        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

自定义泛型结构

1、泛型类、泛型接口

①泛型的声明
interface List<T>{}class GenTest<K,V>{}class student <T extends Person> {}
其中,T,K,V不代表值,而是表示类型。这里使用任意字母都可以,常用T表示,是Type的缩写。

②泛型的实例化

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

<>里面只能是类,不能用基本数据类型填充,可以使用包装类填充。把一个集合中的内容限制为一个特定的数据类型,这就是Generic的核心思想。

泛型类可能有多个参数,此时可将多个参数一起放在尖括号内,如:<E1,E2,E3>

泛型类的构造器与非泛型一样:public GenericClass(){}
public GenericClass<E>(){}是错误的。

泛型不同的引用不能相互赋值:尽管在编译时ArrayList<String>ArrayList<Integer>是两种类型,但是,在运行时只有一个ArrayList被加载到JVM中。

在类/接口上声明的泛型,在本类或本接口中即代表某种类型,可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型,因为静态成员是随着类加载而加载的,而类型的指定是在实例化时才确定的。

异常类不能使用泛型。

不能new E[],但是可以E[] elements = (E[])new Object[capacity];

父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型,子类除了指定或保留父类的泛型,还可以增加自己的泛型:

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)指定类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
class Person<T> {
    // 使用T类型定义变量
    private T info;

    // 使用T类型定义一般方法
    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }

    // 使用T类型定义构造器
    public Person() {
    }

    public Person(T info) {
        this.info = info;
    }
}

2、泛型方法

方法,也可以被泛型化,不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数,此时,参数的类型就是传入数据的类型。

访问权限 是否为静态 <泛型> 返回类型 方法名(泛型标识 参数名称,...) 异常{
	//方法体
}
public class Test {
	public <E> E get(int id, E[] arry) {
		E result = null;
		return result;
	}
}

泛型在继承上的体现

如果B是A的一个子类型(子类或者子接口),而G是具有泛型声明的类或接口,G<B>并不是G<A>的子类型!比如:String是Object的子类,但是List<String>并不是List<Object>的子类,不能相互赋值。而反过来,如下是可以的:

ArrayList<String> arrayList = new ArrayList<>();
List<String> list = arrayList;

通配符的使用

1、使用

比如:List<?>Map<?,?>
List<?>List<String>List<Object>等各种泛型List的父类。

读取List<?>的对象list中的元素时,永远是安全的,因为不管list的真实类型是什么,都包含于Object。而不能向其中添加(写入)对象。除了null,因为它是所有类型的成员:

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时错误
public static void main(String[] args) {
	List<?> list = null;
	list = new ArrayList<String>();
	list = new ArrayList<Double>();
	list.add(3);//编译不通过,编译时错误
	list.add(null);
	List<String> l1 = new ArrayList<String>();
	List<Integer> l2 = new ArrayList<Integer>();
	l1.add("AABBCC");
	l2.add(9);
	read(l1);
	read(l2);
}
public static void read(List<?> list) {
	for (Object o : list) {
		System.out.println(o);
	}
}

2、有限制的通配符

①<?>
允许所有泛型的引用调用

②通配符指定上限
extends:使用时指定的类型必须是继承某个类,或者实现某个接口,即<=。
<? extends Number> (无穷小 , Number],只允许泛型为Number及Number子类的引用调用。<? extends Comparable>只允许泛型为实现Comparable接口的实现类的引用调用。

③通配符指定下限
下限super:使用时指定的类型不能小于操作的类,即>=。
<? super Number> [Number , 无穷大),只允许泛型为Number及Number父类的引用调用。

到此这篇关于Java泛型在集合使用与自定义及继承上的体现和通配符的使用的文章就介绍到这了,更多相关Java 泛型内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java中的泛型

    目录 1. 什么是泛型 2. 为什么需要泛型 3. 如何使用泛型 3.1 泛型使用 3.2 自定义泛型类 3.2.1 Java 源码中泛型的定义 3.2.2 自定义泛型类实例1 3.2.3 自定义泛型类实例2 3.3 自定义泛型方法 4. 泛型类的子类 4.1 明确类型参数变量 4.2 不明确类型参数变量 5. 类型通配符 5.1 无限定通配符 5.2 extends 通配符 5.3 super 通配符 6. 小结 1. 什么是泛型 泛型不只是 Java 语言所特有的特性,泛型是程序设计语言的一

  • Java中的纸老虎之泛型

    目录 一. 泛型的定义 二. 为什么要用到泛型 三. 泛型的写法 四. 泛型的使用实例 1. 求最大值 2. 优化 五. 通配符 1. 基本写法 2. 上界 3. 下界 六. 泛型的限制 泛型,其实算是Java当中比较难的语法了,很多人一开始都对其一知半解,也很害怕阅读带泛型的源码,虽然看起来语法很难,但当你理解后会觉得很简单,其实只是一个纸老虎罢了.下面,我将会用非常简单易懂的方式带你去理解它,相信你在认真看完后会有非常大的收获,从此不会再畏惧它! 一. 泛型的定义 这里大家可以不必去看网上的

  • Java语法关于泛型与类型擦除的分析

    泛型与类型擦除 泛型,JDK 1.5新特性,本质是参数化类型(Parametersized Type) 的应用,即所操作的数据类型被指定为一个参数.这种参数类型可用在: 类 接口 方法 的创建中, 分别称为: 泛型类 泛型接口 泛型方法 在Java还没有泛型的版本时.只能通过: Object 是所有类型的父类 类型强制转换 两个特性协作实现类型泛化.例如,在哈希表的存取中,JDK 1.5之前使用HashMap的get() 方法,返回值就是个Object.由于Java语言里面所有的类型都维承于ja

  • 半小时通透Java的泛型

    目录 前言 学习目标 1. 什么是泛型 2. 为什么需要泛型 3. 如何使用泛型 3.1 泛型使用 3.2 自定义泛型类 3.2.1 Java 源码中泛型的定义 3.2.2 自定义泛型类实例1 3.2.3 自定义泛型类实例2 3.3 自定义泛型方法 4. 泛型类的子类 4.1 明确类型参数变量 4.2 不明确类型参数变量 5. 类型通配符 5.1 无限定通配符 5.2 extends 通配符 5.3 super 通配符 6. 小结 Java 泛型 前言 编程不能停止,每天发一篇~ 不要捉急往后学

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

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

  • Java泛型在集合使用与自定义及继承上的体现和通配符的使用

    泛型的概念 集合容器类在设计阶段/声明阶段不能确定这个容器实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决.因为这个时候除了元素的类型不确定,其他的部分是确定的,例如关于这个元素如何保存,如何管理等是确定的,因此把元素的类型设计成一个参数,这个类型参数叫做泛型.Collection<E>,ArrayList<E> 中<E>就是类型参数,即泛型. 所谓泛型,就是允许在定义类.接口时通过一个标识表示类中某个属性

  • Java泛型最全知识总结

    一.泛型简介 1.1 泛型的概念 所谓泛型,就是允许在定义类.接口时通过一个标识表示类中某个属性的类型或者是某个方法的返 回值及参数类型.这个类型参数将在使用时(例如,继承或实现这个接口,用这个类型声明变量. 创建对象时确定(即传入实际的类型参数,也称为类型实参). 从JDK 5.0以后,Java引入了"参数化类型(Parameterized type)"的概念,允许我们在创建集合时再指定集合元素的类型,正如:List,这表明该List只能保存字符串类型的对象. JDK 5.0改写了集

  • Java 基础详解(泛型、集合、IO、反射)

    计划把 Java 基础的有些部分再次看一遍,巩固一下,下面以及以后就会分享自己再次学习的一点笔记!不是有关标题的所有知识点,只是自己觉得模糊的一些知识点. 1.对于泛型类而言,你若没有指明其类型,默认为Object: 2.在继承泛型类以及接口的时候可以指明泛型的类型,也可以不指明: 3.泛型也数据库中的应用: 写一个 DAO 类对数据库中的数据进行增删改查其类型声明为 <T> .每张表对应一个类,对应每一张表实现一个类继承该 DAO 类并指明 DAO 泛型为该数据表对应的类,再实现一个与该表匹

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

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

  • 基于Java回顾之集合的总结概述

    Java中的集合主要集中在2部分,一部分是java.util包中,一部分是java.util.concurrent中,后者是在前者的基础上,定义了一些实现了同步功能的集合. 这篇文章主要关注java.util下的各种集合对象.Java中的集合对象可以粗略的分为3类:List.Set和Map.对应的UML图如下(包括了java.util下大部分的集合对象):Collection概述 Java集合中的List和Set都从Collection出来,它是一个学习集合很不错的入口,它包含了集合中通常需要有

  • Java 泛型有哪些好处详解

    java 泛型 概要: Java 泛型是java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以用在类.接口和方法的创建中,分别称为泛型类.泛型接口.泛型方法. 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样. 可以在集合框架(Collection

  • 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泛型中T和问号(通配符)的区别

    类型本来有:简单类型和复杂类型,引入泛型后把复杂类型分的更细了. 概述 泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以用在类.接口和方法的创建中,分别称为泛型类.泛型接口.泛型方法. Java语言引入泛型的好处是安全简单. 在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的"任意化","任意化"带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对

  • 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

随机推荐