首页 > 代码库 > Java泛型的定义以及对于<? extends T>和<? super T>

Java泛型的定义以及对于<? extends T>和<? super T>

2024-08-31 11:40:10   220人阅读

Java 中对于泛型方法的定义：

public <T> T getT(){

　　.....相关代码;

}

其中我对<T>的理解就是申明只是一个泛型方法的标记，T是返回的类型。

对于泛型类的定义：

public class Type<T>{

　　....相关代码

}

上面写的是关于泛型方法和泛型类的定义。这里写这篇博客的主要目的是为了记录<? extends T> 和 <? super T>的理解。

 

<? extends T>是上界通配符。逻辑上来说，一个可以往里面放动物的容器，也可以往里面放狗，因为狗是继承了动物的，所以从

逻辑上来说，一个可以放狗的容器也应该是继承一个可以放动物的容器的。但是Java中这是不对的。这时候就需要上界通配符来解决这个问题。

可以定义一个Content<? extends Animal> content，这个content容器里面可以放任何Animal包括其子类。这使得容器Content之间也有

了一定的联系。但是其中的也有一定的副作用。Content类里面有个getContent()方法，这个方法是不会影响使用的。因为对java编译器来说，

里面所有的东西都有一个相同的父亲，那就是Animal。但是如果你想要使用setContent()方法，这时就会出现一个问题，问题是什么呢？那就

是我只知道里面的类型是Animal以及Animal的派生类，但是无法确定具体的类型，是Dog或者Cat等。这里的类型没有具体给明，所以编译器

在这里只是给了一个占位符，所以到后面往t里面放Dog或者Apple的时候他都不知道是不是和Animal相匹配，所以这是不允许使用set的。下面

方法中的 public void setContent(List<T> content) 如果想可以set T包括T的子类的List的时候，可以这么定义：

public void setContent(List<？extends T> content)。

 

<? super T>是下界通配符。其作用这好和上面的<? extends T>相反。Content<? super Animal> content 表示的是Animal 以及Animal

基类的容器，但不是Dog基类的容器。里面的setContent()方法是可以正常使用的。因为它规定了最小粒度的下限，那就是Animal。但是它往外面

getContent()就比较费劲，因为他们公共的基类只有Object。所以取出来的内容只能用Object来装。

 

所以这里总结了一点就是如果一个内容他需要set的内容比较多，那就使用<? super T>。如若使用get的多一点，那就使用<? extends T>。

下面是自己定义的一个Content类：

 1 package test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.List;
 6 
 7 public class Content<T> {
 8     private String contentName;
 9     private List<T> content;
10     private T t;
11     private int size;
12     public Content(){
13         content = new ArrayList<T>();
14         size = 0;
15     }
16     public String getContentName() {
17         return contentName;
18     }
19     public void setContentName(String contentName) {
20         this.contentName = contentName;
21     }
22     public List<T> getContent() {
23         return content;
24     }
25     @SuppressWarnings("unchecked")
26     public void setContent(List<? extends T> content) {
27         this.content = (List<T>) content;
28     }
29     public void add(T content){
30         this.content.add(content);
31     }
32     public void getInfo(){
33         System.out.println(content.toString());
34     }
35     public int getSize(){
36         size = content.size();
37         return size;
38     }
39     public T getT() {
40         return t;
41     }
42     public void setT(T t) {
43         this.t = t;
44     }
45     public void remove(int pos){
46         this.content.remove(pos);
47     }
48     public T get(int i){
49         if(i>content.size())
50             return null;
51         return content.get(i);
52     }    
53 }

定义的Animal类：

 1 package test;
 2 
 3 public class Animal {
 4     private String type;
 5     private String describe;
 6     public Animal(){
 7         
 8     }
 9     public Animal(String type,String describe){
10         this.type = type;
11         this.describe = describe;
12     }
13     public String getType() {
14         return type;
15     }
16     public void setType(String type) {
17         this.type = type;
18     }
19     public String getDescribe() {
20         return describe;
21     }
22     public void setDescribe(String describe) {
23         this.describe = describe;
24     }
25     
26 }

继承Animal的Dog类

 1 package test;
 2 
 3 public class Dog extends Animal {
 4     private String name;
 5     private int age;
 6     public Dog(String type,String describe,String name,int age){
 7         super(type,describe);
 8         this.name = name;
 9         this.age = age;
10     }
11     public String getName() {
12         return name;
13     }
14     public void setName(String name) {
15         this.name = name;
16     }
17     public int getAge() {
18         return age;
19     }
20     public void setAge(int age) {
21         this.age = age;
22     }
23     
24 }

Java泛型的定义以及对于<? extends T>和<? super T>


联系
我们