说说Java中的泛型

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

一、泛型的引入

直接举例：

package generic;


import java.util.ArrayList;

public class Generic_01 {
    public static void main(String[] args) {
        //使用传统的方式解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new People("sxp",20));
        arrayList.add(new People("wy",18));
        arrayList.add(new People("scy",21));

        //如果不小心添加一个Dog类在ArrayList中就会出现问题
        // arrayList.add(new Dog("小黄",2));

        for (Object obj:arrayList){
            People O=(People) obj;
            System.out.println(O.getName()+" - "+O.getAge());
        }
    }
}
class People{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

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

输出结果：

sxp - 20
wy - 18
scy - 21

注意
上面方法中存在2个问题：
1、不能对加入到集合ArrayList中的数据类型进行约束（不安全）
2、遍历的时候，需要进行类型的转换，如果集合中的数据量较大，对效率有影响
例如：

package generic;

import java.util.ArrayList;

public class generic_02 {
    public static void main(String[] args) {
        //使用泛型
        ArrayList<People1> arrayList = new ArrayList<People1>();
        arrayList.add(new People1("sxp",20));
        arrayList.add(new People1("wy",18));
        arrayList.add(new People1("scy",21));
        //1、当我们ArrayList<People1>表示存放到ArrayList集合中的元素是People1类型
        //2、如果编译器发现添加的类型，不满足要求就会报错
        //3、在遍历的时候可以直接取出People1类型而不是Object
        for (People1 p:arrayList){
            System.out.println(p.getName()+" - "+p.getAge());
        }
    }
}

class People1{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class Dog1{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

输出结果：

sxp - 20
wy - 18
scy - 21

总结
1、不使用泛型：某类型数据直接添加入集合中，取得时候先要转换成Object，再向下转型成该类型类型
2、使用泛型：放入时和取出不需要进行类型转换，提高了效率

二、泛型介绍

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

例如：

package generic;

public class Generic_03 {
    public static void main(String[] args) {
        Cat<String> stringCat = new Cat<String>("小黄");
        stringCat.f1();
        Cat<Integer> stringCat1 = new Cat<Integer>(5);
        stringCat1.f1();
    }
}

//E表示s的数据类型，该数据类型在定义Cat对象的时候指定
//即在编译期间，就确定E的类型
class Cat<E>{
    E s;

    public Cat(E s) {
        this.s = s;
    }
    public E f(){
        return s;
    }
    public void f1(){
        System.out.println(s.getClass());
    }
}

输出结果：

class java.lang.String
class java.lang.Integer

三、泛型的语法

1、泛型的声明
interface 接口< T >{}和class类< K,V >{}

  • 其中，T、K、V不代表值，而是表示类型
  • 意字母都可以，常用T表示，是Type的缩写

2、泛型的实例化
要在类名后面指定类型参数的值（类型）如：

  • ArrayList< String >str=new ArrayList< String >();
  • Iterator< man > iterator=man.iterator();

例如：

package generic;

import java.util.*;

public class Generic_04 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("sls",10));
        students.add(new Student("scy",17));
        students.add(new Student("wy",19));
        for ( Student stu:students){
            System.out.print(stu.getName()+" _ "+stu.getAge()+" ");
        }
        System.out.println();
        //迭代器
        HashMap<String,Student> student1 = new HashMap<String,Student>();
        student1.put("no1",new Student("sls",10));
        student1.put("no2",new Student("scy",17));
        student1.put("no3",new Student("wy",19));

        Set<Map.Entry<String, Student>> entries = student1.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.print(next.getKey()+" : "+next.getValue().getName()+" _ "+next.getValue().getAge()+"     ");

        }
        System.out.println();




    }
}

class Student{
    private String name;
    private int age;

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

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

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

输出结果：

scy _ 17 sls _ 10 wy _ 19 
no2 : scy _ 17     no1 : sls _ 10     no3 : wy _ 19

注意
1、interface List < T >{} , public class HashSet< E >{}等等中T，E只能是引用类型

List<integer> list1 = new ArrayList<Integer>();  // 正确
List<int> list2=new ArrayList< int >(); //不正确

2、在指定泛型具体类型后，可以传入该类型或者其子类型
3、泛型的使用：

List<integer> list1 = new ArrayList<Integer>();  
List<Integer> list2=new ArrayList< >();  //编译器会进行类型推断

4、如果写成List list = new ArrayList(); 就是默认泛型其中< E > E为object类型

例如：

package generic;

public class Generic_05 {
    public static void main(String[] args) {
        Bee<Animal> animalBee = new Bee<Animal>(new Animal());
        animalBee.func();
        Bee<Animal> animalBee1 = new Bee<Animal>(new Pig());
        animalBee1.func();
    }
}

class Animal{}

class Pig extends Animal{}

class Bee<E>{
    E e;

