java基础——泛型

已于 2022-10-27 20:43:14 修改
阅读量159 收藏
点赞数
分类专栏： java基础 文章标签： java jvm 开发语言
于 2022-10-26 21:45:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52117201/article/details/127541475
版权

泛型

基本介绍

  1. 泛型又称参数化类型，是Jdk5.0出现的新特性,解决数据类型的安全性问题

  2. 在类声明或实例化时只要指定好需要的具体的类型即可。

  3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时,代码更加简洁、健壮

  4. 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,或者是某个方法的返回值的类型,或者是参数类型。[有点难,举例Generic03.java]

    在这里插入图片描述

基本语法

  • interface 接口{}和class类<K,V>{}
  • List strList = new ArrayList0;
  • Iterator iterator = customers.iterator();

说明：

  1. 其中，T,K,V不代表值，而是表示类型。
  2. 任意字母都可以。常用T表示，是Type的缩写

实例对比

package generic;
import java.util.ArrayList;

public class exerciese0q {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        //需求
//      请编写程序,在ArrayList中,添加3个Dog对象
//      Dog对象含有name和 age，并输出name和 age(要求使用getXxx())
//        如果程序员不小心在里面添加了一个猫
        //使用传统的方法来解决，在for循环时就会报错
        arrayList.add(new cat("啦啦啦",1));
        arrayList.add(new Dog("旺财",10));
        arrayList.add(new Dog("发财",1));
        arrayList.add(new Dog("小黄",5));
//      遍历
        for (Object o : arrayList) {
//       向下转型Object ->Dog
            Dog dog = (Dog)o;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
//        使用传统方法的问题分析
//        1.不能对加入到集合ArrayList中的数据类型进行约束(不安全)
//        2.遍历的时候,需要进行类型转换,如果集合中的数据量较大，对效率有影响
        //泛型解决
        //1.当我们 ArrayList<Dog>表示存放到 ArrayList 集合中的元素是Dog类型（细节后面说...)
        //2。如果编译器发现添加的类型，不满足要求，就会报错
//        3．在遍历的时候，可以直接取出Dog 类型而不是 0bject
        ArrayList<Dog> arrayList1 = new ArrayList<Dog>();
        arrayList1.add(new Dog("旺财",10));
        arrayList1.add(new Dog("发财",1));
        arrayList1.add(new Dog("小黄",5));//假如我们的程序员，不小心，添加了一只猫l/arrayList.add(new Cat("招财猫"，8));
        for (Dog dog : arrayList1) {
            System.out.println(dog. getName() + "-" + dog. getAge();
        }
    }
}
class Dog {
    private String name;private int age;
    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}
class cat{
    private String name;private int age;
    public cat(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

使用细节

  1. interface List0{}, public class HashSet{}…等等

    说明:T,E只能是引用类型
    看看下面语句是否正确?:
    List list = new ArrayList0;

    ​ List list2 = new ArrayList0;//错误

  2. 在指定泛型具体类型后,可以传入该类型或者其子类类型

  3. 泛型使用形式

    ​ List list1 = new ArrayList ();

    ​ List list2 =new ArrayList<>();

  4. ArrayList arrayList = new TArrayList();//等价 ArrayList arrayList = new ArrayList<>();

自定义泛型类

语法

class类名<T,R…>{

​ 成员

}

注意细节

  1. 普通成员可以使用泛型(属性、方法)
  2. 使用泛型的数组，不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
  5. 如果在创建对象时，没有指定类型,默认为Object

代码案例


//1.Tiger后面泛型，所以我们把Tiger就称为自定义泛型类
//2.T，R，M泛型的标识符，一般是单个大写字母
//3.泛型标识符可以有多个。
//4.普通成员可以使用泛型〔属性、方法)
//5.使用泛型的数组，不能初始化
class Tiger<T,R,M> {
    String name;
    R r;//属性使用到泛型
    M m;
    T t;
//因为数组在new不能确定T的类型，就无法在内存开空间
    T[] ts;
    public Tiger(String name,R r,M m,T t){//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
//    public static void m1(M m){
    //静态方法中不能使用类的泛型
//    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public R getR() { return r; }
    public void setR(R r) { this.r = r; }
    public T getT() { return t; }
    public void setT(T t) { this.t = t; }
    public T[] getTs() { return ts; }
    public void setTs(T[] ts) { this.ts = ts; }
}

自定义泛型接口

基本语法

interface接口名<T,R…>{}

注意细节

  1. 接口中,静态成员也不能使用泛型(这个和泛型类规定一样)
  2. 泛型接口的类型，在继承接口或者实现接口时确定
  3. 没有指定类型,默认为Object

代码案例

package generic;
interface IUsb<U,R> {
    int n = 10;
    //U name;不能这样使用
//普通方法中，可以使用接口泛型R get(U u);
    void hi(R r);
    void run(R r1,R r2,U u1, U u2);
    //在jdk8中，可以在接口中，使用默认方法，也是可以使用泛型
     default R method(U u) {
        return null;
    }
}
//在继承接口指定泛型接口的类型
interface IA extends IUsb<String,Double> {
}
//当我们去实现IA接口时，因为IA在继承IUsU 接口时，指定了U为String R为Doublel
 class AA implements IA {
    @Override
    public void hi(Double aDouble) { }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) { }
    @Override
    public Double method(String s) { return null; }
}
//没有指定类型，默认为0bject
//class cc implements TUsb {//等价class CC implements IUsb<Object,0bjects {

自定义泛型方法

基本语法

修饰符<T,R…>返回类型方法名(参数列表){

}

注意细节

  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
  2. 当泛型方法被调用时，类型会确定
  3. public void eat(Ee)0，修饰符后没有<T,R…> eat方法不是泛型方法，而是使用了泛型

泛型的继承和通配符

  1. 泛型不具备继承性
    List list = new ArrayList0; /对吗?//不对
  2. <?>∶支持任意泛型类型
  3. <? extends A>:支持A类以及A类的子类,规定了泛型的上限
  4. <? super A>:支持A类以及A类的父类，不限于直接父类,规定了泛型的下限

章节练习题

package generic;

import org.junit.jupiter.api.Test;

import java.util.*;

public class work04 {
    public static void main(String[] args) {
//        定义个泛型类 DAO<T>，在其中定义一个Map成员变量，
//        Map的键为String类型，值为T类型。分别创建以下方法:
//        (1) public void save(String id,T entity):保存T类型的对象
//                  到 Map成员变量中
//        (2) public T get(String id):从map中获取id对应的对象
//        (3) public void update(String id,T entity):
//                  替换map中key为id的内容,改为entity对象
//       (4) public List<T> list():返回map中存放的所有T对象
//       (5) public void delete(String id):删除指定id对象
//        定义一个 User 类:
//        该类包含:private成员变量(int类型)id, age;(String类型) name
//        创建 DAO类的对象，分别调用其 save.get、update、list、
//        delete方法来操作User对象,使用Junit单元测试类进行测试
    }
        @Test
        public void testList(){
//说明/这里我们给T指定类型User
            DAO<User> dao = new DAO<>();
            dao.save("001", new User(1, 10, "jack"));
            dao.save("002", new User(2, 18, "king"));
            dao.save("003", new User(3, 38, "smith"));
            List<User> list = dao.list();
            System.out.println("list=" + list);
        }

}
class DAO<T>{
    Map<String ,T> map=new HashMap();
    public void save(String id,T entity){
        map.put(id,entity);
        System.out.println("添加成功！");
    }
    public T get(String id){
        return map.get(id);
    }
    public void update(String id,T entity){
        map.replace(id,entity);
        System.out.println("更新成功！");
    }
    public List<T> list(){
        ArrayList<T> ts = new ArrayList<>();
        Set<String> keys = map.keySet();
        for (Object o :keys) {
            ts.add(map.get(o));
        }
        return ts;
    }
    public void delete(String id){
        map.remove(id);
    }
}
class User{
    private int id;
    private int age;
    private String name;
    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}
XZY-SUNSHINE
关注
专栏目录
java泛型初始化
苦战前线的博客
12-25 2776
1.泛型的定义 泛型可以定义在类、接口、方法中，编译器通过识别尖括号和尖括号内部的字母解析泛型。 约定俗成的泛型记号 E:Element，集合中的元素 T:Type,表示某个类 K:Key,键 V:Value,表示值 2.泛型的初始化 在java中泛型为未知类型，只具备执行Object方法的能力，但无法初始化。 例如： //报出Type parameter 'E' cannot be i...
Java基础——泛型
weixin_50458070的博客
05-17 227
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型//在实例化泛型类时，必须指定T的具体类型//key这个成员变量的类型为T,T的类型由外部指定public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定return key;
java 基类的成员方法是泛型_java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一...
weixin_28077113的博客
02-13 596
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于...
泛型代码中的默认关键字default
[hm]
06-06 4054
在泛型类和泛型方法中产生的一个问题是，在预先未知以下情况时，如何将默认值分配给参数化类型 T： T 是引用类型还是值类型。 如果 T 为值类型，则它是数值还是结构。给定参数化类型 T 的一个变量 t，只有当 T 为引用类型时，语句 t = null 才有效；只有当 T 为数值类型而不是结构时，语句 t = 0 才能正常使用。 解决方案是使用 default 关键字，此关键字对于引用类型会返回 nul
泛型算法：Tips (4) --- 再论初始化
feipigwang
08-16 82
总有一些时候，我们不能够借助于“生成式”的初始化方法来给容器赋值，例如我们已经有了一个数组，要把它作为初值赋给一个容器，常规的做法已经深入人心了： int init[] = {2, 3, 5, 7, 11, 13, 17, 19, 23}; std::vector&lt;int&gt; vect(init, init + sizeof(init)/sizeof(int));通过两个 sizeof ...
Java中的泛型详解（一）
小小码农
11-18 706
Java中的泛型详解（一）
Java基础 —— 泛型（二）限制类型参数
能量老8的博客
03-03 983
List
java基础 —— 泛型概述和基本使用
求学之路的苦行僧
09-11 226
泛型概述和基本使用 A:泛型概述 B:泛型好处 提高安全性(将运行期的错误转换到编译期) 省去强转的麻烦 C:泛型基本使用 <>中放的必须是引用数据类型 D:泛型使用注意事项 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) ArrayList存储字符串和自定义对象并遍历泛型版(掌握) A:案例演示 ArrayList存储字符串并遍历泛...
Java高级——泛型
ou_yang_mu_ling的博客
09-11 502
泛型一、为什么要有泛型？1.1 泛型1.2 问题一——类型不安全1.2 问题二——强转时可能出现报错1.3 引出泛型二、在集合中使用泛型2.1 在ArrayList中使用泛型2.2 在HashMap中使用泛型总结三、自定义泛型结构3.1自定义泛型类3.2自定义泛型方法四、泛型在继承上的体现五、通配符的使用六、泛型应用举例 一、为什么要有泛型？ 1.1 泛型 可以理解为生活中的标签 把元素的类型设计成一个参数,这个参数就是泛型 所谓泛型，就是允许在定义类、接口时通过一个标识符表示类中某个属性的类型或者是某个
Java——泛型
Yawn
05-17 206
1. 简介 首先，我们先来说说“语法糖”。 语法糖（Syntactic Sugar）是一个专业性的术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。 Java中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。虚拟机并不支持这些语法，它们在编译阶段就被还原回了简单的基础语法结构，这个过程成为解语法糖。 什么是泛型： 简单来说，泛型就是一种模版 泛型中的类型在使用时指定，主要用于集合中 适用于多种数据类型执行相同的代码 泛型类型变量不能是基本数据类
Java--泛型
weixin_42075274的博客
11-19 573
学习泛型的使用和自定义
Java数据泛型正确的初始化方法
清文的博客
04-05 9897
如果单单使用 T[] array; array = (T[]) new Object[10]; T[] rep() {     return array; } 或 Object[] array; array = new Object[10]; T[] rep() {     return (T[])array;     } 那么当外部使用类调用 GenericArray[] rep =
java泛型 初始化_JAVA泛型（一）泛型基础
weixin_39689347的博客
02-21 690
泛型入门使用泛型Java5之后，Java引入了“参数化类型”的概念，允许程序在创建集合时指定元素的类型。importjava.util.ArrayList;importjava.util.List;public classa{public static voidmain(String[] args){List strList = new ArrayList();strList.add("书本1")...
方法返回泛型
明耀的博客
05-17 2357
public static <T> BaseResult<T> result(Class<T> c){ return new BaseResult<T>() ; }
java泛型关于方法返回值前面的<T>是什么？
大连海大
08-01 1万+
public &lt;T&gt; Test&lt;String,T&gt; setCacheObject(String key,T value){ return null; } 前面的T的声明，跟类后面的 &lt;T&gt; 没有关系。 方法前面的&lt;T&gt;是给这个方法级别指定泛型。 请看示例： package com.fanx; public class Fruit ...
java中的方法返回值使用泛型，实现灵活的返回值类型
热门推荐
junzhen_chen的博客
07-04 7万+
痛点：      使用Mybatis框架的时候，想封装一个底层JDBC控制器，用于提供和Mybatis交互的增删改查接口（公用的接口），但由于公用的查询方法可能是用户自定义的任意一个和表对应的java bean类型，所以要考虑怎么样给调用者返回正确的返回值类型，不需要调用者自己强转型的动作（例如：返回Object类型给调用者，那么调用者就需要拿到这个Object类型进行强转型为表对应的java b
java 返回泛型_泛型方法的返回类型(Java)
weixin_42227736的博客
02-12 3102
我有这个通用功能：public static T sum(List list){Number tot = 0;for(Number n: list){tot = tot.doubleValue() + n.doubleValue();}return (T)tot;}回想一下这段代码的主要内容：public static void main(String[] args) {ArrayList l...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1118
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 157
");
Java基础强化教程——张孝祥讲授
"Java基础加强--张孝祥版.ppt" 这份资料是张孝祥主讲的Java基础强化课程，由传智播客提供。课程旨在提升学员的Java编程技能，内容涵盖了诸多Java进阶主题，包括但不限于Eclipse的使用技巧、静态导入、可变参数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XZY-SUNSHINE

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值