java的泛型【详解】

这篇具有很好参考价值的文章主要介绍了java的泛型【详解】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

定义类、接口、方法时,同时声明了一个或者多个类型变量(如:<E>) ,称为泛型类、泛型接口,泛型方法、它们统称为泛型。

作用:泛型提供了在编译阶段约束所能操作的数据类型,并自动进行检查的能力!这样可以避免强制类型转换,及其可能出现的异常。

1.泛型类:

        定义类的同时定义了泛型的类就是泛型类

        泛型类的格式:java的泛型【详解】,java,开发语言

        作用: 在编译阶段可以指定能操作的数据的类型

        原理: 把出现泛型变量的地方全部替换成传输的真实数据类型。

代码演示1:

package com.itheima.day06.teacher.c_generics;

import java.util.ArrayList;
/**
          集合用泛型的意义
             集合是存储对象的容器。一般来说存储的同种类型的对象。

             泛型:
                未知的类型     定义的时候不知道具体的类型。

             定义集合的时候,是不知道具体的集合对象存储什么类型对象的。
             所以集合采用泛型 来表示 未知的类型。
              你可以将泛型理解成一个占位符。

            使用集合的时候就需要确定 集合存储什么具体的类型了。

            确定之后  所有用到泛型的位置都会变成 具体的类型

     泛型 在定义不确定,在使用的时候必须确定。
        */
public class GenericsDemo01 {

    public static void main(String[] args) {
    
        //这里是没用泛型一个类型定义一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
       // list.add(12); //泛型限定传输的类型

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(12);

        ArrayList list3 = new ArrayList();
        // Object
        list3.add("aaa");
        list3.add(123);
        list3.add("123");
        for (int i = 0; i < list3.size(); i++) {
            Object o = list3.get(i);
            String s = (String) o;
        }
    }
}



--------------
package com.itheima.day06.teacher.c_generics;

/**
    这里是用泛型之后
*/
public class NBA<MVP>{ //泛型定义在类上
    //作用  在类中 都可以去使用这个未知的类型
    private MVP mvp ;//MVP泛型类型 定义的时候不具体

    public MVP getMvp(){//可以当成返回值类
        return mvp;
    }

    public void setMvp(MVP mvp) {//可以作为参数类型
        this.mvp = mvp;
    }
}


------
package com.itheima.day06.teacher.c_generics;

/**
 * 测试类
 */
public class Demo01 {

    public static void main(String[] args) {
        //创建一个NBA对象
        NBA<String> nba = new NBA<>();
        nba.setMvp("恩比德");

        String mvp = nba.getMvp();
        System.out.println(mvp);

        NBA<Integer> nba2 = new NBA<>();
        nba2.setMvp(77);
        System.out.println(nba2.getMvp());
    }
}


-----------

代码演示2:

package com.itheima.day06.teacher.d_generics;

/*
  泛型只能是引用类型
 */

public class MyArrayList<E>{

    //定义底层数组变量
    private Object[] array = new Object[10];//定义初始容量

    //定义一个数组的初始索引
    private int index = 0;

    /*
       添加元素  add(E )
     */
    public void add(E e){
        array[index] = e;
        index++;
    }
    /*
        根据索引获取元素
     */
    public E get(int index){
        return (E)array[index];
    }
}


-------------
package com.itheima.day06.teacher.d_generics;

/**
 * 测试类
 */
public class Demo {

    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();

        list.add("霍霍霍");
        list.add("魁魁魁");

        String s = list.get(0);
        System.out.println(s);

    }
}

2.泛型接口

        使用了泛型定义的接口就是泛型接口

        格式:修饰符 interface 接口名称<泛型变量>{}

        作用:泛型接口可以让实现类选择当前功能需要操作的数据类型

        原理:实现类可以在实现接口的时候传入自己操作的数据类型,这样重写的方法都将是针对于该类型的操作。

代码演示:

package com.itheima.day06.teacher.e_generics;
/**
    泛型接口
*/
public interface MyHoliday<X>{
    //泛型定义在接口   规范方法的使用

    void eat(X x);
}

-------------
package com.itheima.day06.teacher.e_generics;

