Java12-泛型

最新推荐文章于 2024-08-28 23:47:02 发布
最新推荐文章于 2024-08-28 23:47:02 发布
阅读量264 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40893824/article/details/110237735
版权

https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4

https://how2j.cn/frontroute
https://how2j.cn/k/generic/generic-generic/373.html

目录

1 集合泛型

1.1 泛型的便利

不用泛型：

	public static void main(String[] args) {    
        ArrayList heros = new ArrayList();
         
        heros.add(new APHero());
        heros.add(new ADHero());
         
        APHero apHero =  (APHero) heros.get(0);
        ADHero adHero =  (ADHero) heros.get(1);
         
        ADHero adHero2 =  (ADHero) heros.get(0);
    }

ADHero adHero2 = (ADHero) heros.get(0); 就会报错

使用泛型：

public static void main(String[] args) {
        ArrayList<APHero> heros = new ArrayList<APHero>();
         
        //只有APHero可以放进去    
        heros.add(new APHero());
         
        //ADHero甚至放不进去
        //heros.add(new ADHero());
         
        //获取的时候也不需要进行转型，因为取出来一定是APHero
        APHero apHero =  heros.get(0);
    }

1.2 子类对象

public static void main(String[] args) {
        ArrayList<Hero> heros = new ArrayList<Hero>();
         
        //只有作为 Hero 的子类可以放进去     
        heros.add(new APHero());
        heros.add(new ADHero());
         
        //和 Hero 无关的类型 Item 放不进去
        //heros.add(new Item());
    }

1.3 简写

public static void main(String[] args) {
        ArrayList<Hero> heros = new ArrayList<Hero>();
        //后面可以只用<>
        ArrayList<Hero> heros2 = new ArrayList<>();         
    }

1.4 练习

设计集合，可以放整数，也可以放浮点数，但不能放字符串

package 第16个程序_泛型.a1_集合泛型.练习;

import java.util.ArrayList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        List<Number> list = new ArrayList<>();
        list.add(1);
        list.add(12.2);
//        list.add("12");
        System.out.println(list);
    }
}

2 泛型的类

比较【不能泛型】和【泛型】的好处

2.1 不能泛型

package 第16个程序_泛型.a2_泛型的类.s1_比较.不可泛型;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name){
        this.name = name;
    }
}

package 第16个程序_泛型.a2_泛型的类.s1_比较.不可泛型;

// 物品
public class Item {
    String name;
    int price;

    public Item(String name){
        this.name = name;
    }
}

package 第16个程序_泛型.a2_泛型的类.s1_比较.不可泛型;

import java.util.LinkedList;

public class HeroStack {
    LinkedList<Hero> heros = new LinkedList<>();

    //进栈
    public void push(Hero hero){
        heros.addLast(hero);
    }

    //出栈
    public Hero pull(){
        return heros.removeLast();
    }

    //获取栈顶元素
    public Hero peek(){
        return heros.getLast();
    }

    public static void main(String[] args) {
        HeroStack stack = new HeroStack();
        for (int i = 0;i < 10; i++){
            Hero h = new Hero("hero " + i);
            System.out.println("进栈: " + h.name);
            stack.push(h);
        }

        System.out.println("\n出栈:");
        for (int i = 0; i < 10; i++){
            Hero h = stack.pull();
            System.out.println(h.name);
        }
    }
}


package 第16个程序_泛型.a2_泛型的类.s1_比较.不可泛型;

import java.util.LinkedList;

public class ItemStack {
    LinkedList<Item> items = new LinkedList<>();
    public void push(Item item){
        items.addLast(item);
    }

    //出栈
    public Item pull(){
        return items.removeLast();
    }

    //取栈顶元素
    public Item peek(){
        return items.getLast();
    }

