java_泛型

已于 2022-04-05 13:02:58 修改
阅读量692 收藏
点赞数
分类专栏： java笔记 文章标签： java
于 2022-04-04 23:20:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binnnnnnn_/article/details/123958830
版权

一、看一个需求

在这里插入图片描述
这里是引用
在这里插入图片描述

二、泛型介绍

在这里插入图片描述

三、泛型的语法

在这里插入图片描述
在这里插入图片描述

@SuppressWarnings({"all"})
public class Generic02 {
    public static void main(String[] args) {
        HashSet<Student> students = new HashSet<>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));
        //遍历
        for (Student student :students) {
            System.out.println(student);
        }
        //使用泛型方式给HashMap 放入3个学生对象
        HashMap<String, Student> hm = new HashMap<>();
        hm.put("milan", new Student("milan", 28));
        hm.put("smith", new Student("smith", 28));
        hm.put("hsp", new Student("hsp", 28));

        //迭代器 EntrySet
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("=========迭代器==============");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  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 +
                '}';
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
引用数据类型默认都继承Object类所以此处默认用Object类在这里插入图片描述

四、泛型课堂类型

在这里插入图片描述

public class Generic02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 20000, new MyDate(2000,11,11)));
        employees.add(new Employee("jack", 12000, new MyDate(2001,12,12)));
        employees.add(new Employee("hsp", 50000, new MyDate(1980,10,10)));

        System.out.println("employees=" + employees);
        System.out.println("===对雇员进行排序===");
        //先按name，如果name相同，按出生日期排序，
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                //先对传入参数进行验证
                if(!(emp1 instanceof Employee && emp2 instanceof Employee)) {
                    System.out.println("类型不正确");
                    return 0;
                }
                //比较name
                int i = emp1.getName().compareTo(emp2.getName());
                if(i != 0) {
                    return i;
                }
                emp1.getBirthday().compareTo(emp2.getBirthday());
                //对birthday的比较，放在Date类比较好
//                //如果name相同，比较birthday -year
//                int yearMinus = emp1.getBirthday().getYear() - emp2.getBirthday().getYear();
//                    if(yearMinus != 0) {
//                        return yearMinus;
//                    }
//                    //如果year相同，比较month
//                int monthMinus = emp1.getBirthday().getMonth() - emp2.getBirthday().getMonth();
//                    if(monthMinus != 0) {
//                        return monthMinus;
//                    }
//                    //如果year和month 相同，比较day
                return emp1.getBirthday().getDay() - emp2.getBirthday().getDay();


            }
        });
        System.out.println("===对雇员进行排序==");
        System.out.println(employees);
    }
}

public 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) {//把对year-month-day比较
        //如果name相同，比较birthday -year
        int yearMinus = year - o.getYear();
        if(yearMinus != 0) {
            return yearMinus;
        }
        //如果year相同，比较month
        int monthMinus = month - o.getMonth();
        if(monthMinus != 0) {
            return monthMinus;
        }
        //如果year和month 相同，比较day
        return day - o.getDay();

    }
}

public class Employee {
        private String name;
        private double sal;
        private MyDate birthday;

