JAVA泛型通配符T,E,K,V区别,T以及Class T,Class ? 的区别

本文深入解析Java泛型的概念,包括通配符T、E、K、V的含义,以及List<T>、List<Object>、List<?>的区别。同时,探讨了Class<T>、Class<?>在反射中的应用,提供丰富的代码示例帮助理解。

JAVA泛型通配符TEKVT以及Class<T>Class<?>的区

1. 先解下泛型概念

泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,以提高代码的重用率。

以上内容摘自百度百科

举个栗子:
Box类定义为一个泛型类

public class Box<T> {

    private T object;

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

    public T get() { return object; }

}

 

创建一个Box对象,不带泛型参数,发现获取对象的时候需要强制转换

Box box2 = new Box();

box2.set(new Apple());

Apple apple = (Apple) box2.get();

创建一个Box对象,带泛型参数,获取对象的时候就不需要强制转换

Box<Apple> box = new Box<Apple>();

box.set(new Apple());

Apple apple = box.get();

总结下泛型的好处就是
省去了强制转换,可以在编译时候检查类型安全,可以用在类,方法,接口上

但是我们定义泛型类,泛型方法,泛型接口的时候经常会碰见很多不同的通配符T,E,K,V等等,这些通配符又都是什么意思呢?继续往下看

2. 下来说说泛型通配符TEKV

这些全都属于java泛型的通配符,刚开始我看到这么多通配符,一下晕了,这几个其实没什么区别,只不过是一个约定好的代码,也就是说

使用大写字母A,B,C,D......X,Y,Z定义的,就都是泛型,把T换成A也一样,这里T只是名字上的意义而已

  •  表示不确定的java类型
  • T (type) 表示具体的一个java类型
  • K V (key value) 分别代表java键值中的Key Value
  • E (element) 代表Element

举个栗子:

public class Test<T> {   

  public List<T> list = new ArrayList<T>();  

  public static void main(String[] args) {

        Test<String> test = new Test<String>();

        test.list.add("hello");

        System.out.println(test.list);

    }
}

public class Test<A> {   

  public List<A> list = new ArrayList<A>();  

  public static void main(String[] args) {

        Test<String> test = new Test<String>();

        test.list.add("hello");

        System.out.println(test.list);

    }
}

将T换成了A,在执行效果上是没有任何区别的,只不过我们约定好了T代表type,所以还是按照约定规范来比较好,增加了代码的可读性。

如果要定义多个泛型参数,比如说两个泛型参数
很典型的一个栗子是Map的key,value泛型,我们也可以定义一个这样的

public interface Mymap<K, V> {

    public K getKey();

    public V getValue();

}
public class MymapImpl<K, V> implements Mymap<K, V> {

    private K key;

    private V value;


    public MymapImpl(K key, V value) {

        this.key = key;

        this.value = value;

    }


    public K getKey()   { return key; }

    public V getValue() { return value; }

}

 

下来就可以传入任意类型,创建实例了,不用转化类型

Mymap<String, Integer> mp1= new MymapImpl<String, Integer>("Even", 8);

Mymap<String, String>  mp2= new MymapImpl<String, String>("hello", "world");

Mymap<Integer, Integer> mp3= new MymapImpl<Integer, Integer>(888, 888);

如果要定义超过两个,三个或三个以上的泛型参数可以使用T1, T2, ..., Tn,像这样子

public class Test<T1,T2,T3> {

   public void print(T1 t1,T2 t2,T3 t3){

        System.out.println(t1.getClass());

        System.out.println(t2.getClass());

        System.out.println(t3.getClass());

    }

}

3. 接下来说说List<T>List<Object>List<?>

ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型

ArrayList<?> al=new ArrayList<?>(); 集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法

 