public class Student implements MyHoliday<String>{
    @Override
    public void eat(String s) {
        System.out.println("吃烧烤...吃棒棒糖  bulubiu");
    }
}


------------
package com.itheima.day06.teacher.e_generics;

import java.util.Comparator;
/**
    泛型类也可以实现泛型接口
*/
public class Teacher<X> implements MyHoliday<X>{

    @Override
    public void eat(X x) {
    }
}

3.泛型方法

定义方法时同时定义了泛型的方法就是泛型方法

格式:

java的泛型【详解】,java,开发语言

作用:方法中可以使用泛型接收一切实际类型的参数,方法更具备通用性。

代码演示:

package com.itheima.day06.teacher.f_generics;
/**
    泛型方法
*/
public class GenericsDemo {

    public static void main(String[] args) {
        String aaa = test("aaa");

        Integer test = test(12);

        Double test1 = test(1.23);
    }

    public static <T> T test(T t){

        return t;
    }
}


---------------
package com.itheima.day06.teacher.f_generics;
/**
    泛型类里定义泛型方法
*/
public class Sugar<E> {

    private E e;

    public E getE(){
        return e;
    }

    public <T> void show(T t){//泛型定义在方法上

    }

}


4.泛型通配符、上下限

        ? 可以在“使用泛型”的时候代表一切类型。

        E T K V 是在定义泛型的时候使用的。

泛型的上下限:

       1. ? extends Car: ?必须是Car或者其子类 泛型上限

       2. ? super Car : ?必须是Car或者其父类 泛型下限

 代码演示:

package com.itheima.day06.teacher.f_generics;

import java.util.ArrayList;

/*
 定义几个类
 */
class Car extends Object {
}

class BENZ extends Car {
}

class ThreeBengZi extends Car {
}


public class Test {

    public static void main(String[] args) {

        ArrayList<BENZ> list1 = new ArrayList<>();
        ArrayList<ThreeBengZi> list2 = new ArrayList<>();
        ArrayList<Car> list3 = new ArrayList<>();
        ArrayList<Object> list4 = new ArrayList<>();
        test1(list1);
        test1(list2);
        test1(list3);
        test1(list4);
        test2(list1);
        test2(list2);
        test2(list3);
        test2(list4);
        System.out.println("===================");
        System.out.println("=  只能车及其子类 可以接收========");
        test3(list1);//   ArrayList<BENZ> list1 = new ArrayList<>();
        test3(list2);//   ArrayList<ThreeBengZi> list2 = new ArrayList<>();
        test3(list3);//   ArrayList<Car> list3 = new ArrayList<>();
        //   ArrayList<Car> list3 =  new ArrayList<Car>();
        //  如果类型有泛型  类型<泛型>  整体是一个类型!!
        //  List<Car>  ArrayList<Car>
//        test3(list4);
        // <? extends Car> 泛型的类型是Car或及其子类!
        // <? super Car>   泛型的类型是Car或及其父类!
        System.out.println("=  只能车及其父类 可以接收========");
//        test4(list1);
//        test4(list2);
        test4(list3);
        test4(list4);

    }

    /*
      设计一个方法 可以接收 各种各样的集合
     */
    public static <T> void test1(ArrayList<T> list) {
        System.out.println("测试");
    }

    /*
      ? 通配符接收带有泛型集合
     */
    public static void test2(ArrayList<?> list) {
        System.out.println("测试");
    }

    public static void test3(ArrayList<? extends Car> list) {
        System.out.println("限制泛型的类型!!!!!");
    }

    public static void test4(ArrayList<? super Car> list) {
        System.out.println("限制泛型的类型!!!!!");
    }
}

最后注意事项:

泛型的注意事项:擦除问题、基本数据类型问题

        1.泛型是工作在编译阶段的,一旦程序编译成class文件,class文件中就不存在泛型了,这就是泛型擦除。(大白话就是执行后生成的class文件,不在是你定义的字母,而是你传入的实际类型)

        2.泛型不支持基本数据类型,只能支持对象类型(引用数据类型)。文章来源地址https://www.toymoban.com/news/detail-825646.html

