【Java基础】泛型

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量270 收藏 1
点赞数 6
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55839915/article/details/136742192
版权

泛型

泛型的理解和好处

需求

1.请编写程序，在ArrayList中，添加3个Dog对象

2.Dog对象含有name和age，并输出name和age（使用getXxx()）

传统方法

Generic01：

@SuppressWarnings({"all"})
public class Generic01 {
    public static void main(String[] args) {

        // 用传统的方法
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("A",10));
        arrayList.add(new Dog("B",1));
        arrayList.add(new Dog("C",5));

        // 加入不小心添加了一只猫
        arrayList.add(new Cat("D",11)); // 会出现 ClassCastException

        for (Object o : arrayList) {
            // 向下转型 Object -> Dog
            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 int getAge() {
        return 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 int getAge() {
        return age;
    }
}

使用传统方法的问题分析

1.不能对加入到集合 ArrayList中的数据类型进行约束（不安全）

2.遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

使用泛型

Generic02:

@SuppressWarnings({"all"})
public class Generic02 {
    public static void main(String[] args) {

        // 用传统的方法 -> 使用泛型
        // 1. 当 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是 Dog类型
        // 2. 如果编译器发现添加的类型不满足要求，就会报错
        // 3. 在遍历的时候，可以直接取出 Dog 类型，而不是 Object
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("A",10));
        arrayList.add(new Dog("B",1));
        arrayList.add(new Dog("C",5));

        // 加入不小心添加了一只猫
//        arrayList.add(new Cat("D",11)); // 报错

        // 遍历
        System.out.println("=== 使用泛型 ===");
        for (Dog dog : arrayList) {
            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 int getAge() {
        return 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 int getAge() {
        return age;
    }
}

泛型的好处

1.编译时，检查添加元素的类型，提高了安全性

2.减少了类型转换的次数，提高效率

3.不再提示编译警告

泛型介绍

泛型(即广泛类型) -> Integer,String,Dog

1.泛型又称参数化类型，是Jdk5.0出现的新特性，可以解决数据类型的安全性问题

2.在类声明或实例化时，只要指定好需要的具体类型即可

3.Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会发生异常，代码更加简洁、健壮

4.泛型的作用:可以在类声明时通过一个标识表示类中某个属性的类型， 或者是某个方法的返回值类型，或者是参数类型

Generic03:

public class Generic03 {
    public static void main(String[] args) {
        // 注意：E 具体的数据类型在定义Person对象时指定，
        // 即在编译期间，就确定 E 是什么类型
        Person<String> stringPerson = new Person<String>("hsp");
        Person<Integer> integerPerson = new Person<>(100);

        stringPerson.show(); // class java.lang.String
        integerPerson.show(); // class java.lang.Integer
    }
}

// 泛型的作用:可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值类型，或者是参数类型`

class Person<E> {
    E s; // E 表示：s的数据类型，

    public Person(E s) { // E 也可以是参数类型
        this.s = s;
    }

    public E f() { // E 也可以是返回值类型
        return s;
    }

    public void show() {
        System.out.println(s.getClass()); // 显示s的运行类型
    }
}

泛型的语法

泛型的声明

interface 接口 {} 和 class 类<K,V> {}

1.其中，T,K,V不代表值，而是表示类型

2.任意字母都可以，常用T表示，是Type的缩写

泛型的实例化

GenericExercise:

@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        HashSet<Student> studentHashSet = new HashSet<Student>();
        studentHashSet.add(new Student("AA",18));
        studentHashSet.add(new Student("BB",19));
        studentHashSet.add(new Student("CC",20));

        System.out.println("=== HashSet ===");
        for (Student student : studentHashSet) {
            System.out.println(student.name + "-" + student.age);
        }

        HashMap<String, Student> stringIntegerHashMap = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>{}
        */
        stringIntegerHashMap.put("AAA",new Student("AAA",18));
        stringIntegerHashMap.put("BBB",new Student("BBB",19));
        stringIntegerHashMap.put("CCC",new Student("CCC",21));

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

class Student {
    public String name;
    public int age;

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

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

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

1.interface List{} , public class HashSet{}…等等

说明：T,E 只能是引用类型

2.在指定泛型具体类型后，可以传入该类型或者其子类类型

3.泛型使用形式

4.如果这样写 泛型默认是Object

ArrayList list = new ArrayList();
等价于 ArrayList<Object> list = new ArrayList<>();

GenericDetail01:

@SuppressWarnings({"all"})
public class GenericDetail01 {
    public static void main(String[] args) {
        // 1.给泛型指定数据类型，要求是引用类型，不能是基本数据类型
        ArrayList<Integer> list1 = new ArrayList<>(); // ok
        // ArrayList<int> list2 = new ArrayList<>(); // error

        // 2.在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig1 = new Pig<A>(new A());
        aPig1.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();

        // 3.泛型的使用形式
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();

        // 实际开发中，往往简写
        // 编译器会进行类型推断
        ArrayList<Integer> list5 = new ArrayList<>();
        List<Integer> list6 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        // 4.如果这样写 泛型默认是Object
        ArrayList list = new ArrayList();
        // 等价于 ArrayList<Object> list = new ArrayList<>();

//        list.add(); // list.add(Object e)
//        pigs.add(); // pigs.add(Pig e)

        Tiger tiger = new Tiger();
    }
}

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());
    }
}

自定义泛型

自定义泛型类

CustomerGeneric_:

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

    }
}

