0065 泛型

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量229 收藏
点赞数 1
分类专栏： Java的学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72797089/article/details/127380006
版权

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

import org.junit.jupiter.api.Test;

/*
    JUnit (JUnit5)
    一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中
    如果有多个功能代码测试，就需要来回注销，切换很麻烦
    如果可以直接运行一个方法，就方便很多，并且可以给出相关信息--->JUnit

    JUnit是一个Java语言的单元测试框架，多数Java的开发环境都已经集成了JUnit作为单元测试的工具

 */
public class Junit_ {
    public static void main(String[] args) {
        //传统方式
        //new Junit_().m1();
        //new Junit_().m2();
    }
    //@Test加上Alt+Enter加入JUnit5.4
    @Test
    public void m1(){
        System.out.println("m1方法被调用");
    }
    @Test
    public void m2(){
        System.out.println("m2方法被调用");
    }
}

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

    泛型声明
    interface 接口<T>{}
    class 类<K,V>{}
    class 类<E>{}
            //其中T,K,V,E不代表值，而是表示类型
            //任意字母都可以，常用T表示，是Type的缩写
    泛型实例化：
    在类名后指定类型参数的值（类型）：
    List<String> strList = new ArrayList<String>();
    Iterator<Customer> iterator = customers.iterator();

    细节：
    1.T,K,V,E只能是引用类型
        List<Integer> list = new ArrayList<Integer>();//正确
        List<Integer> list2 = new ArrayList<int>();//错误，int为基本数据类型
    2.在指定泛型具体类型后，可以传入该类型或其子类型
        C<A> c1 = new C<A>(new A()) 若B为A的子类
        C<A> c1 = new C<A>(new B()) 也正确
    3.泛型使用形式
        1.List<Integer> list1 = new ArrayList<Integer>()
        2.List<Integer> list2 = new ArrayList<>()//在开发中，往往简写
    4.如果不写类型，默认Object
        ArrayList arrayList = new ArrayList();
        //等价于ArrayList<Object> arrayList = new ArrayList();
 */

import java.util.*;

//泛型使用举例
//创建3个学生对象，放入HashSet\HashMap中，要求Key是String name,Value为学生对象
public class Generic_ {
    public static void main(String[] args) {
        //使用泛型给HashSet放入三个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack",20));
        students.add(new Student("tom",18));
        students.add(new Student("jhon",26));

        //遍历(增强for)
        for (Student student :students) {
            System.out.println(student);
        }

        //使用泛型给HashMap放入三个学生对象
        HashMap<String, Student> hashMap = new HashMap<String, Student>();
        hashMap.put("smith",new Student("smith",26));
        hashMap.put("mary",new Student("mary",22));
        hashMap.put("jack",new Student("jack",20));

        //遍历（迭代器）
        Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = (Map.Entry<String, Student>) iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}

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 +
                '}';
    }
}
/*
    自定义泛型

    1.自定义泛型类
        基本语法
        class 类名<T,R...>{
            成员
        }

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

    2.自定义泛型接口
        基本语法
        interface 接口<T,R...>{}

        细节
        1.接口中，静态成员也不能使用泛型
        2.泛型接口的类型，在继承接口或实现接口时确定
        3.没有指定类型，默认为Object

    3.自定义泛型方法
        基本语法
        修饰符<T,R...>返回类型 方法名（参数列表）{}

        细节
        1.泛型方法可以定义在普通类中，或是泛型类中
        2.当泛型方法被调用时，类型就被确定
        3.public void method（E,e）{}
            修饰符后没有<T,R..>,该方法不是泛型方法，而是使用了泛型
 */
public class Generic03 {
    public static void main(String[] args) {
        Tiger g = new Tiger("jhon");//默认为Object T,R,M=Object

        Person person = new Person();
        person.run("jack",1000);//当泛型方法被调用时，类型就被确定，T=String,R=Integer
        person.run(100,100.00);//T=Integer,R=Double
    }
}
//  自定义泛型类
//Tiger后接泛型，就把Tiger称为自定义泛型类
//T,R,M就是泛型的标识符，一般是单个的大写字母，且可以有多个
class Tiger<T,R,M> {
    String name;
    T t;//普通成员可以使用泛型（属性）
    R r;
    M m;
    //T[] arr = new T[8];
    //使用泛型的数组，不能初始化,因为数组在new时不能确定T的类型，无法在内存开空间

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

    public Tiger(T t, R r, M m) {
        this.t = t;
        this.r = r;
        this.m = m;
    }

    public T getT() {//返回类型也可使用泛型
        return t;
    }

    public void setT(T t) {//普通成员可以使用泛型（方法）
        this.t = t;
    }
    //static R r2;
    //public static void m(M m){}
    //静态成员不能使用类的泛型,因为静态是和类相关的，在类加载时，对象还没创建
    //如果使用了泛型，JVM就无法完成初始化
}
//  自定义泛型接口
interface IUsb<U,R>{