到了这里,关于java的泛型【详解】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java的泛型

    泛型是我们需要的程序设计手段。使用泛型机制编写的程序代码要比那些杂乱地使用 Object 变量,然后再进行强制类型转换的代码具有更好的安全性和可读性。 至少在表面上看来,泛型很像 C++ 中的模板。与 Java —样,在 C++ 中,模板也是最先被添加到语言中支持强类型集合的

    2024年02月08日
    浏览(40)
  • Java 中的泛型是什么,它有什么作用?(十五)

    Java中的泛型是一种类型参数化机制,它使代码更具可读性、可重用性和稳健性。在Java中,通过使用泛型,可以将类型作为参数传递给类或方法,并在编译时执行类型检查,从而避免许多运行时错误。 泛型的基础 Java泛型的基础概念是类型变量、类型参数和类型边界。 类型变

    2024年02月03日
    浏览(38)
  • 第8章-第1节-Java中的泛型(参数化类型)

    1、泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型?为什么要使用泛型? 2、概念:在类声明体中用到了类型参数。 3、泛型类只支持类类型,不支持基本数据类型(如int),但可以用包装类(如Integer ) 泛型标识 含义 T Type 类

    2024年01月23日
    浏览(45)
  • TypeScript中的泛型(泛型函数、接口、类、泛型约束)

    一、泛型函数 TypeScript 泛型是一种可以使代码具有更高的可重用性和泛化能力的特性 。通过泛型,我们可以定义一种通用的类型或函数,使其能够应对多种类型的输入。泛型在类、函数、接口等多种场景下都可以使用。 具体来说,在定义泛型函数时,我们可以使用来表示一

    2024年02月11日
    浏览(45)
  • 【TypeScript】TypeScript中的泛型

    定义一个函数或类时,有些情况下无法确定其中要使用的具体类型(返回值、参数、属性的类型不能确定),此时泛型便能够发挥作用。 举个例子: 上例中,test函数有一个参数类型不确定,但是能确定的时其返回值的类型和参数的类型是相同的,由于类型不确定所以参数和

    2024年02月09日
    浏览(47)
  • C++中的泛型详细讲解

    它是一种泛化的编程方式,其实现原理为程序员编写一个函数/类的代码示例,让编译器去填补出不同的函数实现。允许您延迟编写类或方法中的编程元素的数据类型的规范,直到实际在程序中使用它的时候。换句话说,泛型允许您编写一个可以与任何数据类型一起工作的类或

    2024年02月12日
    浏览(52)
  • Kotlin中的泛型理解与应用

    泛型是一种在编程中用于增加代码的灵活性和重用性的概念。它允许我们编写可以在多种类型上工作的通用代码,而不需要为每种类型都编写不同的代码。 在Kotlin中,泛型可以应用于类、函数和接口等。下面是一些关于泛型在Kotlin中的理解和示例。 1、泛型类 泛型类是指可以

    2024年02月07日
    浏览(38)
  • python中的泛型使用TypeVar

    PEP484的作者希望借助typing模块引入类型提示,不改动语言的其它部分。通过精巧的元编程技术,让类支持[]运算不成问题。但是方括号内的T变量必须在某处定义,否则要大范围改动python解释器才能让泛型支持特殊的[]表示法。 鉴于此,我们增加了typing.TypeVar构造函数,把变量

    2024年02月04日
    浏览(50)
  • .NET Framework中自带的泛型委托Func

    Func是.NET Framework中自带的泛型委托,可以接收一个或多个输入参数,并且有返回值,和Action类似,.NET基类库也提供了多达16个输入参数的Func委托,输出参数只有1个。 .NET Framework为我们提供了多达16个参数的Func委托定义,对于常见的开发场景已经完全够用。 如下图, 注意:

    2024年02月05日
    浏览(46)
  • 【Rust 基础篇】Rust 中的泛型:结构体和方法

    在 Rust 中,泛型是一种强大的特性,可以在结构体和方法中使用通用的类型参数。通过泛型,我们可以编写更加灵活和可复用的代码。本篇博客将详细介绍如何在 Rust 的结构体和方法中使用泛型,包括泛型结构体的定义、泛型方法的实现以及对泛型参数的约束。 在 Rust 中,我

    2024年02月16日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包