ArrayList<? extends E> al=new ArrayList<? extends E>();
泛型的限定:
? extends E:接收E类型或者E的子类型。
? super E:接收E类型或者E的父类型

  • Object和T不同点在于,Object是一个实打实的类,并没有泛指谁,而T可以泛指Object,比方public void printList(List<T> list){}方法中可以传入List<Object> list类型参数,也可以传入List<String> list类型参数,但是public void printList(List<Object> list){}就只可以传入List<Object> list类型参数,因为Object类型并没有泛指谁,是一个确定的类型
  • ?和T区别是?是一个不确定类,?和T都表示不确定的类型 ,但如果是T的话,函数里面可以对T进行操作,比方 T car = getCar(),而不能用? car = getCar()。

下面举个栗子比较下这三种:

import java.util.Arrays;

import java.util.List;



/**

 * 测试泛型参数Object和T的区别

 * Created by yanglu on 2017/04/20.

 */

public class TestDifferenceBetweenObjectAndT {

    public static void printList1(List<Object> list) {

        for (Object elem : list)

            System.out.println(elem + " ");

        System.out.println();

    }



    public static <T> void printList2(List<T> list) {

        for (T elem : list)

            System.out.println(elem + " ");

        System.out.println();

    }



    public static  void printList3(List<?> list) {

        for (int i = 0;i<list.size();i++)

            System.out.println(list.get(i) + " ");

        System.out.println();

    }



    public static void main(String[] args) {

        List<Integer> test1 = Arrays.asList(1, 2, 3);

        List<String>  test2 = Arrays.asList("one", "two", "three");

        List<Object> test3 = Arrays.asList(1, "two", 1.23);

        List<Fruit> test4 = Arrays.asList(new Apple(), new Banana());

        /*

        * 下面这句会编译报错,因为参数不能转化成功

        * */

        printList1(test4);

        /**/

        printList1(test3);

        printList1(test3);

        printList2(test1);

        printList2(test2);

        printList2(test3);

        printList3(test1);

        printList3(test2);

        printList3(test3);

    }

}

 

4. 最后来说说TClass<T>Class<?>

T是一种具体的类,例如String,List,Map......等等,这些都是属于具体的类,这个比较好理解
** Class是什么呢,Class也是一个类,但Class是存放上面String,List,Map......类信息的一个类**,有点抽象,我们一步一步来看 。

如何获取到Class类呢,有三种方式:
1. 调用Object类的getClass()方法来得到Class对象,这也是最常见的产生Class对象的方法。
例如:

List list = null;

Class clazz = list.getClass();

 

**2. 使用Class类的中静态forName()方法获得与字符串对应的Class对象。
**
例如:

Class clazz = Class.forName("com.lyx.demo.People");

 

3.获取Class类型对象的第三个方法非常简单。如果T是一个Java类型,那么T.class就代表了匹配的类对象。

Class clazz = List.class;

 

** 那么问题来了?Class类是创建出来了,但是Class<T>Class<?>适用于什么候呢???**

使用Class<T>和Class<?>多发生在反射场景下,先看看如果我们不使用泛型,反射创建一个类是什么样的。

People people = (People) Class.forName("com.lyx.demo.People").newInstance();

 

看到了么,需要强转,如果反射的类型不是People类,就会报
java.lang.ClassCastException错误。

使用Class<T>泛型后,不用强转了

public class Test {

    public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance();
    }

    public static void main(String[] args)  throws IllegalAccessException, InstantiationException  {
            Fruit fruit= createInstance(Fruit .class);
            People people= createInstance(People.class);
    }

}

 

那Class<T>和Class<?>有什么区别呢?
Class<T>在实例化的时候,T要替换成具体类
Class<?>它是个通配泛型,?可以代表任何类型,主要用于声明时的限制情况
例如可以声明一个

public Class<?> clazz;

但是你不能声明一个

public Class<T> clazz;

因为T需要指定类型
所以当,不知道定声明什么类型的Class的时候可以定义一个Class<?>,Class<?>可以用于参数类型定义,方法返回值定义等。

 

