Java笔记之泛型（二十二）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量141 收藏
点赞数
分类专栏： 自学Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/124644385
版权

学习目录

一、泛型

1.案例引入

要求：
请编写程序，在 ArrayList 中，添加 3 个 Dog 对象 Dog 对象含有 name 和 age, 并输出 name 和 age (要求使用 getXxx())

import java.util.ArrayList;

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        ArrayList list = new ArrayList();
        list.add(new Dog("小黄",2));
        list.add(new Dog("小白",1));
        list.add(new Dog("小黑",5));

        //假如不小心，添加了一直猫
        list.add(new Cat("小花",2));

        //遍历
        for (Object o: list) {
            Dog dog = (Dog) o;
            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;
    }
}

以上代码就会出现ClassCastException: com.test.Cat cannot be cast to com.test.Dog
在这里插入图片描述
使用传统方法缺点

  1. 不能对加入到集合ArrayList中的数据类型进行约束（不安全）
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

2.泛型引入

使用泛型解决上面的问题

import java.util.ArrayList;

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        ArrayList<Dog> list = new ArrayList<Dog>();
        list.add(new Dog("小黄",2));
        list.add(new Dog("小白",1));
        list.add(new Dog("小黑",5));

        //假如不小心，添加了一直猫，代码会提示Required type 必须是Dog类型的数据，但是你给它一个Cat数据类型
//        list.add(new Cat("小花",2));

        //遍历
        for (Object o: list) {
            Dog dog = (Dog) o;
            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. 编译时，检查添加元素的类型，提高了安全性
  2. 减少了类型转换的次数，提高效率

不适用泛型：Dog放入到ArrayList会先转成Object，在取出时，还需要转换成Dog
使用泛型：Dog放入ArrayList时和取出时，不需要类型转换，提高效率

二、泛型介绍

1.基本介绍

泛型其实就是一种表示数据类型的数据类型

  1. 泛型又称参数化类型，是jdk5出现的新特性，解决了数据类型的安全性问题
  2. 在类声明或实例化时，只要指定好需要的具体类型即可
  3. java泛型可以保证如果程序在编译时没有发出警告，进行时就不会产生异常。同时代码更加简洁、健壮
  4. 泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型

加深泛型的理解

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        //E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
        test<String> stringtest = new test<String>("String类型");
        System.out.println(stringtest.demo());
        stringtest.getClass1();

        test<Integer> integertest = new test<Integer>(1000);
        System.out.println(integertest.demo());
        integertest.getClass1();
    }
}
/*
泛型的作用：
可以在类声明时通过一个标识表示类中某个属性的类型，
或者是某个方法的返回值的类型，或者是参数类型。
 */
//泛型类
class test<E>{
    E unknown;  //不确定是什么类型

    //E可以是方法参数类型
    public test(E unknown) {
        this.unknown = unknown;
    }

    //E可以是方法返回类型
    public E demo(){
        return unknown;
    }

    //获取它的运行类型
    public void getClass1(){
        System.out.println(unknown.getClass());
    }
}

2.基本语法

泛型声明
接口：interface 接口{ }
类：class 类<K,V>{ }

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

泛型实例化

要在类的后面指定类型参数
比如：
List＜String＞stringtest = new ArrayList＜String＞();

案例练习

要求：
1.创建3个学生对象
2.放入到HashSet中学生对象使用
3.放入到HashMap中，要求Key是String name，Value就是 学生的对象
4.使用两种遍历方式

import java.util.*;

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        //HashSet
        HashSet<Student> students = new HashSet<>();
        students.add(new Student("张三",18));
        students.add(new Student("李四",20));
        students.add(new Student("小明",17));

        //HashMap
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("张三",new Student("张三",18));
        hashMap.put("李四",new Student("李四",20));
        hashMap.put("小明",new Student("小明",17));

        //增强for遍历HashSet
        for (Object o : students) {
            Student student = (Student) o;
            System.out.println(student.getName()+" "+student.getAge());
        }
        System.out.println("=======");
        //迭代器遍历HashMap
        Set<String> keySet = hashMap.keySet();
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            System.out.println(key+" "+hashMap.get(key).getAge());
        }
        System.out.println("=======");
        //EntrySet方式遍历HashMap
        Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator1 = entries.iterator();
        while (iterator1.hasNext()){
            Map.Entry<String, Student> entry  = iterator1.next();
            System.out.println(entry.getKey()+" "+entry.getValue().getAge());
        }

    }
}

class Student{
    private String name;
    private int age;