    //方法可以使用泛型
    R get(U u);
    void hi(R r);
    default R m(U u){
        return null;
    }
    //U name
    //接口中默认属性public static final，所以不能使用泛型
}
//泛型接口的类型，在继承接口或实现接口时确定
interface IUsb2 extends IUsb<String,Double>{}//指定了U为String,R为Double
class Usb implements IUsb2{
    @Override
    public Double get(String s) {//实现方法时，替换U,R
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public Double m(String s) {
        return null;
    }
}
class Usb2 implements IUsb{//没有指定类型，默认为Object

    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public Object m(Object o) {
        return null;
    }
}
//  自定义泛型方法
//泛型方法可以定义在普通类中，或是泛型类中
class Person{//普通类
    public<T,R> void run(T t,R r){//泛型方法

    }
}
class Dog<T,R>{//泛型类
    public<U,M> void eat(U u,M m){

    }

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

/*
    泛型的继承和通配符
    1.泛型不具备继承性
    2.<?>:支持任意泛型类型
    3.<? extends A>:支持A类以及A类的子类，规定了泛型的上限
    4.<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

 */
public class Generic04 {
    public static void main(String[] args) {
        Object o = new String(" ");//OK
        //List<Object> list = new ArrayList<String>();泛型不具备继承性

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();
        //List<?>表示接收任意泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        //List<? extends AA>:支持AA类以及AA类的子类，规定了泛型的上限
        //printCollection2(list1);错误，Object
        //printCollection2(list2);错误，String
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);
        //List<? super AA> c:支持AA类以及AA类的父类，不限于直接父类，规定了泛型的下限
        printCollection3(list1);//正确，Object
        //printCollection3(list2);错误，String
        printCollection3(list3);
        //printCollection3(list4);错误，BB
        //printCollection3(list5);错误，CC
    }
    //List<?>表示接收任意泛型类型
    public static void printCollection1(List<?> c){
        for (Object o :c) {//取出时为Object
            System.out.println(o);
        }
    }
    //List<? extends AA>:支持AA类以及AA类的子类，规定了泛型的上限
    public static void printCollection2(List<? extends AA> c){
        for (Object o :c) {
            System.out.println(o);
        }
    }
    //List<? super AA> c:支持AA类以及AA类的父类，不限于直接父类，规定了泛型的下限
    public static void printCollection3(List<? super AA> c){
        for (Object o :c) {
            System.out.println(o);
        }
    }

}

class AA{}
class BB extends AA{}
class CC extends BB{}

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

/*
    练习
    1.定义Employee类，private成员变量name，salary，birthday，其中birthday为MyDate对象
    2.为每一个属性定义getter，setter方法
    3.重写toString方法，输出属性
    4.MyDate类包含：private成员变量month，day，year，并为每一个属性定义getter，setter方法
    5.创建该类的三个对象，并把这些对象放入ArrayList中（需要泛型来定义）
      对集合中的元素进行排序，并遍历输出
    排序方式：调用ArrayList的sort方法，传入Comparator对象（泛型）,按照name排序，如果name相同，按照生日先后排序
 */
public class Generic02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom",10000,new MyDate(2005,9,9)));
        employees.add(new Employee("jack",15000,new MyDate(2006,10,10)));
        employees.add(new Employee("tom",20000,new MyDate(2007,11,11)));
        System.out.println(employees);

        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;
                }
                //名字相同比较年、月、日(放到MyDate比较)
                return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        System.out.println("=================排序后==============");
        System.out.println(employees);
    }
}

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 String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
    @Override
    public int compareTo(MyDate o) {//把年月日的比较放入这里比较
        int years = year - o.getYear();
        if(years != 0){
            return years;
        }
        int months = month - o.getMonth();
        if (months != 0){
            return months;
        }
        return day - o.getDay();
    }
}
class Employee{
    private String name;
    private double salary;
    private MyDate birthday;

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

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public MyDate getBirthday() {
        return birthday;
    }

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

    @Override
    public String toString() {
        return "\nEmployee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                ", birthday=" + birthday +
                '}';
    }
}
import org.junit.jupiter.api.Test;
import java.util.*;
/*
    定义一个泛型类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类对象，分别调用以上五种方法来操作User对象，使用JUnit单元测试类进行测试
 */
public class Generic05 {
    public static void main(String[] args) {

    }
    @Test
    public void testList(){
        DAO<User> dao = new DAO<User>();
        //增
        dao.save("001",new User(01,20,"jack"));
        dao.save("002",new User(02,30,"mary"));
        dao.save("003",new User(03,40,"tom"));
        List<User> list = dao.list();
        System.out.println(list);
        //删、改
        dao.delete("001");
        dao.update("003",new User(03,50,"smith"));
        list = dao.list();
        System.out.println(list);
        //查
        System.out.println(dao.get("003"));
    }
}
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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
class DAO<T>{
    private Map<String,T> map = new HashMap<>();

