Java之泛型

已于 2023-11-06 17:40:52 修改
阅读量59 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java 开发语言
于 2023-11-06 17:39:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73709096/article/details/134251354
版权

泛型

理解和好处

使用传统方法的问题分析
1.不能对加入集合ArrayList中的数据类型进行约束(不安全)
2.遍历的时候，需要进行类型转换，如果集合的数据量过大，对效率有影响
泛型的好处
1.编译时，检查添加元素的类型，提高了安全性
2.减少了类型转换的次数，提供效率
不使用泛型
Dog -加入 -> Object -取出 ->Dog //放入到ArrayList会先转成Object，在取出时，还需要转成Dog
使用泛型
Dog->Dog->Dog //加入时和取出时，不需要类型转换，提高效率
3.不再提示编译警告

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("旺财",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());
        }
    }
}
//1.编写程序，在ArrayList中，添加3给Dog对象
//2.Dog对象含有name和age，并输出name和age(要求使用getXxx())
//3.使用泛型来完成代码
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{
    private String name;
    private  int age;

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

介绍

泛(广泛)型(类型) => Integer,String,Dog
1.泛型又称参数化类型，时jdk5.0出现的新特性，解决数据类型的安全性问题
2.在类声明或实例化时之钥指定好需要的具体的类型即可
3.java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
4.泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型

语法

泛型的声明
interface 接口{} 和 class 类 <K,V>{}
比如：List，ArrayList
说明：
1.其中，T，K，V不代表值，二十表示类型
2.任意字母都可以。常用T表示，是Type的缩写
泛型的实例化
要在类名后面指定类型参数的值(类型)。如：
1.List strList = new ArrayList();
2.Iterator iterator = customers.iterator();

练习
截屏2023-11-04 10.02.22.png


public class GenericExercise {
	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);
		}

		//使用泛型方式给HashMap 放入3给学生对象
		HashMap<String, Student> hm = new HashMap<>();
		hm.put("milan",new Student("milan",38));
		hm.put("smith",new Student("smith",48));
		hm.put("cgj",new Student("cgj",20));

		//迭代器
		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 +
		'}';
	}
}

注意事项和细节

1.List list = new ArrayList();//OK
List list = new ArrayList();//错误
2.在给泛型指定类型后，可以传入该类型或其子类型
3.泛型使用形式
List list1 = new ArrayList();
推荐：List list2 = new ArrayList<>();
3. 如果这样写：List list3 = new ArrayList(); 默认它的泛型是[ E就是Object]

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

        //给泛型指向数据类型，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>();//OK
        //List<int> list = 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();

        //2.泛型的使用形式
        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<>();

        Tiger tiger = new Tiger();//默认E为Object
    }
}
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());//运行类型
    }
}

自定义泛型类

基本语法

class 类名<T,R...>{
    成员
}

注意细节

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

//1.Tiger后面泛型，所以我们把Tiger就称完自定义泛型类
//2.T，R，M泛型的标识符，一般是单个大写字母
//3.泛型的标识符可以有多个
//4.普通成员可以使用泛型(属性、方法)
//5.使用泛型的数组，不能初始化
class Tiger<T,R,M>{
    String name;
    R r;
    M m;
    T t;
    //因为数组在new的时候不能确定T的类型，就无法在内存开空间
    //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;
    }

    public void m1(M m){

    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用类泛型，JVM就无法完成初始化
    //static R r2;
//    public  static  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;
    }
}

自定义泛型接口

基本语法

interface 接口名<T,R...>{
}

注意细节

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) {

	}
}

//实现接口时，直接指定泛型接口的类型
//给U指定Integer,给R指定类Float
//所以，当我们实现IUsb方法时，会使用Integer替换U，使用Float替换R
class BB 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) {

	}
}