    public static void main(String[] args) {
        ItemStack stack = new ItemStack();
        for (int i = 0;i < 10; i++){
            Item item = new Item("item " + i);
            System.out.println("进栈: " + item.name);
            stack.push(item);
        }

        System.out.println("\n出栈:");
        for (int i = 0; i < 10; i++){
            Item item = stack.pull();
            System.out.println(item.name);
        }
    }
}

2.2 可以泛型

package 第16个程序_泛型.a2_泛型的类.s1_比较.可以泛型;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name){
        this.name = name;
    }
    public Hero() {
    }
}

package 第16个程序_泛型.a2_泛型的类.s1_比较.可以泛型;

// 物品
public class Item {
    String name;
    int price;

    public Item(String name){
        this.name = name;
    }
}

package 第16个程序_泛型.a2_泛型的类.s1_比较.可以泛型;

import java.util.LinkedList;

public class MyStack<T> {
    LinkedList<T> list = new LinkedList<>();
    int length = 0;

    //进栈
    public void push(T t){
        list.addLast(t);
        length++;
    }

    //出栈
    public T pull(){
        return list.removeLast();
    }

    //获取栈顶元素
    public T peek(){
        return list.getLast();
    }

    public static void main(String[] args) {
        MyStack<Hero> heroMyStack = new MyStack<>();
        System.out.println("进栈 heroMyStack :");
        heroMyStack.push(new Hero("hero " + 1));
        heroMyStack.push(new Hero("hero " + 2));
        System.out.println("出栈 :");
        for (int i = 0; i < heroMyStack.length; i++){
            System.out.println(heroMyStack.pull().name);
        }

        MyStack<Item> itemMyStack = new MyStack<>();
        System.out.println("\n进栈 itemMyStack :");
        itemMyStack.push(new Item("item " + 1));
        itemMyStack.push(new Item("item " + 2));
        System.out.println("出栈:");
        for (int i= 0; i < itemMyStack.length; i++){
            System.out.println(itemMyStack.pull().name);
        }
    }
}

2.3 练习

二叉树的 Node 改成泛型

package 第16个程序_泛型.a2_泛型的类.练习_二叉树;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name){
        this.name = name;
    }
}

package 第16个程序_泛型.a2_泛型的类.练习_二叉树;

import 第15个程序_集合框架.a4_其他.s2_比较器.排序Comparable.Hero;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Node<T extends Comparable<T>> {
    public Node<T> left;
    public Node<T> right;
    public T value;

    //插入
    public void add(T e){
        if (value == null)
            value = e;
        else {
            if (e.compareTo(value) <= 0){
                if (left == null)left = new Node<>();
                left.add(e);
            } else{
                if (right == null)right = new Node<>();
                right.add(e);
            }
        }
    }

    public List<T> values(){
        List<T> list = new ArrayList<>();
        if (left != null){
            list.addAll(left.values());
        }
        list.add(value);
        if (right != null){
            list.addAll(right.values());
        }
        return list;
    }

    public static void main(String[] args) {
        Node<Integer> node = new Node<>();
        node.add(1);
        node.add(2);
        node.add(3);
        node.add(4);
        System.out.println("输出 Node<Integer> node :");
        System.out.println(node.values());

        Random r = new Random();
        Node<Hero> node1 = new Node<>();
        for (int i = 0; i < 5; i++){
            node1.add(new Hero("hero " + r.nextInt(100)));
        }
        System.out.println("\nNode<Hero> node1");
        System.out.println(node1.values());
    }
}

3 通配符

先总结：
只取 不插，用? extends Hero
只插 不取，用? super Hero
又能插入，又能取出，不要用通配符？

3.1 ? extends

ArrayList heroList<? extends Hero>：这是 Hero 泛型或其子类泛型

heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero

从 heroList 取出的对象，一定可以转成 Hero 的
但不能往里面放东西

3.2 ? super

ArrayList heroList<? super Hero>：这是 Hero 泛型或其父类泛型
heroList 的泛型可能是 Hero
heroList 的泛型可能是 Object

可以往里面插入 Hero 以 Hero 子类
但取元素有风险，因为不确定取出来是 Hero 还是 Object

