泛型笔记

2021-03-15 22:01:31 阅读：132 来源： 互联网

标签：Type void 笔记 class 泛型 ParameterizedType type public

ParameterizedType

ParameterizedType represents a parameterized type such as Collection

源码：

public interface ParameterizedType extends Type {
    /**
     * Returns an array of {@code Type} objects representing the actual type
     * arguments to this type.
    Type[] getActualTypeArguments();
     /**
     * Returns the {@code Type} object representing the class or interface
     * that declared this type.
    /
    Type getRawType();
     /**
     * Returns a {@code Type} object representing the type that this type
     * is a member of.  For example, if this type is {@code O<T>.I<S>},
     * return a representation of {@code O<T>}.
    /
    Type getOwnerType();
}

要明白ParameterizedType 的含义，先看它的父类Type:

/**
 * Type is the common superinterface for all types in the Java
 * programming language. These include raw types, parameterized types,
 * array types, type variables and primitive types.
 *
 * @since 1.5
 */
public interface Type {
    /**
     * Returns a string describing this type, including information
     * about any type parameters.
     *
     * @implSpec The default implementation calls {@code toString}.
     *
     * @return a string describing this type
     * @since 1.8
     */
    default String getTypeName() {
        return toString();
    }
}

Type是一个表示Java语言中所有类型，包括原始类型, 参数化类型, 数组类型类型变量以及基本类型。

所以ParameterizedType表示参数化类型。
ParameterizedType有三个方法：
@getActualTypeArguments，@getRawType，@getOwnerType。多说无益处，直接看代码就明白了：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;

/**
 * @author longxingjian <longxingjian@kuaishou.com>
 * Created on 2021-03-15
 */
public class TestGenericInterface {
    private class Food {
        String foodName;
    }

    private interface Eat {
        void eat(String things);
    }

    private interface Eat2<T> {
        void eat(T things);
    }

    private interface Run {
        void run();
    }

    private class Dog implements Eat, Run {
        @Override
        public void run() {
        }

        @Override
        public void eat(String things) {
        }
    }

    private class Cat implements Eat2<Food>, Run {
        @Override
        public void run() {
        }

        @Override
        public void eat(Food things) {
        }
    }

    public static void main(String[] args) {
        Class<?> clazz = Dog.class;
        Type[] genericInterfacesDog = clazz.getGenericInterfaces();
        Class<?>[] interfacesDog = clazz.getInterfaces();

        Class<?> clazz2 = Cat.class;
        Type[] genericInterfacesCat = clazz2.getGenericInterfaces();
        ParameterizedType type = (ParameterizedType) genericInterfacesCat[0];
        Type[] actualTypeArguments = type.getActualTypeArguments();
        Type rawType = type.getRawType();
        String typeName = type.getTypeName();
        Type ownerType = type.getOwnerType();
        Class<?>[] interfacesCat = clazz.getInterfaces();

        System.out.println();
    }
}

标签：Type,void,笔记,class,泛型,ParameterizedType,type,public
来源： https://www.cnblogs.com/greatLong/p/14540251.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

泛型笔记

ParameterizedType