Java Generics 简明教程

Java Generics - Guidelines for Wildcard Use

通配符可以用三种方式使用 −

  1. Upper bound Wildcard − ? extends Type。

  2. Lower bound Wildcard − ? super Type。

  3. Unbounded Wildcard − ?

为了确定哪种类型的通配符最适合该条件，首先让我们将传递给方法的类型参数分类为 in 和 out 参数。

  1. in variable − 一个 in 变量为代码提供数据。例如，copy(src, dest)。此处，src 充当 in 变量，是要复制的数据。

  2. out variable − 一个 out 变量保存由代码更新的数据。例如，copy(src, dest)。此处，dest 充当 in 变量，已复制数据。

Guidelines for Wildcards.

  1. Upper bound wildcard − 如果一个变量属于 in 范畴，请在通配符中使用 extends 关键词。

  2. Lower bound wildcard − 如果一个变量属于 out 范畴，请在通配符中使用 super 关键词。

  3. Unbounded wildcard − 如果可以使用 Object 类方法访问一个变量，请使用一个非限定通配符。

  4. No wildcard − 如果代码在 in 和 out 范畴中均访问变量，请不要使用通配符。

Example

以下示例阐明了上述概念。

package com.tutorialspoint;

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

public class GenericsTester {

   //Upper bound wildcard
   //in category
   public static void deleteCat(List<? extends Cat> catList, Cat cat) {
      catList.remove(cat);
      System.out.println("Cat Removed");
   }

   //Lower bound wildcard
   //out category
   public static void addCat(List<? super RedCat> catList) {
      catList.add(new RedCat("Red Cat"));
      System.out.println("Cat Added");
   }

   //Unbounded wildcard
   //Using Object method toString()
   public static void printAll(List<?> list) {
      for (Object item : list)
         System.out.println(item + " ");
   }

   public static void main(String[] args) {

      List<Animal> animalList= new ArrayList<Animal>();
      List<RedCat> redCatList= new ArrayList<RedCat>();

      //add list of super class Animal of Cat class
      addCat(animalList);
      //add list of Cat class
      addCat(redCatList);
      addCat(redCatList);

      //print all animals
      printAll(animalList);
      printAll(redCatList);

      Cat cat = redCatList.get(0);
      //delete cat
      deleteCat(redCatList, cat);
      printAll(redCatList);
   }
}

class Animal {
   String name;
   Animal(String name) {
      this.name = name;
   }
   public String toString() {
      return name;
   }
}

class Cat extends Animal {
   Cat(String name) {
      super(name);
   }
}

class RedCat extends Cat {
   RedCat(String name) {
      super(name);
   }
}

class Dog extends Animal {
   Dog(String name) {
      super(name);
   }
}

这会产生以下结果 −

Cat Added
Cat Added
Cat Added
Red Cat
Red Cat
Red Cat
Cat Removed
Red Cat