    public Bee(E e) {
        this.e = e;
    }
    public void func(){
        System.out.println(e.getClass());
    }
}

输出结果：

class generic.Animal
class generic.Pig

四、自定义泛型

1、自定义泛型类

基本语法

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

注意
1、普通成员可以使用泛型（属性、方法）
2、使用泛型的数组，不能初始化
3、静态方法中不能使用类的泛型（因为静态是和类相关的，在类加载时，对象还没有创建。如果静态方法和属性使用了泛型，JVM就无法完成初始化）
4、泛型类的类型，是在创建对象时确定的（因为创建对象时，需要制定确定类型）
5、如果在创建对象时，没有指定类型，默认为Object
例如：

package generic;

public class Generic_06 {
    public static void main(String[] args) {
        Monkey<Double,String,Integer> monkey = new Monkey<>("Tom");
        monkey.setAge(17.2);
        monkey.setHigh("110");
        monkey.setWeight(122);

        System.out.println(monkey.name);
        System.out.println(monkey);

        Monkey monkey1 = new Monkey("Jion");
        monkey1.setWeight("12122");
        System.out.println(monkey1);
    }
}
// 自定义泛型
// T,R,M  ： 泛型的标识符 一般时单个大写字母，可以有多个泛型标识符
class Monkey<T,R,M> {
    String name;
    T age;
    R high;
    M weight;

    public Monkey(String name) {
        this.name = name;
    }

    public Monkey(String name, T age, R high, M weight) {
        this.name = name;
        this.age = age;
        this.high = high;
        this.weight = weight;
    }

    public void setAge(T age) {
        this.age = age;
    }

    public void setHigh(R high) {
        this.high = high;
    }

    public void setWeight(M weight) {
        this.weight = weight;
    }

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

    public String getName() {
        return name;
    }

    public T getAge() {
        return age;
    }

    public R getHigh() {
        return high;
    }

    public M getWeight() {
        return weight;
    }

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

输出结果：

Tom
Monkey{name='Tom', age=17.2, high=110, weight=122}
Monkey{name='Jion', age=null, high=null, weight=12122}

2、自定义泛型接口

基本语法

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

}

注意
1、接口中静态成员也不能使用泛型（这个和泛型类规定一样）
2、泛型接口的类型，在继承接口或者实现接口时确定
3、没有指定类型，默认Object

例如

package generic;

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

    }
}

interface inter<U,R> {
    int n=10;
    // U name;不能这样使用
    R get(U u);
    void func1(R r);
    void func2(R r1,R r2 ,U u1);

    default R method(U u){
        return null;
    }
}

interface outer extends inter<String,Double>{

}

//当实现outer接口时，因为outer在继承inter接口时，指定<U,R>为<String,Double>
// 在实现inter接口的方法时，使用<String,Double>替换为<U,R>
class ter implements outer{

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

    @Override
    public void func1(Double aDouble) {

    }

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

    }
}

class AA implements inter<Integer,Float>{

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

    @Override
    public void func1(Float aFloat) {

    }

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

    }

}
//不推荐
//默认为<Object,Object>
class BB implements inter{

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

    @Override
    public void func1(Object o) {

    }

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

    }
}

自定义泛型方法

基本语法

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

}

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

例如：

package generic;

public class Generic_08 {
    public static void main(String[] args) {
        Car car = new Car();
        car.func1("nihao",788);

        Fish<String, Integer> objectObjectFish = new Fish<>();
        objectObjectFish.func4("niahb",123.98);

    }
}

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

    }
    //<T,R>就是泛型标识符，是提供给fly使用的
    public <T,R> void func1(T t,R r){
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

class Fish<T,R>{
    public void func(){

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

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

    }
    public<K,k> void func4(T t,K k){
        System.out.println(t.getClass());
        System.out.println(k.getClass());

    }
}

输出结果：

class java.lang.String
class java.lang.Integer
class java.lang.String
class java.lang.Double

泛型的继承和通配符

1、泛型不具备继承性
2、<?> :支持任意泛型类型
3、<? extends A >:支持A类以及A类的子类，规定了泛型的上限
4、<? super A>:支持A类以及A类的父亲，不限于直接父类，规定了泛型的下限

例如：

package generic;

import java.util.ArrayList;
import java.util.List;

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

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<FF1> list3 = new ArrayList<>();
        List<FF2> list4 = new ArrayList<>();
        List<FF3> list5 = new ArrayList<>();

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

        // printCollection1(list1); 报错
        // printCollection1(list2); 报错
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        printCollection2(list1);
        // printCollection2(list2); 报错
        printCollection2(list3);
        // printCollection2(list4); 报错
        // printCollection2(list5); 报错


    }
    public static void printCollection(List<?> c){
        for (Object object:c){
            System.out.println(object);
        }
    }
    //？extends FF1 ：表示上限，可以接受FF1或者FF1子类
    public static void printCollection1(List<? extends FF1> c){
        for (Object object:c){
            System.out.println(object);
        }
    }
    //? super FF1 子类类名FF1: 支持FF1类以及FF1类的父类，不限于直接父类
    public static void printCollection2(List<? super FF1> c){
        for (Object object:c){
            System.out.println(object);
        }
    }
}

class FF1{

}

