Caractères génériques dans les fonctions Java : limites supérieure et inférieure

En Java, les caractères génériques permettent de représenter des types génériques sans spécifier de types spécifiques. Le caractère générique de limite supérieure (<? extends T>) représente un paramètre de type T ou n'importe quelle sous-classe de celui-ci, permettant aux données de sous-classe d'être acceptées dans une liste. Le caractère générique inférieur (<? super T>) représente T ou l'une de ses superclasses, permettant aux données de superclasse de la liste d'être acceptées. Les caractères génériques peuvent être utilisés pour implémenter des listes de tableaux redimensionnables avec des génériques, permettant la gestion de différents types et opérations d'ajout/suppression.

Caractères génériques dans les fonctions Java : limites supérieures et inférieures

En Java, nous pouvons utiliser des caractères génériques pour représenter des types génériques, nous permettant d'utiliser des génériques sans spécifier de type concret. Cet article explorera les caractères génériques supérieurs et inférieurs et démontrera leur utilisation à travers des exemples pratiques.

Caractère générique plafonné

Le caractère générique plafonné (<? extends T>) représente un paramètre de type T ou l'une de ses sous-classes. Par exemple : <? extends T>) 表示类型参数 T 或其任何子类。例如：

public static <T extends Number> double sum(List<T> numbers) {
  double total = 0;
  for (T num : numbers) {
    total += num.doubleValue();
  }
  return total;
}

此函数可以接受任何 Number (如 Integer、Double) 或其子类的列表。我们可以安全地将任何满足 Number 约束的列表传递给此函数，如下所示：

List<Integer> ints = List.of(1, 2, 3);
double sumIntegers = sum(ints); // 编译通过

下限通配符

下限通配符 (<? super T>) 表示类型参数 T 或其任何超类。例如：

public static <T super Number> void process(List<T> entities) {
  for (T entity : entities) {
    System.out.println(entity.getClass().getName());
  }
}

此函数可以接受任何 Number 的超类 (如 Object、Serializable) 的列表。我们可以安全地将任何满足 Number 超类约束的列表传递给此函数，如下所示：

List<Object> objects = List.of("Hello", 123);
process(objects); // 编译通过

实战案例

考虑一个可调整大小的数组列表，我们可以使用泛型通配符来实现它：

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

public class ResizableArrayList<E> {

  private List<E> list;

  public ResizableArrayList() {
    this(new ArrayList<>());
  }

  public ResizableArrayList(List<? super E> initialList) {
    list = new ArrayList<>(initialList);
  }

  public void addAll(List<? extends E> elements) {
    list.addAll(elements);
  }

  public void removeAll(List<? super E> elements) {
    list.removeAll(elements);
  }

  public List<E> getList() {
    return list;
  }

  public static void main(String[] args) {
    ResizableArrayList<Integer> numbers = new ResizableArrayList<>(
        Arrays.asList(1, 2, 3)
    );
    numbers.addAll(Arrays.asList(4, 5, 6));
    numbers.removeAll(Arrays.asList(2, 3));

    System.out.println(numbers.getList()); // [1, 4, 5, 6]
  }
}

这个可调整大小的数组列表可以处理任何类型 Errreee

Cette fonction peut accepter n'importe quel nombre (tel que Integer, Double) ou une liste de ses sous-classes. Nous pouvons transmettre en toute sécurité n'importe quelle liste qui satisfait la contrainte Number à cette fonction comme suit : 🎜rrreee🎜🎜Caractère générique inférieur🎜🎜🎜Le caractère générique inférieur (<? super T>) représente un paramètre de type T ou l'une de ses superclasses. Par exemple : 🎜rrreee🎜Cette fonction peut accepter une liste de n'importe quelle superclasse Number (telle que Object, Serialisable). Nous pouvons transmettre en toute sécurité n'importe quelle liste qui satisfait aux contraintes de la superclasse Number à cette fonction comme suit : 🎜rrreee🎜🎜 Exemple pratique 🎜🎜🎜 Considérons une liste de tableaux redimensionnable, nous pouvons utiliser des caractères génériques pour y parvenir : 🎜rrreee🎜Cette liste de tableaux redimensionnables peut gérer n'importe quel typeE, nous permettant d'ajouter ou de supprimer divers objets à la liste. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!