//没有指定类型，默认为Object
//建议直接写成<Object, Object>
class CC implements IUsb{//等价 class CC 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) {

	}
}
interface  IUsb<U, R>{

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

自定义泛型方法

基本语法

修饰符 <T,R...>返回类型 方法名(参数列表){
}

注意细节

1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
2.当泛型方法被调用时，类型会确定
3.public void eat(E e){},修饰符后没有<T,R…>，eat方法不是泛型方法，而是使用了泛型

泛型的继承和通配符

(1)泛型不具备继承性 List list = new ArrayList();//不对
(2)<?>:支持任意泛型类型
(3)<? extends A>:支持A类以及A类的子类，规定了泛型的上限
(4)<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

public class GenericExtends {
	public static void main(String[] args) {
		Object o = new String("xx");

		//泛型没有继承性
		//List<object> list = new ArrayList<<String>();//错误

		//举例说明下面三种方法都使用
		ArrayList<Object> list1 = new ArrayList<>();
		ArrayList<String> list2 = new ArrayList<>();
		ArrayList<AAA> list3 = new ArrayList<>();
		ArrayList<BBB> list4 = new ArrayList<>();
		ArrayList<CCC> list5 = new ArrayList<>();

		//如果是List<?> c ,可以接受任意都泛型类型
		printCollection1(list1);
		printCollection1(list2);
		printCollection1(list3);
		printCollection1(list4);
		printCollection1(list5);

		//如果是List<? extends AAA> c ,可以接受任意都泛型类型
		//printCollection2(list1); //报错
		//printCollection2(list2); //报错
		printCollection2(list3);
		printCollection2(list4);
		printCollection2(list5);

		//如果是List<? super AAA> 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 子类类名AAA 表示上限，可以接受AAA或者AAA子类
	public static  void printCollection2(List<? extends AAA> c){
		for (Object object : c) { //通配符，取出时，据说Object
			System.out.println(object);
		}

	}

	//? super 子类类名AAA：支持AAA类以及AAA类都父类，不限于直接父类
	public static  void printCollection3(List<? super AAA> c){
		for (Object object : c) { //通配符，取出时，据说Object
			System.out.println(object);
		}

	}
}
class AAA{

}
class BBB extends AAA{

}
class CCC extends BBB{

}
孤舟一叶～
关注
专栏目录
java -数据结构，List相关基础知识，ArrayList的基本使用，泛型的简单、包装类介绍
ryy1999的博客
02-13 1013
泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。泛型是一种编译期间的机制，即 MyArrayList< Person > 和 MyArrayList< Book > 在运行期间是一个类型。泛型是 java 中的一种合法语法，标志就是尖括号 装箱，装包： 就是将基本数据类型的数据转换成包装类类型 的数据拆箱，拆包：就是将包装类类型的数据转换成基本数据类型的数据。
从ArrayList看Java泛型
DennisJu的专栏
06-12 3573
从ArrayList看Java泛型 一、知识点 1、Java 泛型 2、Java 多态 3、Java ArrayList源码 二、个人理解 1、泛型更形式面向对象思想多态的扩展，它的使用范围更多的针对于类类型的参数、方法参数、方法返回值等等，它可以让程序的代码更简洁、减少你程序里面因为类型不匹配，在进行显示转换的时候，导致的类型强制转换错误。说泛型是“通配”作用，我更喜欢用“限定范围”
Java之泛型边界
u012135697的博客
07-23 1816
如果在泛型中使用`extends`和`super`关键字，就可以对泛型的类型进行限制。即：规定泛型的上限和下限。
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java之泛型详解
qq_38571892的博客
02-11 790
泛型的定义 什么是泛型呢？从字面意思理解，泛型就是广泛的类型，不确定的类型。这种不确定的数据类型需要在使用这个类的时候才能够确定出来。 泛型程序设计意味着编写的代码可以对多种不同类型的对象重用。 泛型机制的作用 泛型的作用是一种安全机制，将运行时期会发生的某些异常提前到编译时期了。它是一种书写规范，和接口的作用有着一定的类似，都是在制定规则。同时也可以提高代码的复用性。 如何理解泛型是一种安全机制呢？举例来说： public static void main(String[] args) {
Java之泛型：解读类型安全的利器
喵手的博客
05-30 1126
在Java开发中，经常需要处理各种数据类型。但是，传统的Java使用Object类型作为通用数据类型会存在一些问题，如数据类型的转换等。Java泛型的出现就是为了解决这些问题。本文将介绍Java泛型的基本概念、语法和应用场景。通过对源代码的分析和案例的讲解，掌握泛型的使用方法和操作技巧，同时分析泛型的优缺点，并介绍相应的应用实例。最后，通过测试用例对泛型的使用进行验证，总结泛型的特点和使用场景。Java泛型是Java 5的新特性，是一种将数据类型参数化的机制。
Java之泛型接口
yuan_boss的博客
06-05 4433
泛型接口 泛型接口和普通接口类型，定义的抽象方法没有方法体，也通常会把public abstract省略，定义常量也通常会省略public final static 泛型接口 /** * 泛型接口 * 语法：接口名<T> * 注意：不能泛型静态常量 * @param <T> */ public interface MyIterface<T> { public final static String name = "yuan"; public ab
java 之泛型详解
用键盘与世界交流
12-05 1825
关于泛型的详细介绍
JAVA利用泛型返回类型不同的对象方法
08-31
在Java编程中，泛型是一种强大的工具，它允许我们在类、接口和方法中定义类型参数，从而实现对多种数据类型的通用处理。泛型的主要目的是提高代码的类型安全性和重用性，减少类型转换的需要，并在编译时捕获可能的...
Java让泛型实例化的方法
08-18
Java让泛型实例化的方法 Java是一种静态类型语言，它可以在编译时检查类型的正确性，以避免运行时的类型错误。然而，在 Java 中使用泛型时，会出现一个问题：如何实例化泛型对象？在 Java 中，泛型擦除机制使得...
Java之泛型集合
yuan_boss的博客
06-05 1154
泛型集合 概念：参数化类型，类型安全的集合，强制集合元素的类型必须一致 特点： ​ 编译时即可检查，而非运行时抛出异常 ​ 访问时，不必类型转换（拆箱） ​ 不同泛型之间引用不能相互赋值，泛型不存在多态 总结：如果未使用泛型，泛型类型将会默认为Object类型，如果添加元素的时候既有字符串类型，又有整数类型，这个时候编译的时候不会报错，后面对这个集合进行遍历的时候如果是将Object类型的元素强制转换为字符串类型，但是因为整数类型不能转换为String类型，就会报错，即运行时抛出异常 如以下代码未使用
JAVA之泛型
莫予笙的博客
04-18 205
泛型 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 泛型的分类： 泛型类 泛型方法 基本数据类型对应的包装类： int---->Integer char—>Character long—>Long byte—>Byte short—>Short float—>Float double—>Double boolean—>Bool...
java 异常包装
最新发布
fdvvg的博客
10-17 214
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 357
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 669
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 521
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值