Comment définir des paramètres de type restreint en Java

[Recommandations d'apprentissage associées : Tutoriel de base Java]

Parfois, vous souhaiterez peut-être limiter les types pouvant être utilisés comme paramètres de type dans un type paramétré. Par exemple, une méthode qui opère sur des nombres peut vouloir accepter uniquement des instances de Number ou l'une de ses sous-classes. C'est à cela que servent les paramètres de type limité.

Exemple de méthodes de types de paramètres bornés

Pour déclarer un paramètre de type borné, listez le nom du paramètre de type, suivi du mot clé extends, puis sa limite supérieure , Dans ce cas Number

Notez que dans ce cas, extends est généralement utilisé pour signifier « extension » (comme dans une classe) ou « implémentation » (comme dans une interface).

package generics;

/**
 * 定义受限制的方法
 * 
 * @author psdxdgK1DT
 *
 */
public class Box<T> {

	private T t;

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

	public T get() {
		return t;
	}
/**
	 * 通过修改我们的通用泛型方法以包含此有界类型参数，现在编译将失败，因为我们对inspect的调用仍包含String：
	 * By modifying our generic method to include this bounded type parameter
	 * compilation will now fail, since our invocation of inspect still includes a String:
	 * inspect:单词：检查
	 * @param <U>
	 * @param u
	 */
	public <U extends Number> void inspect(U u) {
		System.out.println("T:" + t.getClass().getName());
		System.out.println("U:" + u.getClass().getName());
	}

	public static void main(String[] args) {
		Box<Integer> integerBox = new Box<Integer>();
		integerBox.set(new Integer("some text"));
		integerBox.inspect("some test");这里会出现预编译错误

		integerBox.inspect(10);
	}
}

Une ligne ondulée rouge apparaîtra sur le moniteur pour indiquer une erreur de compilation

Si la compilation est forcée, une erreur sera signalée :

résultat de l'exécution du programme :

Exception dans le thread « main » java.lang.Erreur : problème de compilation non résolu : la méthode inspect(U) dans le type Box n'est pas applicable pour les arguments (String )

at generics.Box.main(Box.java:36)

Traduction :

Erreur de compilation non résolue

Classe Box La méthode inspect(U) ne peut pas être appliquée aux paramètres de type (String)

Une classe utilisant un paramètre de type restreint peut appeler des méthodes de limite restreinte

sauf que des restrictions peuvent être appliquées aux instances En plus de taper des types génériques, les paramètres de type borné permettent également d'appeler des méthodes définies dans les limites : La méthode

//使用受限类型参数的类
public class NaturalNumber<T extends Integer> {

  private T n;
  public NaturalNumber(T n) { this.n = n; }

  public boolean isEven() {
    return n.intValue() % 2 == 0;
  }

  // ...

isEven appelle la méthode intValue définie dans la classe Integer via n.

Limites multiples

L'exemple précédent illustre l'utilisation d'un paramètre de type avec une seule limite, mais un paramètre de type peut avoir plusieurs limites :

dee20d5a101ff37576d3dea788a52029 Une variable de type avec plusieurs limites est un sous-type de tous les types répertoriés dans la limite. Si l'une des limites est une classe, elle doit être spécifiée en premier. 🎜>

Classe A { /* … / } interface B { / … / } interface C { / … */ }

classe D 0810d4b6c955e24af93cd76cba0b0a47 { /* … */ } Si la limite A n'est pas spécifiée en premier, vous obtenez une erreur de compilation :

class D b08ac1cb90d2575d3d2e6d9d9e86e32d { /* … */ } // erreur de compilation

Algorithme générique

Les paramètres de type limité sont la clé de la mise en œuvre d'algorithmes génériques. Considérez la méthode suivante, qui compte le nombre d'éléments dans un tableau T[] qui sont supérieurs à l'élément elem spécifié.

public static <T> int countGreaterThan(T[] anArray, T elem) {
  int count = 0;
  for (T e : anArray)
    if (e > elem) // compiler error
      ++count;
  return count;
}
The implementation of the method is straightforward,
but it does not compile because the greater than operator (>) applies only to primitive types
such as short, int, double, long, float, byte, and char. 
You cannot use the > operator to compare objects. To fix the problem, use a type parameter
bounded by the Comparable<T> interface:

public interface Comparable<T> {
  public int compareTo(T o);
}
The resulting code will be:

public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
  int count = 0;
  for (T e : anArray)
  //因为这里的T是受限制的类型参数，实现了Comparable接口，于是可以使用接口的方法compareTo
    if (e.compareTo(elem) > 0)
      ++count;
  return count;
}

Recommandations d'apprentissage associées :

Vidéo de programmation

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!