    public void save(String id,T entity){//保存T类型的对象到Map成员变量中
        map.put(id,entity);
    }
    public T get(String id){//从map中获取id对应的对象
        return map.get(id);
    }
    public void update(String id,T entity){//替换map中key为id的内容，改为entity对象
        map.put(id,entity);
    }
    public List<T> list(){//返回map中存放的所以T对象
        //遍历map,将所以value封装到ArrayList返回
        ArrayList<T> list = new ArrayList<>();
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            list.add(map.get(key));
        }
        return list;
    }
    public void delete(String id){//删除指定id对象
        map.remove(id);
    }
}
nzmzmc
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java ast 解析_[Java教程]AST-web端javascript逆向杀器之认识AST
weixin_30249997的博客
02-28 575
[Java教程]AST-web端javascript逆向杀器之认识AST0 2020-12-29 16:01:21 什么是AST？ 答:在计算机科学中，抽象语法树(Abstract Syntax Tree，AST)，或简称语法树(Syntax tree)，是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。之所以说语...
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
对象、继承、封装、多态、抽象类的组合应用
weixin_34281477的博客
07-24 325
对象、继承、封装、多态、抽象类的组合应用 编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个Employee对象的生日，则将该员工的工资增加100元。 （1）定义一个Employee类，该类包含：　　private成员变量name,number,birthday，其中birthday 为MyDate类的对象；　　abstract方法earnings()；toString()...
Java泛型详解（史上最全泛型知识详解）
m0_70325779的博客
07-25 9067
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
在java中，使用数组将员工的信息和薪水打印出来
qq_65836429的博客
04-09 4368
/* 需求： 创建一个Employee数组，分别创建若干个不同的Employee对象，并打印某个月的工资；且每个类都完全封装，不允许有非私有化属性 1.Employee:父类 属性：员工姓名，员工的出生年月 方法：getSalary(int month）根据参数月份确定工资，如果该月员工过生日，则公司会额外发放100元 2.SalariedEmployee:Employee的子类，拿固定工资的员工 属性：月薪 .
Java面向对象程序设计——0428上机作业（多态实验）
程序员本员
04-28 685
定义Employee类： 属性salary（工资） 定义salary的getter和setter 定义print,返回salary的值； 定义Manager为Employee的子类: 定义属性allowance; 定义构造方法，用参数给salary和allowance赋值。 定义print方法，返回salary与allowance的和。 在Demo类中编写main方法 定义Employee类的对象...
深入理解C#的装箱和拆箱、使用非泛型集合时引发的装箱和拆箱操作
永无止境
03-16 2814
装箱和拆箱是值类型和引用类型之间相互转换是要执行的操作。  1. 装箱在值类型向引用类型转换时发生 2. 拆箱在引用类型向值类型转换时发生 光上述两句话不难理解，但是往深处了解，就需要一些篇幅来解释了。 我们先看装箱时都会发生什么事情，下面是一行最简单的装箱代码 object obj = 1; 这行语句将整型常量1赋给object类型的变量obj；
Swift 3.0开发者预览版（第一版）发布内容简介
王学森的专栏
06-21 585
导读：从去年年底至今，全球iOS开发者一直在期待以及展望Swift 3，在凌晨“开放”成重点的WWDC上，苹果实现了Siri、iMessage等软件在多平台的打通及开放，而对于开发者而言，最为关注的莫过于Xcode和Swift的更新。 北京时间6月14日，苹果开源语言的高级经理Ted Kremenek在Swift官方博客上发布了一篇题为“Swift 3.0 Preview 1 Relea
c#索引器
weixin_33756418的博客
11-27 61
1.索引器概述 c#中的索引器提供了语法的简洁方便的特性，它允许你访问对象元素如同访问数组那样，通常我们会在实现索引器的类的内部维护一个内部的集合或数组，通过索引器来实现对集合中的元素的存取操作。例如，我定义了一个row对象，内部维护了column数组，我们访问通过数组的方式访问row就相当于访问了对应的column元素，一目了然。代码如下： public class Row ...
Go 1.18 版本新特性详解！
QcloudCommunity的博客
09-01 2164
导语|本文推选自腾讯云开发者社区-【技思广益 · 腾讯技术人原创集】专栏。该专栏是腾讯云开发者社区为腾讯技术人与广泛开发者打造的分享交流窗口。栏目邀约腾讯技术人分享原创的技术积淀，与广泛开发者互启迪共成长。本文作者是腾讯后台开发工程师Johns。本文主要探析Go 1.18版本新特性，希望本文能对此方面感兴趣的开发者们提供一些经验和帮助。Go官方在今年315悄悄发布了Golang 1.18版本。...
Java泛型使用
12-22
Java泛型是Java编程语言中一个强大的特性，它允许开发者在编写代码时声明类型参数，从而增强了代码的灵活性和安全性。泛型的引入主要是为了解决代码复用和类型安全问题，避免在运行时出现类型转换异常...
24泛型
01-07
1.泛型 scala中的泛型可以作用在类,方法和函数上,泛型本身占位符没有任何意义。 只有当传入数据类型或参数时,当前的占位符才会有意义。 2.界定 在指定泛型时,可以对泛型进行范围界定,指定类型,而不是让其随意传入一...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 554
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 395
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 381
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 319
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 940
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

nzmzmc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值