泛型 笔记

最新推荐文章于 2024-05-30 12:58:04 发布
最新推荐文章于 2024-05-30 12:58:04 发布
阅读量82 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48385654/article/details/120001207
版权

1. 泛型的理解和好处

泛型的英文是 generics，generic 的意思是通用,而翻译成中文，泛应该意为广泛，型是类型。所以泛型就是能广泛适用的类型。

看一个需求

在这里插入图片描述

  //使用传统的方法来解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));
        //假如不小心，添加了一只猫
        arrayList.add(new Cat("招财猫", 8));
        //遍历
        for (Object o : arrayList) {
            //向下转型Object ->Dog
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

使用传统方法的问题分析

泛型快速体验-用泛型来解决前面的问题

在这里插入图片描述

//使用传统的方法来解决===> 使用泛型
        //1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型 (细节后面说...)
        //2. 如果编译器发现添加的类型，不满足要求，就会报错
        //3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
        //4. public class ArrayList<E> {} E称为泛型,那么 Dog->E
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));
        //假如我们的程序员，不小心，添加了一只猫
        //arrayList.add(new Cat("招财猫", 8));//会报错
        System.out.println("===使用泛型====");
        for (Dog dog : arrayList) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

2. 泛型的理解和好处

泛型的好处

在这里插入图片描述

3. 泛型介绍

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

    public static void main(String[] args) {
        //注意，特别强调： E具体的数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
        Person<String> person = new Person<String>("韩顺平教育");
        person.show(); //String
        /*
            你可以这样理解，上面的Person类
            class Person {
                String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
                public Person(String s) {//E也可以是参数类型
                    this.s = s;
                }
                public String f() {//返回类型使用E
                    return s;
                }
            }
         */
        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer
        /*
            class Person {
                Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
                public Person(Integer s) {//E也可以是参数类型
                    this.s = s;
                }
                public Integer f() {//返回类型使用E
                    return s;
                }
            }
         */
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {
    E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }
    public E f() {//返回类型使用E
        return s;
    }
    public void show() {
        System.out.println(s.getClass());//显示s的运行类型
    }
}

4. 泛型的语法

泛型的声明

在这里插入图片描述

泛型的实例化

在这里插入图片描述

泛型使用举例

在这里插入图片描述

    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        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);
        }
/*Student{name='tom', age=28}
Student{name='jack', age=18}
Student{name='mary', age=19}
*/
        //使用泛型方式给HashMap 放入3个学生对象
        //K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("hsp", new Student("hsp", 28));
        //迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
         */
        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());     
        }
        /*
smith-Student{name='smith', age=48}
hsp-Student{name='hsp', age=28}
milan-Student{name='milan', age=38}
        */
}
/**
 * 创建  3个学生对象
 * 放入到HashSet中学生对象, 使用.
 * 放入到  HashMap中，要求 Key 是 String name, Value 就是 学生对象
 * 使用两种方式遍历
 */
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 +
                '}';
    }
}

泛型使用的注意事项和细节

在这里插入图片描述

    public static void main(String[] args) {
        //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List<int> list2 = new ArrayList<int>();//错误
        //2. 说明
        //因为 E 指定了 A 类型, 构造器传入了 new A()
        //在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();
        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断, 老师推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();
        //4. 如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
        /*
            public boolean add(Object e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        Tiger tiger = new Tiger();
        /*
            class Tiger {//类
                Object e;
                public Tiger() {}
                public Tiger(Object e) {
                    this.e = e;
                }
            }
         */
}
class Tiger<E> {//类
    E e;
    public Tiger() {}
    public Tiger(E e) {
        this.e = e;
    }
}
class A {}
class B extends A {}
class Pig<E> {//
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); //运行类型
    }
}

5. 泛型练习

在这里插入图片描述

    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 20000, new MyDate(1980, 12, 11)));
        employees.add(new Employee("jack", 12000, new MyDate(2001, 12, 12)));
        employees.add(new Employee("tom", 50000, new MyDate(1980, 12, 10)));
        System.out.println("employees=" + employees);
        /*
employees=[
Employee{name='tom', sal=20000.0, birthday=MyDate{year=1980, month=12, day=11}}, 
Employee{name='jack', sal=12000.0, birthday=MyDate{year=2001, month=12, day=12}}, 
Employee{name='tom', sal=50000.0, birthday=MyDate{year=1980, month=12, day=10}}]
         */
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                //先按照name排序，如果name相同，则按生日日期的先后排序。【即：定制排序】
                //先对传入的参数进行验证
                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;
                }
                //下面是对birthday的比较，因此，我们最好把这个比较，放在MyDate类完成
                //封装后，将来可维护性和复用性，就大大增强.
                return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });
        System.out.println("==对雇员进行排序==");
        System.out.println(employees);
        /*
[
Employee{name='jack', sal=12000.0, birthday=MyDate{year=2001, month=12, day=12}}, 
Employee{name='tom', sal=50000.0, birthday=MyDate{year=1980, month=12, day=10}}, 
Employee{name='tom', sal=20000.0, birthday=MyDate{year=1980, month=12, day=11}}]
         */
}
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比较放在这里
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        //如果year相同，就比较month
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0) {
            return monthMinus;
        }
        //如果year 和 month
        return day - o.getDay();
    }
}
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 +
                '}';
    }
}