    public Employee(String name, double 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 double getSal() {
        return sal;
    }

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

    public MyDate getBirthday() {
        return birthday;
    }

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

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

employees=[
Employee{name='tom', sal=20000.0, birthday=MyDate{year=2000, month=11, day=11}}, 
Employee{name='jack', sal=12000.0, birthday=MyDate{year=2001, month=12, day=12}}, 
Employee{name='hsp', sal=50000.0, birthday=MyDate{year=1980, month=10, day=10}}]
===对雇员进行排序===
===对雇员进行排序==
[
Employee{name='hsp', sal=50000.0, birthday=MyDate{year=1980, month=10, day=10}}, 
Employee{name='jack', sal=12000.0, birthday=MyDate{year=2001, month=12, day=12}}, 
Employee{name='tom', sal=20000.0, birthday=MyDate{year=2000, month=11, day=11}}]

五、自定义泛型

在这里插入图片描述

class Tiger<T, R, M> {
    String name;
    R r; //r属性使用泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开辟空间
    T[] ts;
    //T[] ts = new T[8];//错

    public Tiger(String name, R r, M m, T t) {
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
    //因为静态是和类相关的，在类加载时，对象还没创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
    //static R r2;
    //public static void m1(M m) {}


    public String getName() {//方法使用泛型
        return name;
    }

在这里插入图片描述
这里是引用

interface IUsb<U, R> {
    //1.在接口中，静态成员也不能使用泛型
    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;
    }
}
//在继承接口 指定泛型接口的类型 U->String    R->Double
interface IA extends IUsb<String, Double> {

}
//当我们去实现IA接口时，因为IA在继承IUsb接口时，指定了U为String，R为Double
//在实现IUsb接口的方法时，使用String替换U,Double替换R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

在这里插入图片描述

public class CustomInterfaceGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马" ,100);//当调用方法时，传入参数，编译器，就会确定类型
        /*
        * class java.lang.String
            class java.lang.Integer*/
        System.out.println("----------");
        car.fly(100, 10.1);
        /*
        * class java.lang.Integer
        class java.lang.Double
        * */
    }
}

//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car {
    public void run() {//普通方法

    }
    //说明
    //1.<T, R> 就是泛型
    //2.是提供给fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}
class Fish<T, R> {//泛型类
    public void run() { //普通方法

    }
    public<U,M> void eat(U u, M m) {//泛型方法

    }
    //说明
    //1.下面是hi方法不是泛型方法
    //2.是hi方法使用了类声明的泛型
    public void hi(T t) {}
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public <K> void hello(R r, K k) {}//R r是泛型类，K k是泛型方法//可以这样
}

这里是引用

在这里插入图片描述
这里是引用

六、泛型的继承和通配符

在这里插入图片描述
在这里插入图片描述

public class CustomInterfaceGeneric {
    public static void main(String[] args) {
        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> c
        //printCollection2(list1);错
        //printCollection2(list2);错
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        //List<? super AA> c
        printCollection3(list1);
        //printCollection3(list2);错
        printCollection3(list3);
        //printCollection3(list4);错
        //printCollection3(list5);错
    }
    //List<?>表示任意泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for(Object object :c) {//通配符，取出时，就是Object
            System.out.println(object);
        }
    }
    // ?extends AA 表示 上限，可以接受AA或AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object :c) {
            System.out.println(object);
        }
    }
    //?super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object :c) {
            System.out.println(object);
        }

    }
}
class AA {

}
class BB extends AA {

}
class CC extends BB {

}

七、本章作业

在这里插入图片描述

public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
    @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);//list=[User{id=1, age=10, name='jack'}, User{id=2, age=18, name='king'}, User{id=3, age=38, name='smith'}]

        dao.update("003", new User(3, 58, "milan"));
        list = dao.list();
        System.out.println("list=" + list);//list=[User{id=1, age=10, name='jack'}, User{id=2, age=18, name='king'}, User{id=3, age=58, name='milan'}]
        dao.delete("001");//删除
        System.out.println("id=003" + dao.get("003"));//获取、、id=003User{id=3, age=58, name='milan'}

    }
}


public class DAO<T> {
    private Map<String,T> map = new HashMap<>();
    public T get(String id) {
        return map.get(id);
    }
    public void update(String id, T entity) {
        map.put(id, entity);
    }
    //返回 map 中存放的所有T对象
    //遍历map[k-v],将map中的所有value(T entity),封装到ArrayList返回即可
    public List<T> list() {
        //创建 ArrayList
        List<T> list = new ArrayList<>();
        //遍历map
        Set<String> keySet = map.keySet();
        for (String key :keySet) {
            list.add(map.get(key));
        }
        return list;
    }
    public void delete(String id) {
        map.remove(id);
    }
    public void save(String id, T entity) {//把entity保存到map
        map.put(id, entity);
    }
}

public 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 + '\'' +
                '}';
    }
}

public class JUnit_ {
    public static void main(String[] args) {
        //传统方法
        new JUnit_().m1();
        new JUnit_().m2();
    }
    @Test
    public void m1() {
        System.out.println("m1方法被调用~");
    }
    @Test
    public void m2() {
        System.out.println("m2方法被调用~");
    }
}

八、JUnit

在这里插入图片描述
在这里插入图片描述

    //传统方法
        new JUnit_().m1();
        new JUnit_().m2();
    }
    @Test
    public void m1() {
        System.out.println("m1方法被调用~");
    }
    @Test
    public void m2() {
        System.out.println("m2方法被调用~");
    }
