Résumé des génériques Java

introduction

J'ai de nouveau fait des recherches sur les génériques ces derniers jours, alors après avoir donné un bref aperçu des génériques, j'ai décidé de résumer les deux contenus suivants sous forme de mémo.

• Portée générique
• Parler des variables de type

Présentation des génériques

Quoi qu'il en soit, je voudrais réorganiser les avantages de l'utilisation des génériques. Il ** vous avertira au moment de la compilation si vous essayez d'insérer un objet du mauvais type ** (cité dans Effective Java 3rd Edition Chapter 5 Generics). En conséquence, un traitement similaire peut être réalisé avec différents types dans la plage dans laquelle la sécurité de type peut être garantie. Maintenant, je voudrais montrer un exemple concret dans le code. Ici, je voudrais comparer des séquences et des génériques et reconnaître la bonté d'écrire dans les génériques. Écrivez la définition de la liste, l'ajout à la liste et l'extraction de la liste sans utiliser de génériques comme suit.

ArrayList list = new ArrayList(); 
list.add("hoge"); 
String s = (String) list.get(0);

Puisqu'il est extrait en tant que type Object, il est nécessaire de le convertir explicitement, et s'il y a une erreur (telle que l'affectation avec int et l'extraction avec String), vous ne remarquerez pas l'erreur à moins que vous ne la déplaciez. ← C'est très douloureux. Écrivez la définition de la liste à l'aide des génériques, l'ajout à la liste et l'extraction comme suit.

ArrayList<String> list = new ArrayList<String>(); 
list.add("hoge"); 
String s = list.get(0);

J'obtiens une erreur lors de la compilation. (Vous pouvez remarquer l'erreur avant de l'exécuter ← C'est très agréable)

À propos de la portée des génériques

Generics a deux portées. Portée de la méthode et portée de l'instance. Un aperçu est donné pour chacun.

Portée de la méthode

Tout d'abord, la syntaxe est indiquée ci-dessous.

SetInt.java

public class SetInt{
  public <E> Set<E> union(Set<E> s1,Set<E> s2){
    // (Exemple)Traitement pour ajouter s1 et s2
 }
}

La première chose que vous remarquerez est le après le modificateur d'accès public. Il s'agit d'une déclaration de variable de type. Cette déclaration nous permet de définir une association selon laquelle l'argument et la valeur de retour sont du même type dans le cadre de la méthode. La déclaration générique dans la portée de la méthode peut être utilisée non seulement pour les méthodes d'instance mais aussi pour les méthodes statiques et les constructeurs. Lors de l'appel, il existe des cas où il est appelé tel quel et des cas où il est appelé en spécifiant explicitement le type.

Lors de l'appel tel qu'il est

Set<Integer> result = SetInt.union(Set<Integer>,Set<Integer>);

Lors de l'appel en spécifiant explicitement le type

Set<Integer> result = SetInt.<Integer>union(Set<Integer>,Set<Integer>);

De plus, le type peut être spécifié explicitement et le traitement des exceptions peut être appelé comme suit.

Hoge.java

public class Hoge{
	public <E extends Exception> void example() throws E {};
	public  void test() {
		try {
			this.<IOException>example();
		} catch (IOException e) {
			//Gestion des exceptions lors de la capture d'exception IOException
		}
		try {
			this.<SQLException>example();
		} catch (SQLException e) {
			//Gestion des exceptions lors de la capture d'exception SQLException
		}
	}	
}

Portée de l'instance

Elle est plus souvent vue que la portée de la méthode, et j'estime qu'elle est généralement traitée dans les livres d'introduction. Un exemple est présenté ci-dessous.

Stack.java

public class Stack<E> {
  private E elements;
  public void push(E e) {
	//Processus pour pousser vers les éléments
  }
  public E pop() {
	//Traitement pour extraire E des éléments
  }
}

Vous pouvez définir des associations dans lesquelles les arguments, les valeurs de retour et les types de champs d'instance de plusieurs méthodes d'instance déclarées (deux ci-dessus) sont identiques.

Histoire autour des variables de type

On suppose que vous avez connaissance de «covariant, antivariant, immuable» et du «principe de remplacement de Riskov». Cet article est facile à comprendre sur le premier (https://www.thekingsmuseum.info/entry/2016/02/07/235454) Dans le mémo suivant, à titre d'exemple, il existe des classes A, B et C, respectivement, et elles sont vérifiées comme ayant une relation d'héritage de C étend B et B étend A, respectivement.

Covariant

Il peut être défini comme suit.

List<? extends B> extendsBList = new ArrayList<C>();

L'extensionAList ci-dessus a les propriétés suivantes.

1. Les variables de type B et de type C peuvent être extraites de extendBList.
2. Seul le type nul peut être stocké dans extendBList.

Mis à part la propriété 1, la propriété 2 reste discutable. Le processus par lequel la propriété 2 est dérivée est résumé ci-dessous.

Pourquoi ne puis-je pas stocker autre chose que du type nul dans extendBList?

Par exemple, il peut être stocké dans extendBList et extendBList.add (new B ()); tient. Mais encore une fois, veuillez vous référer au code d'initialisation de extendBList. Initialisé avec le type ArrayList . Si B pouvait être ajouté (), le type B serait ajouté () au type ArrayList , provoquant une contradiction. Par conséquent, dans List <? Extends B>, add () peut être ajouté à List et List qui peuvent être assignés à List <? Extends B> afin que la sécurité du type ne soit pas rompue. Une contrainte est placée pour que seuls de nouveaux éléments puissent être ajoutés (). Puisqu'elle n'a qu'un type nul, la propriété 2 tient.

List<? super B> superBList = new ArrayList<A>();