Un, générique
1. Vue d'ensemble
Les génériques Java ont été introduits dans J2 SE 1.5. L'essence réside dans les types paramétrés. "Il s'agit de paramétrer le type à partir du type concret d'origine, similaire au paramètre variable de la méthode. À ce stade, le type est également défini comme un formulaire de paramètre (qui peut être appelé Paramètre de type), puis transmettez le type spécifique (argument de type) lors de l'utilisation de / appelant. Ce type de paramètre peut être utilisé dans la création de classes , d' interfaces et de méthodes. Ils sont appelés classes génériques, interfaces génériques et génériques Méthode de type.
1.1 Classe générique
/**
* 泛型类
*/
//
public class ClassName<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
1.2 Interface générique
/**
* 泛型接口
*/
public interface IntercaceName<T>{
T getData();
}
1.2.1 Implémentation de l'interface générique
//指定类型
public class Interface1 implements IntercaceName<String> {
private String text;
@Override
public String getData() {
return text;
}
}
//不指定类型
public class Interface1<T> implements IntercaceName<T> {
private T data;
@Override
public T getData() {
return data;
}
}
1.3 Méthodes génériques
private static <T> T methodName(T a, T b) {
}
1.4 Types de restrictions génériques
Lorsque vous utilisez des génériques, vous pouvez spécifier la zone limitée des génériques, par exemple, il doit s'agir de la classe d'implémentation d'une certaine classe, le format:
<T extends 类或接口1 & 接口2>
1.5 Caractères génériques dans les génériques
Des caractères génériques de type sont-ils utilisés? Remplacez les arguments de type spécifiques à la méthode.
- <? extend Parent> spécifie le dernier du type générique
- <? super Child> spécifie le dernier du type générique
- <?> spécifie le dernier du type générique
1.6 Fonction
(1) Généralisation (2) Sécurité de type (3) Suppression de la conversion forcée de type (4) Rétrocompatibilité
Améliorer le taux de réutilisation du code; les types dans les génériques sont spécifiés lorsqu'ils sont utilisés, et aucune conversion de type forcée n'est requise (sécurité de type, le compilateur vérifiera le type)
Sécurité des types: l' objectif principal des génériques est d'améliorer la sécurité des types des programmes Java . En connaissant les restrictions de type des variables définies à l'aide de génériques, le compilateur peut vérifier les hypothèses de type à un niveau très élevé . Sans génériques, ces hypothèses n'existent que dans l'esprit des développeurs de systèmes. En capturant ces informations de type supplémentaires dans la déclaration de variable, les génériques permettent au compilateur d'appliquer ces contraintes de type supplémentaires . Les erreurs de type peuvent être détectées au moment de la compilation au lieu d'être affichées en tant que ClassCastException au moment de l'exécution. Le déplacement de la vérification de type de l'exécution à la compilation aide les développeurs Java à trouver les erreurs plus tôt et plus facilement et améliore la fiabilité du programme.
Éliminer la conversion de type forcée: un avantage secondaire des génériques est l'élimination de nombreuses conversions de type forcées dans le code source. Cela rend le code plus lisible et réduit le risque d'erreurs. Bien que la réduction de la conversion de type coercitif puisse augmenter le degré d'éloge cumulatif du code en utilisant des classes génériques, la déclaration de variables génériques apportera le degré cumulatif correspondant . L'utilisation de variables génériques une fois dans un programme simple ne réduira pas le degré d'accumulation de code. Mais pour les grands programmes qui utilisent plusieurs fois des variables génériques, il peut être accumulé pour réduire le degré d'éloge. Ainsi, une fois que les génériques ont éliminé la conversion de type forcée, cela rendra le code plus clair et plus propre.
Efficacité de fonctionnement générique: dans la programmation non générique, passer des types simples en tant qu'objets entraînera des opérations de boxe et de déballage , qui ont toutes deux beaucoup de surcharge. Après l'introduction des génériques, il n'est pas nécessaire d'effectuer des opérations de boxe et de déballage, donc l'efficacité opérationnelle est relativement élevée, surtout dans le système où les opérations de collecte sont très fréquentes , l'amélioration des performances apportée par cette fonctionnalité est plus évidente.
1.7 Attention
- Après la compilation, le programme prendra des mesures pour dégénérer.
- Les génériques en Java ne sont valides que lors de la compilation.
- Pendant le processus de compilation, une fois le résultat générique vérifié correctement, les informations associées du générique seront effacées et ajoutées à la limite de l'objet entrant et sortant de la méthode.
- Vérification de type et méthodes de conversion de type. En d'autres termes, les informations génériques n'entreront pas dans la phase d'exécution.
- Ne définissez pas de méthodes equals (Tx) dans une classe générique, car la classe Object a également une méthode equals. Lorsque la classe générique est effacée, ces deux méthodes entreront en conflit.
1.8 Effacement générique
Lors de la compilation, toutes les informations génériques seront effacées.
/**
* 泛型擦除
*/
public class Test {
public static void main(String[] args) {
ArrayList<String> arrayList1=new ArrayList<String>();
arrayList1.add("abc");
ArrayList<Integer> arrayList2=new ArrayList<Integer>();
arrayList2.add(123);
System.out.println(arrayList1.getClass()==arrayList2.getClass()); //结果为true
}
}
Le problème des pseudo-génériques n'est pas comme les modèles C ++.
J'ai vu un blog et j'ai acquis de l'expérience. Postez ici pour relier
les principes internes des génériques: effacement de type et problèmes causés par l'effacement de type