JavaSE学习：第二十七章、泛型

已于 2022-04-22 14:40:50 修改
阅读量118 收藏
点赞数
文章标签： 学习 java
于 2022-04-03 19:59:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HSF_213156/article/details/123918660
版权

1、概念：

泛型就是用来定义可以传入什么数据类型，限制传入的数据类型。
指定泛型的具体类型之后，可以传入该类型或者该类的子类型。

2、意义：

1、泛型的好处,可以在编译时进行数据类型检查。

例如：

 //约束collection集合中只能存储String类型的数据
Collection<String> collection = new ArrayList<>();

推荐写法：
在这里插入图片描述

3、使用：

类和接口中使用：

package com.hsf.First;/*
 * @author HSF
 * @version 8.0
 */

public class Generic02 {
    public static void main(String[] args) {
        Person<String,Integer> stringPerson = new Person<String,Integer>("liLei");
    }
}

class Person<E,K> {

    E name;

    public Person(E name) {
        this.name = name;
    }

    public E fn() {
        return name;
    }
}

集合使用：

package com.hsf.First;/*
 * @author HSF
 * @version 8.0
 */

import java.util.ArrayList;

public class First_ {
    public static void main(String[] args) {
        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog("旺财", 10));
        dogs.add(new Dog("大黄", 8));
        dogs.add(new Dog("小黄", 12));
        // dogs.add(new Cat());  // 不是Dog类型：报错

        /*
        没有使用泛型之前：只能接收一个Object对象，并且要进行向下转型，才可以使用dog的get和set方法。
        for (Object o : dogs) {
            Dog dog = (Dog)o;
            System.out.println(dog.getName());
        }
        */

        // 使用泛型之后：可以直接使用dog对象来接收
        for (Dog dog : dogs) {
            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 {

}


package com.hsf.First;/*
 * @author HSF
 * @version 8.0
 */

import com.sun.org.apache.xml.internal.serializer.ToStream;

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

public class Test {
    public static void main(String[] args) {
        Map<String, Student> map = new HashMap<String, Student>();
        Student liLei = new Student("liLei", 20);
        Student mary = new Student("mary", 18);
        Student jack = new Student("jack", 25);
        map.put("liLei", liLei);
        map.put("mary", mary);
        map.put("jack", jack);

        // entry遍历
        Set<Map.Entry<String, Student>> entries = map.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey());
            System.out.println(next.getValue());
        }
    }
}

class Student {
    public String name;
    public int age;

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return  name + " " + age;
    }
}

作业：定制排序：

package com.hsf.First;/*
 * @author HSF
 * @version 8.0
 */

import java.util.ArrayList;
import java.util.Comparator;

public class HomeWork {
    public static void main(String[] args) {
        Employee liLei = new Employee("liLei", 3000, new MyDate(2020, 1, 1));
        Employee Mary = new Employee("Mary", 9000, new MyDate(2022, 3, 1));
        Employee Jack = new Employee("liLei", 6000, new MyDate(2020, 1, 2));
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(liLei);
        employees.add(Mary);
        employees.add(Jack);

        // 作业要求：定制排序
        // 调用ArrayList的sort方法，传入comparator对象，先按照name进行排序，如果name相同，则按生日日期进行排序。
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                // 先比较name
                int i = o1.getName().compareTo(o2.getName());
                if (i != 0) {
                    return i;
                }
                // 再比较生日
                return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        System.out.println(employees);
    }
}

class Employee {
    private String name;
    private double dal;
    private MyDate birthday;

