《一步到位》——完全理解Java泛型

其他 2020-03-02 10:43:54 阅读次数: 0

一、什么是泛型？

泛型，即“参数化类型”，意思为将参数类型由原来的具体的类型，也设置成参数，即参数化（通常设置为T）。

把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

注意：
  1. 参数化类型：把类型当作是参数一样传递，<数据类型> 只能是引用类型
  2. 泛型只在编译阶段有效，编译之后程序会采取去泛型化的措施，即在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。泛型信息不会进入到运行时阶段。
  • ArrayList< E>中的E称为类型参数变量
  • ArrayList< Integer>中的Integer称为实际类型参数
  • 整个称为ArrayList< E>泛型类型
  • 整个ArrayList< Integer>称为参数化的类型ParameterizedType

二、为什么需要泛型

  1. 早期Java是使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全。
  2. 假如没有泛型，Collection、Map集合对元素的类型是没有任何限制的。本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，是没有任何语法错误的。
  3. 把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。外边获取该对象，还需要强制转换。
  • 向下转型需要考虑安全性，如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误，即子类不能直接指向父类对象
  • Java为了解决不安全的向下转型问题，引入泛型的概念。
  • 它可以使用instanceof来避免出错此类错误即能否向下转型，只有先经过向上转型的对象才能继续向下转型。

使用增强for遍历集合：

	 //创建集合对象
        ArrayList<String> list = new ArrayList<>();

        list.add("hello");
        list.add("world");
        list.add("java");

        //遍历,由于明确了类型.我们可以增强for
        for (String s : list) {
            System.out.println(s);
        }

三、泛型基础（泛型类、泛型接口、泛型方法）

1、泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。因此，用户明确了什么类型，该类就代表着什么类型，用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

在类上定义的泛型，在类的方法中也可以使用。

此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
在实例化泛型类时，必须指定T的具体类型

public class ObjectTool<T> {
	// obj这个成员变量的类型为T,T的类型由外部指定  
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

	public static void main(String[] args) {
        //创建对象并指定元素类型，泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
        ObjectTool<String> strTool = new ObjectTool<>();
        strTool.setObject("testString");
        String s = strTool.getObject();
        System.out.println(s);

        // 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
        ObjectTool<Integer> objectTool = new ObjectTool<>();
        objectTool.setObject(10);
        int i = objectTool.getObject();
        System.out.println(i);
    }
注意：定义的泛型类，就一定要传入泛型类型实参么？
  1. 在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。
  2. 如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
  3. 泛型的类型参数只能是类类型，不能是简单类型。

2、泛型接口

泛型接口与泛型类的定义及使用基本相同。

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当实现泛型接口的类，未传入泛型实参时：

未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"

class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

当实现泛型接口的类，传入泛型实参时：

虽然我们只创建了一个泛型接口Generator<T>，但是我们可以为T传入实参，从而形成某种类型的Generator接口。
在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都会替换成传入的实参类型

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3、泛型方法

仅仅在某一个方法上需要使用泛型，外界仅仅是关心该方法，不关心类其他的属性。泛型是先定义后使用的.
泛型方法，是在调用方法的时候指明泛型的具体类型 。

	 // 定义泛型方法
    public <Y> void show(Y y){
        System.out.println(y.getClass().getName()+"："+y);
    }

说明：

  1. public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
  2. 只有声明了<T>的方法才是泛型方法，泛型类中的使用带有泛型的成员方法并不是泛型方法。
  3. <T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
  4. 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

用户传递进来的是什么类型，返回值就是什么类型了：

		// 测试泛型方法
        ObjectTool tool = new ObjectTool();
        tool.show("hello");
        tool.show(12);

举例子：

（1）基本用法
public class GenericTest {

    //这个类是个泛型类，在上面已经介绍过
    public class Generic<T>{
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        /**
         * 虽然在方法中使用了泛型，但是这并不是一个泛型方法
         * 这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
         * 所以在这个方法中才可以继续使用 T 这个泛型。
         */
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
         */
//        public E setKey(E key){
//            return key;
//        }
    }

    /**
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个
     *      例如：public <T,K> K showKeyName(Generic<T> container){...}
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    // 这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        System.err.println("key value is " + obj.getKey());
    }

    /**
     * 这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
     * 同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
     */
    public void showKeyValue2(Generic<?> obj){
        System.err.println("key value is " + obj.getKey());
    }

    /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
     */
//    public <T> T showKeyName(Generic<E> container){
//        return null;
//    }

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
     */
//    public void showkey(T genericObj){
//
//    }

    public static void main(String[] args) {
        GenericTest test = new GenericTest();

        Generic<String> generic = test.new Generic<>("**generic**");
        test.showKeyName(generic);

        Generic<Number> inte = test.new Generic<>(10);
        test.showKeyValue1(inte);

        Generic<?> sss = test.new Generic<>("++++++++");
        test.showKeyValue2(sss);
    }
}

结果：
在这里插入图片描述

（2）类中的泛型方法
public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        /**
         * 在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
         * 由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
         */
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        // 在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }

        public <T> void printMsg(T... args){
            for(T t : args){
                System.err.println("t is : " + t);
            }
        }
    }

    public static void main(String[] args) {
        GenericFruit generic = new GenericFruit();

        Apple apple = generic.new Apple();
        Person person = generic.new Person();
        GenerateTest<Fruit> generateTest = generic.new GenerateTest<Fruit>();

        // apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        // 编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);

        generateTest.printMsg("123",222,"++++","aaaa",55.36);
    }
}