<think>我们正在讨论Java中的类参数符号(K, T, V, E)以及它们与Object的区别。根据引用内容,我们可以总结如下: 1. **类参数符号的含义**(引用[1][2]): - `T` (Type):代表一个具体的Java,通常用于类和方法的定义。 - `E` (Element):通常用于集合框架中,表示集合中的元素类。 - `K` (Key):表示映射(如Map)中的键类。 - `V` (Value):表示映射中的值类,与K配对使用。 - `N` (Number):表示数值类。 这些字母本质上都是类参数的占位符,没有严格区别,可以互换使用,但按照约定俗成,我们使用上述字母来增加代码可读性。 2. **通配符`?`**(引用[3][4]): - `?`表示不确定的Java,通常用于方法的调用和形参,不能用于定义类或方法。 - 它和`T`的区别在于:`T`用于定义时确保类一致性,而`?`表示任意类,没有一致性约束。 3. **与`Object`的区别**(引用[3]): - `Object`是所有类的父类,使用`Object`作为参数或返回类时,需要进行强制类转换,且可能引发`ClassCastException`。 - 使用(如`T`)则可以在编译时确定类,避免强制转换,提高类安全性。 下面我们详细展开说明: ### 一、类参数符号(K, T, V, E)的含义 这些符号都是**类参数(Type Parameter)**,用于在定义类、接口或方法时声明一个占位符类。它们的具体含义如下: | 符号 | 常见含义 | 典应用场景 | |------|------------------|--------------------------| | `T` | Type(类) | 类/方法中的通用类 | | `E` | Element(元素) | 集合类(如`List<E>`) | | `K` | Key(键) | 映射的键(如`Map<K,V>`) | | `V` | Value(值) | 映射的值(如`Map<K,V>`) | | `N` | Number(数值) | 数值类(如`Integer`等) | **示例代码**: ```java // 使用T的类 public class Box<T> { private T content; public void set(T content) { this.content = content; } public T get() { return content; } } // 使用K,V的类 public class Pair<K, V> { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } // 省略getter/setter } // 使用E的集合 List<String> list = new ArrayList<>(); // 这里E被指定为String ``` ### 二、通配符`?`的作用 通配符`?`表示**未知类**,常用于以下场景: 1. **接收任意类对象**: ```java public void printList(List<?> list) { for (Object elem : list) { System.out.println(elem); } } ``` 此方法可以接受任何类的`List`,如`List<String>`、`List<Integer>`等。 2. **与上下界限定符结合使用**: - `<? extends T>`:表示类为`T`或其子类(上界通配符) - `<? super T>`:表示类为`T`或其父类(下界通配符) ```java // 上界示例:接受Number及其子类的List public void processNumbers(List<? extends Number> list) { ... } // 下界示例:接受Integer及其父类的List public void addInteger(List<? super Integer> list) { list.add(42); } ``` ### 三、参数与Object的区别 1. **类安全性**: - 使用`Object`需要手动强制转换,容易引发运行时错误: ```java List list = new ArrayList(); list.add("Hello"); String s = (String) list.get(0); // 需要转换,但可能出错 ``` - 在编译时检查类,避免转换: ```java List<String> list = new ArrayList<>(); list.add("Hello"); String s = list.get(0); // 无需转换 ``` 2. **代码表达性**: - 明确指定了容器中元素的类(如`List<String>`),而`Object`会丢失类信息。 3. **通用性**: - `Object`虽然能代表任意类,但无法表达类之间的约束关系(如`T extends Comparable`)。 ### 四、类参数符号的一致性约束(引用[4]) 参数`T`可以确保多个参数之间的类一致性,而通配符`?`则不能: ```java // 使用T:确保dest和src的元素类相同 public <T extends Number> void copy(List<T> dest, List<T> src); // 使用通配符:dest和src可以是不同的Number子类 public void copy(List<? extends Number> dest, List<? extends Number> src); ``` - 第一种方法要求`dest`和`src`的元素类必须完全相同(如都是`Integer`)。 - 第二种方法允许`dest`是`List<Double>`而`src`是`List<Integer>`。 ### 总结对比表 | 特性 | 类参数(T/K/V/E) | 通配符?) | Object | |--------------------|----------------------------------|-----------------------------|----------------| | 用途 | 定义类/方法 | 使用(参数/变量) | 通用超类 | | 类一致性 | 可确保多个参数类一致 | 无法确保类一致 | 不适用 | | 类边界控制 | 支持(如`T extends Comparable`) | 支持(如`? super Integer`) | 不支持 | | 强制类转换 | 不需要 | 可能需要 | 需要 | | 运行时类信息 | 被擦除(编译后为Object) | 被擦除 | 保留 | | 能否用于定义类 | 能 | 不能 | 能 | > 通过参数,我们能在编译期捕获类错误,提升代码安全性和可读性[^1][^2][^3][^4]。 §§相关问题§§ 1. 通配符`?`在哪些场景下必须使用?能否用`Object`替代? 2. 如何理解中的上界和下界(如`<? extends T>`和`<? super T>`)? 3. 类擦除对参数和通配符有什么影响?</think>### Java参数符号(K、T、V、E)与Object的区别详解 #### 一、类参数符号的含义 这些字母是**参数**的占位符,本质上是**编译时的类标记**(运行时会被擦除)。它们的主要作用是增强代码可读性: 1. **T (Type)** - 最通用的类占位符 - 表示任意Java类 - 示例: ```java public class Box<T> { private T content; } ``` 2. **E (Element)** - 专指集合中的元素类 - 示例: ```java public interface List<E> { boolean add(E e); } ``` 3. **K (Key) 和 V (Value)** - 成对使用表示键值对 - 主要用于Map类 - 示例: ```java public class HashMap<K,V> { V get(K key) { ... } } ``` 4. **N (Number)** - 限定为数值类(如Integer、Double) - 示例: ```java public <N extends Number> double sum(N a, N b) { return a.doubleValue() + b.doubleValue(); } ``` > 📌 **关键点**:这些符号本质可互换,但约定俗成的用法能显著提升代码可读性[^2]。 #### 二、通配符`?`的特殊性 1. **不确定类** - 表示"未知类",常用于方法参数 - 不能用于定义类/方法 - 示例: ```java void printList(List<?> list) { ... } // 可接受任何List ``` 2. **与T的关键区别** ```java // 使用T确保类一致性 public <T> void merge(List<T> dest, List<T> src) { ... } // 使用?则无法保证类一致 public void merge(List<?> dest, List<?> src) { ... } // 可能不同类 ``` #### 三、参数 vs Object | 特性 | 参数(T/E/K/V) | Object | |---------------------|--------------------------------|------------------------| | **类安全** | ✅ 编译时检查类一致性 | ❌ 需运行时强制转换 | | **强制转换** | 不需要 | 必须显式转换 | | **类约束** | 支持边界限定(如`T extends Number`) | 无约束 | | **代码表达性** | 明确指定具体类 | 丢失类信息 | | **集合元素访问** | 直接获取正确类 | 需向下转 | **典示例对比**: ```java // 使用(安全) List<String> names = new ArrayList<>(); names.add("Alice"); String first = names.get(0); // ✅ 无转换 // 使用Object(危险) List objects = new ArrayList(); objects.add("Bob"); String name = (String) objects.get(0); // ❌ 需强制转换,可能ClassCastException ``` #### 四、核心差异总结 1. **参数(T等)** - 编译时占位符,提供**类安全的抽象** - 使API能声明"此方法/类将使用某种具体类" - 如`Collections.sort(List<T> list)`要求列表元素可比较[^4] 2. **Object** - 运行时实际存在的超类 - 使用时需**显式向下转**,失去编译时类检查 - 如JDK1.5前的集合设计(`ArrayList`只存Object) > 💡 **设计原则**:能用时避免使用Object,以获取编译时类安全[^3]。 #### 五、使用场景建议 | 场景 | 推荐方式 | 示例 | |---------------------|----------------------------|--------------------------| | 定义类 | 使用T/K/V/E | `class Response<T>` | | 方法参数接收任意集合 | 使用通配符? | `void print(List<?> list)` | | 类无关的工具方法 | 使用Object+反射 | `Arrays.deepEquals()` | | 保证参数类一致 | 使用方法+T | `<T> void copy(List<T> src)` | > 通过参数,Java实现了在编译期捕获类错误的能力,这是使用Object无法达到的安全级别[^1][^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值