    public Employee(String name, double dal, MyDate birthday) {
        this.name = name;
        this.dal = dal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public double getDal() {
        return dal;
    }

    public void setDal(double dal) {
        this.dal = dal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", dal=" + dal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate implements Comparable<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;
    }

    @Override
    public int compareTo(MyDate o) {
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        int MonthMinus = month - o.getMonth();
        if (MonthMinus != 0) {
            return MonthMinus;
        }
       return day - o.getDay();
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

1、自定义泛型类：

class Tiger<T,R,E> {
    T name;
    R age;
    E gender;

    public Tiger(T name, R age, E gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
 // 不能初始化：因为数组在new的时候，不能确定T的类型，就无法开辟空间。
    T[] ts = new T[8];
    T[] ts1; // 可以定义
}

注意点：

1、类后面有泛型，我们称为自定义泛型。
2、T,R,E 泛型标识符，可以写多个。
3、普通成员也可以使用泛型。
4、使用泛型的数组不能初始化。
5、静态方法和静态属性不能使用泛型：
a、因为静态成员是在类加载的时候执行，而泛型是在类创建的时候指定，而类加载 又先于对象创建，因此在类加载的时候无法知道成员类型，无法进行初始化。
6、如果创建对象时没有指定泛型，默认为Object。

2、自定义泛型接口：

如果没有指定类型，默认是Objectl类型:
class IComputer implements IUsb<Object, Object>

// 实现泛型接口后，String--E；Integer -- T;
class IComputer implements IUsb<String, Integer> {

    @Override
    public String get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Integer integer) {

    }

    @Override
    public void run(String e1, String e2, Integer t1, Integer t2) {

    }
}

interface IUsb<E,T> {
//    E name; 普通属性不能使用泛型，以为接口中属性默认是静态的 
    // 抽象方法
    E get(T t);

    void hi(T t);

    void run(E e1, E e2, T t1, T t2);

    // 默认方法
    default E method(T t) {
        return null;
    }
}

3、自定义泛型方法：

package com.hsf.First;/*
 * @author HSF
 * @version 8.0
 */

public class Method_ {
    public static void main(String[] args) {
        Animal<String> animal = new Animal<>();
        animal.eat("jack", 12);
    }
}

class Animal<E> {
    public void run() {}; // 普通方法

    // 泛型方法：使用了一个泛型类声明的泛型E，也是用了一个自己声明的泛型T
    public<E, T> void eat(E e, T t) {
        System.out.println(e.getClass()); // string
        System.out.println(t.getClass()); // integer
    }
    // 泛型方法：两个都是自己声明的泛型K,T
    public<K, T> void hi(K k, T t) {}
    // 使用了泛型，不叫泛型方法，只能在泛型类中使用，因为只能用泛型类声明的泛型。
    public void say(E e) {}

}

class People<E,K> {

}

4、泛型的继承和通配符：

1、泛型不具备继承性，不可被继承。

List<Object> lsit= new ArrayList<String>(); // 错误string虽然是object子类，但是不可被继承

2、通配符：
a、<?>：表示支持任意泛型类型。
b、<? extends A>：支持A类以及A类的子类，规定了泛型的上限：即最上面只能到A类。
c、<? super A>：支持A类及A类的父类，规定了泛型的下限：即最底下只能到A类。

HSF_213156
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
泛型note
努力笨小孩的博客
04-18 155
引入：例如我们想要在 List l = new ArrayList()中存放Dog对象时，是将Dog——>Object，而要取出对象时，需要判断类型，将Object强转为Dog，在加入时不能对存入对象的类型进行数据类型的约束，是不安全的，也就是说我们存入一个Cat对象也能存进去。类型转换在数据量较大时对效率是有影响的。如果我们使用泛型<>，就可以在编译时检查我们存入的对象类型是否符合要求，且不再提示编译警告。 一、定义：用来指定数据类型的参数，也称参数化类型。在jdk5.0出现的，用于.
javase项目：学生在线考试系统
05-13
总的来说，JavaSE学生在线考试系统是一个综合性的项目，涵盖了Java编程基础、数据库操作、网络通信等多个方面，对于学习和掌握JavaSE技术有着极大的实践价值。通过这个项目，开发者不仅可以提升编程技能，还能了解并...
java基础——泛型
上邪的博客
10-11 186
java基础 笔记的都是需要背诵的零散知识点，以顺序的方式组织 文章目录java基础一、泛型二、Junit 一、泛型 1、给泛型指向数据类型是，要求是引用类型，不能是基本数据类型 2、ArrayList arrayList = new ArrayList();泛型默认是 Object 3、自定义泛型类注意事项： （1）语法： class类名<T,R…>{//表示可以有多个泛型成员} （2）普通成员可以使用泛型(属性、方法)2)使用泛型的数组，不能初始化 （3）静态方法中不能使用类的泛
Java学习13：泛型
weixin_43741998的博客
11-10 291
13. 泛型 引入泛型：下列代码在list集合中添加了三个Dog对象，然后添加一个Cat对象，然后循环遍历输出list集合Dog对象信息，但是因为有一个Cat对象，所以在向下转型时会抛出一个ClassCastException(类转换异常)， public class Generic01 { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(new D
java泛型详解
weixin_52385232的博客
06-25 2421
java泛型详解
《JavaSE 基础知识》泛型的基本介绍和应用。
yzh2776680982的博客
06-05 4386
一、泛型的基本介绍 1、传统方法存在的问题 不能对加入到集合 ArrayList中的数据类型进行约束(不安全) 遍历的时候， 需要进行类型转换，如果集合中的数据量较大，对效率有影响
JavaSE学习笔记：集合框架、迭代器、泛型
超级无敌小胖头
10-26 352
文章目录一、集合框架概述1.Collection和Map2.Collection集合3.Collection集合常用方法二、迭代器1.常用方法2.如何获取迭代器3.使用步骤(掌握)4.使用实例5.迭代器使用原理三、增强型for循环(更常用)1.简介2.使用实例3.注意点四、泛型1.泛型的概念2.使用泛型的好处2.1使用集合对象，不使用泛型会带来的问题2.1.1实例2.1.2注意点2.2使用集合使用...
【Java基础系列教程】第十八章 Java泛型详解
波哩个波的博客
03-09 524
一、泛型概述 二、简单示例解析概念 三、类型擦除 四、自定义泛型结构 五、泛型在继承上的体现 六、通配符的使用 七、泛型应用举例 八、面试题
JavaSE_第十二章:集合
开心点的博客
04-05 178
JavaSE学习历程 第一章:Java初识 第二章:Java语言基础 第三章:选择结构与分支结构 第四章:循环结构 第五章:方法/函数 第六章:数组 第七章:面向对象 第八章:三大特性 第九章:三个修饰符 第十章:接口 第十一章:常用类 第十二章:集合 1 集合的概念 什么是集合 概念:对象的容器,定义了对多个对象进行操作的常用方法.可实现数组的功能. 集合和数组区别 数组长度固定,集合长度不固定 数组可以存储基本类型和引用类型,集合只能存储引用类型 集合位置:java.util.*;
Exer.java（JavaSE泛型学习笔记）
04-19
泛型学习笔记2的源代码，泛型 ： 要解决类型的安全问题， 如果使用Object类型会带来类型的损失。典型的应用就是在集合中， 集合中理论上可以保存任意对象，实际上我们应该让它泛型化，集合类<元素类型>, 添加元素...
JavaSE:JavaSE学习笔记
04-07
- **构造器**：学习如何定义和使用构造器来初始化对象。 - **重写与重载**：了解方法的覆盖（override）和重载（overload）。 3. **异常处理** - **异常分类**：Java中的异常分为检查性异常和运行时异常，学习...
JavaSE_JavaSE学习资料_
10-02
这个编程资料包涵盖了JavaSE的学习资源，旨在帮助开发者掌握Java的基础知识、集合框架、IO流等关键概念。 首先，Java基础知识是学习JavaSE的起点。这包括了Java语法、数据类型、控制结构（如if语句、for循环、while...
javase-:javase基础代码仓库
03-15
Java SE（标准版）是...这个"javase--master"可能包含了以上这些知识点的实践代码，对于学习和巩固Java SE基础知识非常有帮助。通过阅读和运行这些代码，开发者可以更直观地理解Java编程的各个方面，并提升编程能力。
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 379
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 939
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
学习日志：JVM垃圾回收
weixin_46117680的博客
07-23 1026
当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在普通对象就不会被回收。
前端学习1——自学习梳理
qq_63125992的博客
07-24 398
【代码】前端学习1——自学习梳理。
虚拟机学习
weixin_63374588的博客
07-25 332
虚拟机的优点：虚拟机使用教程：
JavaSE学习：XML基础与规范解析
"JavaSE全套学习PPT14" 在JavaSE的学习过程中，XML技术是非常重要的一部分，它被广泛应用于数据交换、配置文件以及各种应用程序之间的通信。本资源提供了关于XML的详细讲解，包括其基本概念、规范以及解析方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值