class FF2 extends FF1{

}

class FF3 extends  FF1{

}
森小胖
关注
  • 32
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java泛型_Java中的泛型结构_
10-01
Java中的泛型结构请大家指教并指导有不足的地方给予赐教。
【java】Java 中泛型的实现原理
DreamSun的博客
03-11 1152
对比编辑的源代码 User.java 和反编译出来的代码 User.jad，容易发现：类型参数没有了，多了一个无参构造方法，多了一个 compareTo(Object obj) 方法，这个就是桥接方法，还可以发现参数 obj 被强转成 User 再传入 compareTo(User user) 方法。与泛型方法类似，泛型类也需要声明类型变量，只不过位置放在了类名后面，作用的范围包括了当前中的成员变量类型，方法参数类型，方法返回类型，以及方法内的代码中。而普通类中的泛型方法在进行类型擦除时不会产生桥接方法。
java int泛型_Java 泛型的使用详解
weixin_42603332的博客
02-24 657
原标题：Java 泛型的使用详解一、引入 1、泛型是什么首先告诉大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢？先看看下面这段代码：ArrayList strList = new ArrayList();ArrayList intList = new ArrayList();ArrayList doubleList = new ArrayList();大家对...
[java]泛型和通配符
qq_61925446的博客
04-20 267
但是我们得好好说说三号错误，三号错误在很多时候被认为是正确的代码，他创建了一个T类型的数组，我们可以往这个数组里面传入T类型的变量，也能正确的从这个数组中正确的拿到这个T类型变量,但是这个数组本质上是一个Object数组，他并没有被切换成T类型的数组，这样写也被java设计人员认为是不安全的，因为将一个Object类型数组强行转换成一个T[]类型是不安全的，除非这个T是Object，否则会报类型转换异常；首先，我们需要了解什么是泛型，泛型你可以理解为是一个容器，这个容器可以装入且只能装入你指定的类型变量。
java基础:说说，Java泛型
程序员ZZ的源码
08-31 145
特性 泛型只在编译阶段有效 public class GenericTest1 { public static void main(String[] args) { ArrayList&amp;lt;String&amp;gt; strings = new ArrayList&amp;lt;&amp;gt;(); ArrayList&amp;lt;Double&amp;gt; doubles ...
Java 泛型，你了解类型擦除吗？
热门推荐
frank 的专栏
08-05 10万+
泛型，一个孤独的守门者。 大家可能会有疑问，我为什么叫做泛型是一个守门者。这其实是我个人的看法而已，我的意思是说泛型没有其看起来那么深不可测，它并不神秘与神奇。泛型是 Java 中一个很小巧的概念，但同时也是一个很容易让人迷惑的知识点，它让人迷惑的地方在于它的许多表现有点违反直觉。文章开始的地方，先给大家奉上一道经典的测试题。List&lt;String&gt; l1 = new ArrayList&lt;Stri
Java集合-泛型
Philanderers的博客
12-25 1137
1、Array(数组）、ArrayList和LinkedList的区别 Array(数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移)。缺点:数组初始化必须指定初始化的长度, 否则报错。 例如: int[] a = new int[4];//推荐使用int[] 这种方式初始化 ​ int
Java——泛型机制
Cherry的博客
01-08 209
package day04; public class TypeDemo&amp;amp;lt;T&amp;amp;gt; { private T x; public TypeDemo(T d) { this.x = d; } public T getX() { return x; } public void setX(T x) { this.x = x; } public String to...
java之泛型
qq_41898297的博客
01-27 340
概念 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参） 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接
java泛型 extends_Java 之泛型通配符 ? extends T 与 ? super T 解惑
weixin_34803977的博客
02-16 344
简述大家在平时的工作学习中, 肯定会见过不少如下的语句:List super T>List extends T>我们都知道, 上面的代码时关于 Java 泛型的, 那么这两个不同的写法都有什么区别呢?首先, 说到 Java 的泛型, 我们必须要提到的是Java 泛型的类型擦除机制: Java中的泛型基本上都是在编译器这个层次来实现的. 在生成的 Java 字节代码中是不包含泛型中的类型...
Java中泛型总结(推荐)
08-26
主要介绍了Java中泛型总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中泛型使用实例详解
08-30
主要介绍了Java中泛型使用实例详解的相关资料,需要的朋友可以参考下
基于java中泛型的总结分析
09-05
本篇文章介绍了，在java中泛型的总结分析。需要的朋友参考下
Java中泛型的用法总结
09-03
主要介绍了Java中泛型的用法,实例总结了java中泛型的常见使用技巧,需要的朋友可以参考下
jar包增量更新分析
junlaiyan的专栏
05-16 278
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 908
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 639
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 41
1，引入核心关键依赖。
和我说说java的泛型
06-09
Java 泛型是一种在编译时期进行类型检查和类型推断的机制，它可以让程序员在编写代码时...Java 泛型还支持多重边界（Multiple Bounds）、类型擦除（Type Erasure）等特性，它是 Java 语言中非常重要和常用的特性之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值