3.3 泛型通配符 ?

? 代表任意泛型，这个容器什么泛型都有可能
只能以 Object 的取出来
不能往里放对象，因为不知道这是什么泛型的容器

3.4 练习1

如下代码所示，遍历不同泛型的 3 种集合，要设计 3 个方法
借助? extends， 把代码减到只用 1 种方法

package generic;
 
import java.util.ArrayList;
 
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
 
public class TestGeneric {
 
    public static void iterate(ArrayList<Hero> list) {
        for (Hero hero : list) {
            System.out.println(hero.name);
        }
    }
 
    public static void iterateAP(ArrayList<APHero> list) {
        for (Hero hero : list) {
            System.out.println(hero.name);
        }
    }
 
    public static void iterateAD(ArrayList<ADHero> list) {
        for (Hero hero : list) {
            System.out.println(hero.name);
        }
    }
 
    public static void main(String[] args) {
        ArrayList<Hero> hs = new ArrayList<>();
        ArrayList<APHero> aphs = new ArrayList<>();
        ArrayList<ADHero> adhs = new ArrayList<>();
 
        iterate(hs);
        iterateAP(aphs);
        iterateAD(adhs);
    }
}

解答：

package 第16个程序_泛型.a3_通配符.练习;

import java.util.ArrayList;
import java.util.List;

public class test {
    public static void iterate(List<? extends Hero> list){
        System.out.println("遍历:");
        for (Hero hero:list){
            System.out.println(hero.name);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayList<Hero> hs = new ArrayList<>();
        ArrayList<ADHero> adhs = new ArrayList<>();
        ArrayList<APHero> aphs = new ArrayList<>();

        hs.add(new Hero("hero 1"));
        hs.add(new Hero("hero 2"));

        adhs.add(new ADHero("adhero 1"));
        adhs.add(new ADHero("adhero 2"));

        aphs.add(new APHero("aphero 1"));
        aphs.add(new APHero("aphero 2"));

        iterate(hs);
        iterate(adhs);
        iterate(aphs);
    }
}

3.5 练习2

二叉树改造成 支持泛型 <T extends Comparable>
比较时，用 compare 方法

package 第16个程序_泛型.a3_通配符.练习2;

public class Hero implements Comparable<Hero> {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name){
        this.name = name;
    }

    @Override
    public int compareTo(Hero o) {
        if(hp > o.hp)
            return 1;
        else
            return -1;
    }
}

package 第16个程序_泛型.a3_通配符.练习2;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Node<T extends Comparable<T>> {
    public Node<T> left;
    public Node<T> right;
    public T value;

    //插入
    public void add(T e){
        if (value == null)
            value = e;
        else {
            if (e.compareTo(value) <= 0){
                if (left == null)left = new Node<>();
                left.add(e);
            } else{
                if (right == null)right = new Node<>();
                right.add(e);
            }
        }
    }

    //中序遍历
    public List<T> inOder(){
        List<T> list = new ArrayList<>();
        if (left != null){
            list.addAll(left.inOder());
        }
        list.add(value);
        if (right != null){
            list.addAll(right.inOder());
        }
        return list;
    }

    public static void main(String[] args) {
        Node<Integer> node = new Node<>();
        node.add(1);
        node.add(2);
        node.add(3);
        node.add(4);
        System.out.println("输出 Node<Integer> node :");
        System.out.println(node.inOder());

        Random r = new Random();
        Node<Hero> node1 = new Node<>();
        for (int i = 0; i < 5; i++){
            node1.add(new Hero("hero " + r.nextInt(100)));
        }
        System.out.println("\nNode<Hero> node1");
        for (Hero hero: node1.inOder()){
            System.out.println(hero.name);
        }
    }
}

4 泛型转型

4.1 对象转型 可行

子类转父类 = 父 = 子 = Hero h = new ADHero(); = 中国人 a = new 湖北人();