    public Student(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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.泛型使用细节

  1. interface 接口{ } 或 class 类<K,V>{ }，其中T、K、V必须是引用数据类型
  2. 泛型指定具体类型后，可以传入该类型或者其子类类型
  3. 泛型使用形式
    ①List< String > list1 = new ArrayList< String >();
    ②List< String > list1 = new ArrayList<>(); 简写形式，比较推荐
  4. 如果我们这样写 List list = new ArrayList(); 默认给它的泛型是[< E > E就是 Object ]
import java.util.ArrayList;

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        //细节一
        ArrayList<String> strings = new ArrayList<>();
//        ArrayList<int> ints = new ArrayList<int>();   //错误的

        //细节二
        C<A> A = new C<A>(new A());
        C<A> A1 = new C<A>(new B());

        //细节三
        ArrayList<String> strings1 = new ArrayList<>(); //这里编译器会自动推断
        ArrayList<String> strings2 = new ArrayList<String>();

        //细节四
        ArrayList list = new ArrayList();
        ArrayList<Object> list1 = new ArrayList<Object>();  //跟上面等价
    }
}

class A{}
class B extends A{}
class C<E>{
    E s;

    public C(E s) {
        this.s = s;
    }
}

细节四
在这里插入图片描述
Object e其实就是ArrayList默认的泛型

综合案例练习
要求：

  1. 定义 Employee 类，该类包含：private 成员变量 name,sal,birthday，其中 birthday 为 MyDate 类的对象
  2. 为每一个属性定义 getter, setter 方法
  3. 重写 toString 方法输出 name, sal, birthday
  4. MyDate 类包含: private 成员变量 month,day,year；并为每一个属性定义 getter, setter 方法；
  5. 创建该类的 3 个对象，并把这些对象放入 ArrayList 集合中（ArrayList 需使用泛型来定义），对集合中的元素进 行排序，并遍历
  6. 调用 ArrayList 的 sort 方法 排序, 传入Comparator 对象[使用泛型]，先按照 name 排序，如果 name 相同，则按生日日期的先后排序
import java.util.ArrayList;
import java.util.Comparator;

class test1{
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom",5000,new MyDate(2022,8,15)));
        employees.add(new Employee("juck",6000,new MyDate(2022,2,19)));
        employees.add(new Employee("juck",10000,new MyDate(2022,4,20)));

        employees.sort(new Comparator<Employee>(){
            @Override
            public int compare(Employee o1, Employee o2) {
                //判断是否为Employee类型的数据;如果不是就不进行比较
                if (!(o1 instanceof Employee && o2 instanceof Employee)){
                    return 0;
                }
                //判断name是否相同，compareTo字符串的比较
                int i = o1.getName().compareTo(o2.getName());
                if (i != 0 ){
                    return i;
                }

                //如果name相同，判断year
                int i1 = o1.getBirthday().getYear() - o2.getBirthday().getYear();
                if (i1 != 0){
                    return i1;
                }

                //如果name相同，判断month
                int i2 = o1.getBirthday().getMonth() - o2.getBirthday().getMonth();
                if (i2 != 0){
                    return i2;
                }

                //如果name相同，判断day
                int i3 = o1.getBirthday().getDay() - o2.getBirthday().getDay();
                if (i3 != 0){
                    return i3;
                }

                return 0;
            }
        });

        for (Object o: employees) {
            System.out.println(o);
        }
    }
}

class Employee {
    private String name;
    private int sal;
    private MyDate birthday;

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday.getYear() +
                ", birthday=" + birthday.getMonth() +
                ", birthday=" + birthday.getDay() +
                '}';
    }
}