6. 自定义泛型

自定义泛型类 (难度)

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

自定义泛型接口

在这里插入图片描述

自定义泛型方法

在这里插入图片描述

自定义泛型方法

在这里插入图片描述

   public static void main(String[] args) {
        //T->String, R->Integer, M->Double
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
        apple.fly(new Dog());//Dog
}
class Apple<T, R, M> {//自定义泛型类
    public <E> void fly(E e) {  //泛型方法
        System.out.println(e.getClass().getSimpleName());
    }
    //public void eat(U u) {}//错误，因为U没有声明
    public void run(M m) {
    } //ok
}
class Dog {}

7. 泛型的继承和通配符

泛型的继承和通配符说明

在这里插入图片描述

    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        //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<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√
        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×   
    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            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 {
}
江夬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA泛型笔记.pdf
12-01
JAVA泛型笔记.pdf
泛型笔记.pdf
08-21
一个泛型子类继承一个泛型父类时，子类泛型参数传值给父类泛型参数 Son--Father 4; 定义子类时子类泛型参数给定占位符，同时父类泛型参数可以赋值 public class Son,Y>:Father,string> 5:一个泛型子类继承一个...
泛型笔记
weixin_44801354的博客
10-09 859
泛型 泛型（C#2.0）： 泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。 优点： 1.使用泛型类、方法，我们可以极大提高代码的重用性，不需要对类型不同代码相同（仅类型参数不同）的代码写多次。 2.创建泛型类，可在编译时创建类型安全的集合 3.避免装箱和拆箱操
泛型的笔记
yanmo_01的博客
12-21 237
一、什么是泛型？ 泛型：类在定义时不为类中的属性，方法（返回值，参数）设置数据类型，在创建该类的对象时为其指定相应的数据类型。 二、为什么需要使用泛型？ 例子：定义个point类,属性：x坐标和y坐标 要求：x坐标和y坐标的值 （1）x坐标和y 坐标的值都是整形。 （2）x坐标和y 坐标的值都是小数。 （3）x坐标和y 坐标的值都是字符串。 思考：x和y属性的类型。Object，因为Object是所有类的父类，由于多态 public class Test01 { public st...
泛型笔记学习2009
05-01
此word学习文档适合泛型入门的人学习，对泛型的介绍内容详细，其中内容均为本人从网上搜集整理。
java基础学习笔记之泛型
09-02
所谓泛型，就是变量类型的参数化。泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的...
侯捷-STL和泛型编程笔记1-4讲
03-28
侯捷——STL和泛型编程笔记1-4讲
js bug日常
ailian_f的博客
09-22 162
项目场景：下拉框选项key是数字类型，绑定的值为字符串类型，这时当数据回显时，下拉框绑定失败 原因分析：类型不同意，无法绑定 解决方案：在获取到回显数据信息时，把字符串类型转成数字类型：使用Number(value)函数进行转换 项目场景：后端使用Date类型接收前台日期类型，在编辑回显时，包类型错误 原因分析：在回显时使用的类型是string类型，而在接受的时候使用的object类型 解决方案：前端自定义转换 convertDateFromString(dateString){ .
泛型学习笔记
jdk819的博客
08-09 102
1
Java泛型笔记
ilovestudy_的博客
02-10 192
Java泛型笔记 1.1 泛型概述和好处 假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？ 答案是可以使用 Java 泛型。 使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。 泛型（generics）是JDK5中引入的特性，它提供了编译时类...
Java之泛型学习笔记
TingtingYang
07-31 204
Java之泛型学习笔记1. 泛型技术的产生背景1.1 泛型的引出1.2 泛型操作的实现2. 通配符的使用2.1 背景 1. 泛型技术的产生背景 1.1 泛型的引出 保存多种数据类型的一堆数据时，我们会考虑Object类型： int自动装箱为Interger,Interger向上转型为Object double自动装箱为Double,Double向上转型为Object String向上转型为Obj...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
最新发布
优树搭的博客
05-30 1166
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
typescript笔记pdf
08-02
TypeScript笔记PDF还可以帮助开发者了解TypeScript的一些高级功能和概念，例如泛型、元组、枚举、接口等。这些功能可以帮助开发者编写更灵活和可扩展的代码，并提高应用程序的性能和可读性。 此外，TypeScript笔记...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值