// 自定义泛型类：
// 1. Mouse<T,R,M> 称为自定义泛型
// 2. T,R,M 泛型的标识符，一般是单个大写字母
// 3. 泛型的标识符可以有多个
// 4. 普通成员可以使用泛型（属性、方法）
// 5. 使用泛型的数组，不能初始化
// 6. 静态方法中不能使用类的泛型

class Mouse<T,R,M> {
    String name;
    R r; // 属性使用泛型
    M m;
    T t;

    // 数组在 new 不能确定 T 的类型，无法在内存开辟空间
//    T[] ts = new T[8]; // error



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

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

    // 方法使用泛型
    public R getR() {
        return r; // 返回方法可以使用泛型
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

自定义泛型接口

CustomerInterfaceGeneric：

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

    }
}

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

// 继承接口，指定泛型接口的类型
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) {

    }
}

// 没有指定类型，默认为Object
class IC implements IUsb { // 等价于 class IC implements IUsb<Object,Object>

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

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

    }
}

// 实现接口时，直接指定泛型接口的类型
class IB implements IUsb<Integer,Float> {


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

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

interface IUsb<U,R> {

    // 接口中的属性，只能是 final 的，而且是 public static final 修饰符
    int n = 10;
    // U name; // error

    // 普通方法中，可以使用接口泛型
    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;
    }

}

自定义泛型方法

CustomerMethodGeneric：

public class CustomerMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        // 调用方法时，传入参数，编译器就会确定类型
        car.fly("宝马",100);
        car.fly(12.3,'1');

        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(),11.3f);
    }
}

// 自定义泛型方法：
//

class Car {
    public void run() {

    }

    // 泛型方法
    // 1. <T,R> 就是泛型
    // 2. 是提供给fly使用的
    public<T,R> void fly(T t, R r) {
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }

}

// 泛型类
class Fish<T,R> {
    public void run() {

    }

    public<U,M> void eat(U u, M m) {

    }

    // hi方法不是泛型方法，而是使用了类声明的泛型
    public void hi(T t) {

    }

    // 泛型方法可以使用：
    // 1. 类声明的泛型
    // 2. 自己声明的泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass()); // ArrayList
        System.out.println(k.getClass()); // Float
    }

}

泛型的继承和通配符

泛型的继承和通配符说明

GenericExtends:

public class GenericExtends {
    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<AAA> list3 = new ArrayList<>();
        List<BBB> list4 = new ArrayList<>();
        List<CCC> list5 = new ArrayList<>();

        // List<?> c 可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        // List<? extends AAA> c
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        // List<? super AAA> c
        printCollection3(list1);
        printCollection3(list3);
    }

    // List<?> 表示 任意的泛型类型都可以接收
    public static void printCollection1(List<?> c) {
        for (Object o : c) {
            System.out.println(o);
        }
    }

    // ? extends AAA 表示 上限，可以接收 AAA 或者 AAA 的子类
    public static void printCollection2(List<? extends AAA> c) {
        for (Object o : c) {
            System.out.println(o);
        }
    }

    // ? super 子类类名AAA 表示 下限，支持 AAA类以及 AAA类的父类，不限于直接父类
    public static void printCollection3(List<? super AAA> c) {
        for (Object o : c) {
            System.out.println(o);
        }
    }

}

class AAA {

}

class BBB extends AAA {

}