class MyDate{
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
}
王博1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java基础学习笔记之泛型
09-02
所谓泛型，就是变量类型的参数化。泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的...
JAVA泛型笔记.pdf
12-01
JAVA泛型笔记.pdf
Java笔记之泛型（二十三）
weixin_44604159的博客
06-21 82
介绍了自定义泛型类、自定义泛型接口、自定义泛型接口
Java学习笔记之泛型
qq_46113679的博客
05-23 93
泛型（一种未知的数据类型） 泛型可以看作是一个变量，用来接收数据类型，eg. E:Element元素（未知的 数据类型） 注意： 泛型的标志是那对尖括号，里面的泛型接收值可自定义 定义含有泛型的类与方法 定义含有泛型的类： 格式： class 类名<泛型> { } 定义含有泛型的方法：泛型定义在修饰符与返回值类型之间 格式： 修饰符 <泛型> 返回值类型 方法名(参数列表（可以使用泛型）){ //方法体 } 泛型使用的利弊 使用泛型 利： 1.避
[Java 学习笔记] 泛型
☆迷茫Dog的秘密基地☆
10-17 648
目录 泛型的向上转型 将静态方法的泛型类型和实例类型的泛型类型区分开 多泛型类 java可以创建泛型数组(待完善) Java实现泛型的方法——擦拭法 由此,Java泛型的局限也体现出来 泛型继承(loading) 通配符(loading) 泛型与反射(loading) 总结自廖雪峰老师的Java教程: Java教程 - 廖雪峰的官方网站 (liaoxuefeng.com)https://www.liaoxuefeng.com/wiki/1252599548343744 泛型的...
【java笔记】泛型定义和使用
热门推荐
暮色年华的博客
02-25 1万+
概述： 泛型是一种未知的数据类型，当不知道使用什么数据类型的时候，可以使用泛型 泛型可以接受任意类型的类型，可以使用Integer,String,Student... E :未知的数据类型 例：public class ArrayList<E>{ public boolean add(E e){} public E get(int index){} 创建集合对象的时候，会确定泛型的数据类型 String作为参数赋值给E ...
Java笔记之泛型
u012250063的博客
05-10 175
什么是泛型？ 为什么使用泛型？ 泛型对数据类型有影响吗？ 泛型通配符
java笔记之 泛型
qq_32473523的博客
12-11 74
泛型概述： 泛型：是JDK5中 引入的特性，他提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型 它的本质是参数化类型，也就是说操作的数据类型被指定为一个参数，这里的参数化类型，是将类型由原来的具体的类型参数化，然后在使用或者调用的时候传入具体的类型 这种参数类型可以用在类、方法、接口中，分别被称为泛型类、泛型方法、泛型接口 泛型定义格式： <类型> : 指定一种类型的格。这里的类型可以看成是形参 <类型1，类型2...>: 指定多种类型的格式，多种类型之间
JAVA笔记—泛型
maohe的博客
08-19 166
泛型知识点
Java笔记 —— 泛型
2401_84558326的博客
05-23 692
为什么我不完全主张自学？①平台上的大牛基本上都有很多年的工作经验了，你有没有想过之前行业的门槛是什么样的，现在行业门槛是什么样的？以前企业对于程序员能力要求没有这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
Java学习笔记：泛型
Z_jl123的博客
02-10 1578
1、泛型 泛型的本质是参数化类型，是将类的类型参数化，具体调用的时候再给具体的类型。这种参数类型可以用在类、方法和接口的创建中，方便称为泛型类、泛型接口和泛型方法。 我们知道JAVA中所有的参数必须提前声明参数类型，例如方法的形参中，如果我们在定义这个方法时不知道这个参数的类型，要等具体调用时才知道，这时我们可以使用泛型来代替那些定义时还不明确的参数类型。 2、定义格式 泛型类：public class 类名 <T> { } 泛型接口：public interface 接口名 <
Java学习笔记之泛型方法的返回值问题
weixin_46828458的博客
03-19 3372
关于泛型方法的返回值 在上JDBC的课中，用到了泛型方法。 泛型的类型推断： 调用泛型方法，对其声明一个类型的变量，则在此方法中的泛型就会被赋予该类型。在此方法中： 若语句为：String str = getValue(conn,sql,…args); 则其泛型类型为String，也就是实际中该方法的E为String 若为：Long long = getValue(conn,sql,…args); 则其泛型类型为Long，则实际中该方法的E为Long。 ...
java李兴华学习笔记之泛型
09-07
收集的java李兴华老师的课件笔记。感觉还不错，适合回顾和新手补习。
Java基础笔记之集合框架和泛型
07-31
详细的介绍了集合框架的用法，及其语法规则，剖析了使用的使用注意事项，帮助更牢靠的掌握集合框架的知识及泛型内容。谢谢
Java泛型学习笔记.pdf
10-04
Java泛型学习笔记.pdf
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 864
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1190
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 480
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java多线程创建方式
weixin_57763462的博客
05-28 1035
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
 java 中的泛型 （二
06-07
Java中的泛型是一种编程机制，它可以在类或方法中定义一种参数类型，而不是指定具体的类型。这样可以使代码更加通用和灵活，同时也可以提高代码的安全性和可读性。 在Java中，泛型可以应用于类、接口、方法等各种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王博1999

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

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

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

打赏作者

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

抵扣说明：

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

余额充值