结果：
在这里插入图片描述

（3）静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {

    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}
（4）泛型方法总结
  1. 如果能用泛型方法，那么就尽量用泛型方法。
  2. 如果static方法要使用泛型能力，就必须使其成为泛型方法。

4、泛型类派生出的子类

注意：泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承。
继承分两种情况：

  1. 子类明确泛型类的类型参数变量
  2. 子类不明确泛型类的类型参数变量
子类明确泛型类的类型参数变量
// 把泛型定义在接口上
public interface Inter<T> {

    public abstract void show(T t);
}

// 子类明确泛型类的类型参数变量
public class InterImpl implements Inter<String> {

    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

测试：

      Inter<String> i = new InterImpl();
      i.show("hello");
子类不明确泛型类的类型参数变量

当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量。

// 子类不明确泛型类的类型参数变量,实现类也要定义出<T>类型的
public class InterImpl<T> implements Inter<T> {

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

	Inter<String> ii = new InterImpl<>();
	ii.show("100");

注意：

  • 实现类的要是重写父类的方法，返回值的类型是要和父类一样的
  • 类上声明的泛形只对非静态成员有效

5、类型通配符

问题：方法接收一个集合参数，遍历集合并把集合元素打印出来，怎么办？

// 不用泛型，只不过在编译的时候会出现警告，说没有确定集合元素的类型
public void test(List list){
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }
}

// 该方法只能遍历装载着Object的集合
public void test(List<Object> list){
	for(int i=0;i<list.size();i++){        
        System.out.println(list.get(i));
    }
}

// 使用类型通配符
public void test(List<?> list){
	for(int i=0;i<list.size();i++){ 
        System.out.println(list.get(i));
    }
}

泛型中的<Object>并不是像以前那样有继承关系的，也就是说List<Object>和List<String>是毫无关系的

?号通配符：表示可以匹配任意类型，任意的Java类都可以匹配。

注意：

  1. 当我们使用?号通配符的时候：就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。因为直到外界使用才知道具体的类型是什么。即：List集合，是不能使用add()方法的。因为add()方法是把对象丢进集合中，而现在我是不知道对象的类型是什么。
  2. 类型通配符一般是使用'?'代替具体的类型实参，注意了，此处'?'是类型实参，而不是类型形参 。再直白点的意思就是，此处的'?'和Number、String、Integer一样都是一种实际的类型，可以把?看成所有类型的父类。是一种真实的类型。
  3. 可以解决当具体类型不确定的时候，这个通配符就是?；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用?通配符来表未知类型。

设定通配符上限

对通配符做边界限定，假如接收一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等】数字类型，怎么做？
这时候需要用到设定通配符上限，

List<? extends Number>

上述的含义是：List集合装载的元素只能是Number的子类或自身。
在这里插入图片描述

设定通配符下限

有通配符上限，那么也应该有通配符下限

 <? super Type>

含义：传递进来的只能是Type或Type的父类。
在这里涉及到泛型的上限和下限中有一个原则：PECS(Producer Extends Consumer Super)

  • 如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
  • 如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
  • 如果既要存又要取，那么就不要使用任何通配符。

参考：https://blog.csdn.net/xx326664162/article/details/52175283

6、通配符和泛型方法

大多时候，我们都可以使用泛型方法来代替通配符的。但是，我们使用通配符还是使用泛型方法呢？
使用通配符和泛型方法的原则：

  • 如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法
  • 如果没有依赖关系的，就使用通配符，通配符会灵活一些。

ObjectTool.java

public class ObjectTool<T> {

    private T object;

	public ObjectTool(T object){
        this.object = object;
    }

    public T getObject(){
        return object;
    }

    public void setObject(T object){
        this.object = object;
    }
}

测试类：

public class Main {

    public static void main(String[] args) {
        ObjectTool<String> generic1 = new ObjectTool<String>("11111");
        ObjectTool<Integer> generic2 = new ObjectTool<Integer>(2222);
        ObjectTool<Float> generic3 = new ObjectTool<Float>(2.4f);
        ObjectTool<Double> generic4 = new ObjectTool<Double>(2.56);

        //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
        //showKeyValue1(generic1);

        showKeyValue1(generic2);
        showKeyValue1(generic3);
        showKeyValue1(generic4);
    }

    public static void showKeyValue1(ObjectTool<? extends Number> obj){
        System.err.println("key value is " + obj.getObject());
    }
}

再来一个泛型方法的例子：

	/**
     * 在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
     * public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
     */
    public <T extends Number> T showKeyName(ObjectTool<T> container){
        System.out.println("container key :" + container.getObject());
        T test = container.getObject();
        return test;
    }

总结：泛型的上下边界添加，必须与泛型的声明在一起。

7、泛型擦除

JDK5提出了泛型这个概念，但是JDK5以前是没有泛型的。也就是泛型是需要兼容JDK5以下的集合的。因此，当把带有泛型特性的集合赋值给老版本的集合时候，会把泛型给擦除了。

注意：它保留的就类型参数的上限。

	List<String> list = new ArrayList<>();

    //类型被擦除了，保留的是类型的上限，String的上限就是Object
    List list1 = list;

如果我把没有类型参数的集合赋值给带有类型参数的集合赋值，它也不会报错，仅仅是提示未经检查的转换

	List list = new ArrayList();
    List<String> list2 = list;
JSai
发布了75 篇原创文章 · 获赞 39 · 访问量 2万+
私信 关注

猜你喜欢

转载自blog.csdn.net/s2152637/article/details/103648052
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022