class CCC extends BBB {

}
Pioneer.93
关注
【无标题】
weixin_52433098的博客
04-29 1202
JAVA高级特性 第一章:集合框架 List、Map是否都继承自Collection接口 ？ List，set继承于Collection Map没有继承于Collection其相对是独立的，属于Collection类型的对象可以通过构造函数将一个集合构成另一个集合 和数组采用相同存储结构的集合类型是什么？ java.util.ArrayList和java.util.Vector.都是采用数组形式来实现的。 Iterator接口的作用是什么？ Iterator称之为迭代器，是去遍历Collection、Map
Java集合
Libra_Ng
11-01 302
Java集合框架 在Java集合框架中 程序员不需要关心数组到底应该申请多少个元素，框架会自动分配空间. 程序员可以通过一个键，快速得到这个键所对应的值，并且不需要顾虑插入和删除元素的问题. 程序员可以方便地对数据进行排序，遍历等. 程序员可以直接使用各种数据结构. Java集合框架：Java集合框架提供了一套性能优良，使用方便的接口和类，它们位于java.util包中. List类集合 ...
07java基础进阶之集合框架
Denial_learn的博客
07-26 304
Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中。 其中经常使用到的接口，如图所示：（就是用红框包起来的） 其中：Collections 提供了对集合进行排序、遍历等多种算法实现 Java集合框架包含的内容： Collection 接口存储一组不唯一，无序的对象 List 接口存储一组不唯一，有序（插入顺序）的对象 例如： Set 接口存储一...
面向对象编程JAVA——泛型
m0_55854679的博客
12-22 197
文章目录问题引入泛型入门泛型的好处泛型说明 问题引入 请编写程序，在ArrayList中添加3个dog对象，dog对象中含有name和age，并输出（要求使用getXxx()) import java.util.ArrayList; /* * 请编写程序，在ArrayList中添加3个dog对象，dog对象中含有name和age，并输出（要求使用getXxx()) */ public class Generic01 { public static void main(String[] args)
Java基础 泛型
fulinlin的博客
11-07 266
什么是泛型 那么什么是泛型呢？ 我们经常在java里见到泛型的地方，应该就是那些集合类了吧。 List<String> list = new ArrayList<String>(); 差不多是这样。在java7及其之后 由于编译器会做类型推荐那么也可以简写成这样 List<String> list = new ArrayList<>(); 大...
Java基础泛型
孤夜的博客
04-01 1547
目录:前言一.泛型的理解和好处1.泛型的理解(1) 使用传统方法的问题分析(2) 使用泛型方式2.泛型的好处二.泛型介绍1.什么是泛型2.泛型的语法3.泛型使用细节三.自定义泛型1.自定义泛型类2.自定义泛型接口3.自定义泛型方法四.通配符1.泛型继承性2.通配符 前言 最近在回顾JavaSE部分的知识,对一些薄弱的知识进行记录,学习方式,通过视频和图书的进行学习,视频看B站韩顺平老师的30天学会Java,图书看Java核心技术 卷I 基础知识（原书第10版）。 韩顺平30天学会地址:Javahttps
Java基础-泛型
ImmortalsK的博客
08-16 295
泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式<数据类型>注意：泛型只能支持引用数据类型Java中的泛型是伪泛型，java文件中有泛型但是转为class文件之后泛型会消失，记作泛型的擦除使用场景：当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成：T、E、K、V等，创建该类对象时，E就确定了类型。如下面代码创建对象的时候E确定为String类型。
Java 基础 泛型
Java攻城狮修炼中
03-20 576
泛型（参数化类型）是把确定类型的操作推迟到对象创建或者方法调用时，才能确定具体类型的一种类型。泛型在使用时，将对象类型作为参数，这种参数可以被使用在 类、接口、方法中，称为 泛型类、泛型接口、泛型方法。一般我们在创建对象时，会指定对应的类型，如果没有指定类型，并且也没有指定泛型的话，默认类型就是 Object 类型。
java基础 泛型
qq_43057601的博客
03-13 297
什么是泛型 Java泛型设计原则： 只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常. 泛型： 把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型 一些常用的泛型类型变量： E：元素（Element） K：关键字（Key） T：类型（Type） V：值（Value） 参数化类型： 在不创建新类型的情况下，通过泛型指定的不同类型（类型形参），...
java基础（八）泛型
m0_75209145的博客
08-27 408
本文主要介绍的java基础中的泛型的相关知识，包括泛型的介绍和用法
java基础泛型 学习全文件
01-23
Java基础泛型是Java编程语言中的一个重要特性，它允许在类、接口和方法中使用类型参数，从而增强了代码的类型安全性和重用性。在Java中，泛型的主要目标是提高效率，避免运行时的类型转换，并且在编译时期就能发现...
Java 基础泛型.pdf
07-26
Java泛型是Java编程语言中的一个关键特性，它允许开发者在编写代码时引入类型参数，以提高代码的灵活性、安全性和可复用性。泛型的主要目标是在编译时进行类型检查，确保代码在运行时不会出现类型转换异常。下面我们...
关于java基础的泛型的练习
04-24
Java泛型是Java SE 5.0引入的一个重要特性，它极大地增强了代码的类型安全...在进行"关于Java基础的泛型的练习"时，可以尝试编写不同的泛型类、泛型方法，体验泛型带来的便利，并理解其背后的类型系统和类型擦除机制。
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 535
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 408
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 699
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 839
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 918
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
spring task的使用场景
qq_40603125的博客
10-13 368
spring任务调度框架约定的时间。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值