Java泛型详解-优快云博客

本文链接：https://blog.youkuaiyun.com/cincoutcin/article/details/104729970

简介：

简介：

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

实际业务开发中，泛型多被用来定义泛型函数，用于处理对不同类实例对象的相同操作以简化代码。

泛型接口：

package com.knowledge.system.java_system.generices_system.generices_instance;

public interface Generator<T> {
    public T testGenerices();
}

package com.knowledge.system.java_system.generices_system.generices_instance;

import java.util.Random;

public class GeneratorImpl implements Generator<Integer> {
    int num[]={1,2,3,4,5,6,7};
    @Override
    public Integer testGenerices() {
        Random random=new Random();
        return num[random.nextInt(7)];
    }
}

package com.knowledge.system.java_system.generices_system.generices_instance;

import lombok.Data;

@Data
public class Man {
    private String name;
    private Integer age;
    private Integer sex;
}

package com.knowledge.system.java_system.generices_system.generices_instance;

import java.util.Map;

public class GeneratorImpl2 implements Generator<Man> {
    @Override
    public Man testGenerices() {
        Man man=new Man();
        man.setAge(12);
        man.setName("tset");
        man.setSex(12);
        return man;
    }
}

package com.knowledge.system.java_system.generices_system.generices_instance;

import com.alibaba.fastjson.JSON;

public class Test {
    public static void main(String[] args) {
        GeneratorImpl im=new GeneratorImpl();
        GeneratorImpl2 im2=new GeneratorImpl2();
        System.out.println(im.testGenerices());
        System.out.println(JSON.toJSONString(im2.testGenerices()));
    }
}

泛型类：

package com.knowledge.system.java_system.generices_system.generice_class;

public class GenericeClass<T> {
    private T t;

    public T getT() {
        return t;
    }

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

package com.knowledge.system.java_system.generices_system.generice_class;

public class Test {
    public static void main(String[] args) {
        GenericeClass gc=new GenericeClass();
        gc.setT(12);
        System.out.println(gc.getT());
    }
}

泛型方法：

package com.knowledge.system.java_system.generices_system.generices_function;

import java.util.List;

/**
 * 1.类型参数声明部分（由尖括号分隔），该部分在方法返回类型之前.
 * 2.每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。
 * 3.类型参数能被用来声明返回值类型，并且能作为泛型方法的实际参数类型的占位符。
 * 4.泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。
 * 5.<T extends Number> 指定泛型参数的上界，及T为Number类型或其子类型
 */
public class GenericesFunction {
    public static void main(String[] args) {
        Number num=getNum(1,2,3);
        System.out.println(num);
    }

    private static <T extends Number,E extends Integer> Number getNum(T i, T i1, E i2) {
        return i1.intValue()+i2.intValue()+i.intValue();
    }


}

有界参数：

package com.knowledge.system.java_system.generices_system.generices_function;

import java.util.List;

/**
 * 1.类型参数声明部分（由尖括号分隔），该部分在方法返回类型之前.
 * 2.每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。
 * 3.类型参数能被用来声明返回值类型，并且能作为泛型方法的实际参数类型的占位符。
 * 4.泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。
 * 5.<T extends Number> 指定泛型参数的上界，及T为Number类型或其子类型
 */
public class GenericesFunction {
    public static void main(String[] args) {
        Number num=getNum(1,2,3);
        System.out.println(num);
    }

    private static <T extends Number,E extends Integer> Number getNum(T i, T i1, E i2) {
        return i1.intValue()+i2.intValue()+i.intValue();
    }


}

类型通配符：

<? extends T>表示该通配符所代表的类型是T类型的子类。
<? super T>表示该通配符所代表的类型是T类型的父类。
对于泛型，只是允许程序员在编译时检测到非法的类型而已。通过反射依旧可以添加想要的数据类型。

package com.knowledge.system.java_system.generices_system.generices_tongpeifu;

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

public class GenericeTongPeiFu {
    public static void main(String[] args) {
        try {
            List <Integer> integerList=new ArrayList<>();
            integerList.add(12);
            integerList.add(223);
            List<String>stringlist=new ArrayList <>();
            stringlist.add("123123");
            stringlist.add("ajkfhah");
            stringlist.add("afjasasghashddhs");
            printList(integerList);
            printListBYFX(integerList,Integer.class);
            printListBYFX(stringlist,String.class);
            printListByTPF(integerList);
            printListByTPF(stringlist);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

    //只能处理一种类型的参数
    private static  void printList(List <Integer> integerList) {
        for(Integer integer:integerList){
            System.out.println(integer);
        }
    }

    //泛型函数，能够处理多种类型的额参数，可动态添加参数，改变集合数据
    private static <T> void  printListBYFX(List<T> list,Class<T> clz) throws IllegalAccessException, InstantiationException {
        T t1= null;
        try {
            if(clz==Integer.class){
                t1 = (T)clz.getConstructor(int.class).newInstance(145);
            }
            if(clz==String.class){
                t1 = (T)clz.getConstructor(String.class).newInstance("ahgahg");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        list.add(t1);
        for(T t:list){
            System.out.println(t);
        }
    }

    //使用类型通配符，能够处理多种类型的额参数，可动态添加参数，改变集合数据
    private static void printListByTPF(List<?> list){
        //list 无法添加元素，这也是通配符和泛型参数的区别
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }

}