4.2 子类泛型 转 父类泛型 不可行

public static void main(String[] args) {
        ArrayList<Hero> heros = new ArrayList<>();
        ArrayList<ADHero> adHeroes = new ArrayList<>();
        heros = adHeroes;
    }

会报错！

假设转型成功
ArrayList<Hero> heros 可以放入 APHero
ArrayList<ADHero> adHeroes又当成 ArrayList<Hero> heros
相当于 ArrayList<ADHero> adHeroes 中放入了 APHero，矛盾！
子类泛型 转 父类泛型 不可行
父类泛型 转 子类泛型 不可行(同样)

qq_1403034144
关注
专栏目录
Java重点--泛型
YOU__FEI的博客
10-01 2528
定义一个含有泛型的类，模拟ArrayList集合泛型是一个未知的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型泛型可以接收任意的数据类型，可以使用Integer,String,Student…创建对象的时候确定泛型的数据类型好处 ：类型不写死，创建对象泛型是什么类型，类中泛型就是什么类型首先定义一个含有泛型的类public class 含有泛型的类 < E > {} //所有使用数据类型的时候，都使用了泛型E }接着就可以在主方法中使用它了public class 主方法 {
Java----泛型与集合
m0_64063877的博客
03-19 3400
Java----泛型与集合一、泛型二级目录三级目录 一、泛型 1、泛型的安全机制 泛型作用：强制了集合存储固定的数据类型 2、书写格式 //集合类<> 3、泛型的好处 ①安全性提高了 ②程序代码量减少 ③避免了强制类型转换 ④程序的问题提前到了运行前 4、泛型中的E E没有实际价值，只是一个变量 特殊：等待接收指定的数据类型 ArrayList<String> ar = new ArrayList<String>(); //此时E变成String类型 5、自定
JAVA---泛型
weixin_56777219的博客
01-10 2519
JAVA---泛型
Java--泛型
weixin_42075274的博客
11-19 585
学习泛型的使用和自定义
Java基础---泛型
最新发布
jlihan的博客
08-28 8232
在Java中，泛型是通过在类或接口后添加一对尖括号（< >）并在其中指定类型参数来定义的。这些类型参数在类的定义中作为占位符，用于指定实际类型。泛型类的定义语法class 类名称 <泛型标识、泛型标识，...> {private 泛型标识 变量名；......常用的泛型标识 T、E、K、V代码示例package 泛型;//泛型：能够代表一切类型//定义数组//Object 是所有类的父类 把父类转换为子类//添加数据i++;//输出数据。
Java集合--泛型集合
likehack的博客
09-07 830
泛型集合的使用
JAVA高级-泛型
weixin_47303191的博客
03-21 817
泛型 什么是泛型 jdk5.0新增的特性。 我们可以将中药柜作比喻，每一种中药是一个类，这个类里面有不同品种的中药。比如，大黄是一个类，但是大黄的品种有很多。 我们要找到中药这个类，就要在中药柜上面贴上标签，里面的品种就如同一个类下的各种类型属性。 中药柜上的标签，就是我们的泛型，以此推出： 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入
java-泛型-参数
weixin_57830401的博客
02-20 1397
泛型类： 定义格式 修饰符 class 类名<类型> { } 示例代码 泛型类 public class Generic<T> { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } } 测试类 public class GenericDemo { public stati.
Java-EE-泛型
qq_43156057的博客
04-25 1089
Java引入泛型主要是为了提高类型安全性和代码的可读性。
JAVA泛型-泛型方法的定义和使用
热门推荐
northcastle的博客
10-23 5万+
1.泛型方法的定义和语法 1.1 定义 泛型方法 是在调用方法的时候指明泛型的具体类型。 【泛型方法 能够使方法独立于类的处理指定的类型。】 1.2 语法 修饰符 <T,E,…> 返回值类型 方法名（形参列表）{ 。。。。。。 } 修饰符与返回值类型中间的 泛型标识符 <T,E,…>,是 泛型方法的标志，只有这种格式声明的方法才是泛型方法。 泛型方法声明时的 泛型标识符 <T,E,…> 表示在方法可以使用声明的泛型类型。 与泛型类相同，泛型标识符可以是任意类
8-java进阶-泛型1
08-03
泛型是Java编程中的一个重要概念，它提供了一种在编译时期检查类型安全性的机制，同时也减少了强制类型转换的需要。泛型主要应用于类、接口和方法中，用来限制可以存储或处理的数据类型。 1. **泛型的意义**： - ...
大学课程讲义-Java基础-泛型.docx
08-14
Java泛型是Java编程语言中的一种特性，它允许在数据结构（如集合）中存储特定类型的元素，从而提供了编译时的类型安全性和更清晰的代码。泛型引入的主要目标是消除强制类型转换的需要，减少类型转换带来的潜在错误，...
Java-泛型.ppt
07-17
### Java泛型详解 #### 一、什么是泛型？ 在Java中引入泛型之前，开发者通常使用`Object`类型的集合来存储多种不同类型的对象。这种方式虽然灵活，但在使用过程中需要频繁进行类型检查或类型转换，这不仅增加了...
Java03-命名规范/ 注释/ 排版(换行、空格)
qq_1403034144的博客
01-15 1128
1. 命名规范 名字一般是两个单词的组合 驼峰命名： 大驼峰 vs 小驼峰 大驼峰：两个单词首字母大写，如ClassRoom 小驼峰：仅第二个单词首字母大写，如classRoom 包名、类名、接口名、变量、常量均使用大驼峰 2. 注释 2.1 //单行注释，快捷键：ctrl + / 或 Ctrl + shift + C，相同操作取消注释 2.2 /* … */多行注释，快捷键：ctrl + shi...
Java11-集合框架
qq_1403034144的博客
11-27 1020
https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4 https://how2j.cn/frontroute https://how2j.cn/k/collection/collection-arraylist/363.html 目录ArrayList集合框架和数组常用方法其他集合关系与区别其他 ArrayList 集合框架和数组 数组的局限性： 声明长度是 10 的数组 不用的数组浪费了 超过 10 又放不下… 为解决数
Java02-标识符/ 关键字、数据类型/ 分隔符/ 常量final/ 运算符
qq_1403034144的博客
01-15 1014
1. 标识符，给变量起名 a. 区分大小写 b. _/ $/ 字母/ 数字，数字不可在首位 c. 关键字不可作为标识符 2. 关键字 关键字全是小写的！ 数据类型：boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof 语句：break、case、 catch、 continue、 defaul...
java什么时候用try
qq_1403034144的博客
11-03 877
try { 程序运行成功时执行 } catch { 异常时执行 } finally { 总要执行 } 程序要打开资源，使用完后要关闭的情况下，要使用 try-catch！ 网络连接，即使程序一点错也没有，但网络有可能有不稳定，不知道什么地方会出现错误，要 try…catch 一下 文件、io 也一样，都可能产生不可预料的错误，要try…catch 具体： 代码执行预料不到的情况，用 try-catch a除以b，但 b 是变量，如果b等于0程序就会出错，用 try-ca
Java10-I/O
qq_1403034144的博客
11-18 877
https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4 https://how2j.cn/frontroute https://how2j.cn/k/io/io-file/345.html 目录文件创建常用方法12流字节流关闭流字符流中文问题缓存流对象流System.in练习 文件 创建 package 第14个程序_IO.a1_文件; import java.io.File; public class test {
Java基础-泛型详解
"这份大学课程讲义主要介绍了Java编程中的泛型概念，旨在提高代码的类型安全性、可读性和稳定性。泛型允许程序员在编写代码时指定容器（如List）所容纳的对象类型，从而在编译阶段就能检测出类型错误，避免了运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qq_1403034144

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

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

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

打赏作者

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

抵扣说明：

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

余额充值