binnnnnnn_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
本科课程【java程序设计】实验4 - 实用工具类编程练习
1+1=王的博客
05-04 3799
大家好，我是【1+1=王】， 热爱java的计算机（人工智能）渣硕研究生在读。 如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！ Good better best, never let it rest, until good is better, and better best. 近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。 博客更新至专栏【课程设计实验报告】：https://blog.csdn.net/weixin_43598687/ca.
java_泛型.docx
10-12
Java 泛型是Java语言中的一种强大的特性，它允许在定义类、接口和方法时使用类型参数，从而增强了代码的重用性和安全性。泛型的主要目标是在编译时期就检测出可能存在的类型错误，而不是等到运行时才抛出异常。这样...
经典泛型使用案例,创建员工类Employee 对象 放入ArrayList集合(使用泛型)中.
qq_45973176的博客
06-01 969
1.创建一个员工类Employee: private 成员变量 name,sal,birthday,其中birthday 为 MyDate类的对象;2.为每一个属性定义 getter,setter方法;3.重写toString(); 输出name,sal,birthday;4.MyDate类包含: private 成员变量 year,month,day; 并未每一个属性定义getter,setter方法;5.创建该类的3个对象,并把这些对象放入ArrayList集合中[ArrayList 需使用泛型],对集
泛型编程（六）
qq_37279464的博客
04-01 80
通配符类型 长期以来，强类型语言已知被诟病，Java设计者提出了通配符类型，比如 Pair<? extends Employee> 表示所有类型变量集成自Employee的Pair泛型类，比如Pair<Manager>，但不包含Pair<String>。 比如你想编写一个函数，输出员工对的信息。 public static void printBuddies(Pair<Employee> p) { Employee first = p.getFirst()
Java笔记之泛型（二十二）
weixin_44604159的博客
06-06 144
泛型的基本介绍和使用
设计一个雇员Employee类
Szero
03-26 8010
设计一个雇员Employee类
jdk5.zip_java 泛型_jdk5 泛型_泛型
09-23
Java泛型在运行时会被擦除，因此泛型不提供运行时的类型检查。所有的泛型类和方法都会有一个没有泛型的等价形式，这个过程称为类型擦除。 4. **通配符的使用**： - 无界通配符：`?`，表示类型参数可以是任何类型...
Java_5_Tiger.rar_Tiger_泛型
09-23
在这个名为"Java_5_Tiger.rar_Tiger_泛型"的压缩包中，重点讨论了泛型这一核心特性，同时涵盖其他重要的改进，如枚举类型、动态参数、注释、静态包含以及多线程等。下面将详细解释这些关键知识点。 1. **泛型**：...
java-generic.rar_泛型
09-24
Java泛型是Java编程语言中的一个关键特性，它在2004年随着Java SE 5.0的发布而引入。泛型的主要目的是提供类型安全，同时减少在编写和使用集合类时的冗余代码。它允许开发者在类、接口和方法中定义参数化的类型，...
JAVAfanxing.rar_泛型
09-20
Java 泛型是Java语言中的一...总的来说，Java泛型提供了一种强大的工具，使我们能够在编写代码时进行更严格的类型检查，减少运行时错误，提高代码的可读性和可维护性。理解和掌握泛型是成为专业Java开发者的必备技能。
Java的自学之旅09
weixin_40518706的博客
09-16 435
一.类的成员之四 ：初始化块（对java对象初始化） 1.类的属性的默认初始化和显示初始化 2.执行代码块的代码 3.执行构造器的代码 代码的具体体现： package hellojava.day9; public class Person { String name; public Person(){ this.name="长得三"; System.out.println("执行的是构造方法"); } // 非静态代码块
Java实验项目三——面向对象定义职工类和日期类
ageng2545的博客
10-13 455
Program：按照如下要求设计类： （1）设计一个日期类，用于记录年、月、日，并提供对日期处理的常用方法。 （2）设计一个职工类，该职工类至少具有下面的属性：职工号，姓名，性别，生日，工作部门，参加工作时间，设计相应的方法。 （3）设计一个测试类，采用对象数组模拟一个拥有10个职工的单位。 以下是日期类和员工类的实现 Program：按照如下要求设计类： ...
定义员工类employee ,员工有姓名,年龄,工号属性, 员工有工作的方法, 键盘录入三组数据, 数据格式(姓名,年龄,工号) 例如:张三,23,9527; 通过数据,创建员工对象, 然后通过对
流氓小猴子的博客
07-04 3万+
定义员工类employee ,员工有姓名,年龄,工号属性, 员工有工作的方法, 键盘录入三组数据, 数据格式(姓名,年龄,工号) 例如:张三,23,9527; 通过数据,创建员工对象, 然后通过对象流将三个对象储存到文本文件中; 最后读取文本文件中的对象,然后将对象的属性打印到控制台上; import java.io.BufferedReader; import java.io.EOF
创建一个员工类Employee,有属性:姓名name,性别sex,工龄workAge,薪水salary和奖金award
热门推荐
健健
06-19 5万+
创建一个员工类Employee,有属性:姓名name,性别sex,工龄workAge,薪水salary和奖金award，创建一个排序类SortUtil,有静态方法sort(Employee[] s);方法可以对员工按年薪排升序（必须用插入排序）创建一个Test类，生成5个员工的数组，排序后打印所有员工信息（包括年薪）。创建一个员工类Employee：public class Employee { ...
Java 多态
weixin_45603004的博客
05-16 83
多态是同一个行为具有多个不同表现形式或形态的能力。 多态的优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 多态存在的三个必要条件 继承 重写 父类引用指向子类对象 比如： Parent p = new Child(); 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。 多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。 以下是一个多态实例的演示，详细说明请看注释： Test.java 文件代码：
Java面向对象程序设计——创建Employee子类
weixin_58793217的博客
11-25 887
掌握类的继承的概念，能够使用继承定掌握关键字super的使用。 继(ineiace)是面向对象程序设计的又一重要特性，是面向对象编程技术的一块基石,因为它允许创建分等级层次的类。采用继承的机制可以有效地组织程序的结构，设计系统中的类，明确类间关系，充分利用已有的类来完成更复杂、深人的开发,大大提高程序开发的效率,降低维护的工作量。Java的继承具有单继承的特点，即每个子类只能有一个父类。(1)继承的概念 继承是一种由已有类创建新类的机制。在Java语言中，被继承的类称为...
java 程序填空题_JAVA 程序填空题
weixin_28997071的博客
02-20 271
//Employee.javapublicclassEmployee{privateStringname;privateintage;privatedoublesalary;publicEmployee(StringnewName,intnewAge,doublenewSalary){【代码1】//要求调用有两个参...//Employee.javapublic class Employee{ ...
java泛型 类型通配符_Java泛型--通配符类型
weixin_42299244的博客
02-19 301
java的通配符类型实在令人头疼。通配符的概念下面的讨论基于一下三个类的定义：public class Employee {private String name;private double salary;private LocalDate hireDay;}public class Manager extends Employee {public Manager(String name, do...
Java泛型（四）：类型变量的限定、通配符类型
Ju的博客
12-26 3956
Java的泛型除了可以直接使用类型变量（如T等），如果有需要的话，我们还可以对其进行一定的限制，如规定某类型变量必须是“扩展”了某个类或者方法的。借助类型绑定和通配符我们就可以对类型变量进行限定。
kotlin t class.java_Kotlin 泛型
最新发布
05-25
Kotlin 中的泛型是通过在类、函数或接口声明中使用尖括号语法来实现的。例如，一个简单的泛型类可以这样声明： ``` class Box<T>(t: T) { var value = t } ``` 这个类的类型参数是 `T`，可以在类的各种属性和方法中使用。在这个例子中，我们在 `Box` 类的构造函数中使用了类型参数 `T`，并将其保存在一个名为 `value` 的属性中。 创建一个 `Box` 对象时，需要指定类型参数： ``` val box: Box<Int> = Box(1) ``` 在这个例子中，我们创建了一个 `Box` 对象，类型参数是 `Int`，并将值 `1` 传递给构造函数。 Kotlin 中的泛型支持协变和逆变，这使得在使用泛型时更加灵活。例如，我们可以将一个类型参数为 `List<Int>` 的对象赋给一个类型参数为 `List<Number>` 的变量： ``` val ints: List<Int> = listOf(1, 2, 3) val nums: List<Number> = ints ``` 在这个例子中，`ints` 是一个类型为 `List<Int>` 的对象，我们将其赋给了一个类型为 `List<Number>` 的变量 `nums`，这是因为 `List` 支持协变。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值