Facultatif est un type qui fonctionne en partant du principe qu'il peut être nul. En stockant l'objet à l'intérieur, vous pouvez écrire le comportement dans le cas de null séparément. Si vous écrivez la conclusion, vous pouvez écrire l'instruction ** "if" comme une chaîne de méthodes. ** **
En un mot, "Nurupo" est un gars ...
Dans un peu plus de détails, dans l'orientation objet, un objet est un énorme morceau de données qui se déplace avec de nombreuses méthodes et champs.
Si la variable de l'objet est nulle, lorsque vous appelez une méthode à partir de cette variable, vous accédez à une méthode non matérialisée et obtenez une ** NullPointerException **.
Par conséquent, il est nécessaire de réécrire le code de manière significative selon que l'objet existe ou non.
L'instruction if est une syntaxe typique qui change le comportement quand elle existe et quand elle n'existe pas. C'est la base des bases du programme.
Maintenant, lorsque l'objet A existe, faisons quelque chose comme obtenir la valeur avec la méthode getDataWord () de l'objet B.
foo.java
~
String wantData = null;
if(A_var != null){
wantData = A_var.gethogeWord();
} else if (B_var != null){
wantData = B_var.getDataWord();
} else {
wantData = "Il n'y avait ni(・_・`)") ;
}
System.out.println(wantData);
~
Est-ce une manière typique d'écrire? Bien sûr, n'oubliez pas les ** cas A et B ** implicites et ** A et B aucun **.
Cependant, si les déclarations sont difficiles à gérer. De plus, il est facile de combiner des caisses et de provoquer une explosion, ce qui rend l'emboîtement difficile.
Si vous écrivez ceci en utilisant une option, cela ressemblera à ceci.
foo.java
~
String wantData = null;
//Valeur d'emballage facultative
Optional<A_class> ObjA_opt = Optional.ofNullable(A_var);
Optional<B_class> ObjB_opt = Optional.ofNullable(B_var);
//Obtenez la valeur.
Optional<String>Hogeword_opt = ObjA_opt.map(A_var-> A_var.gethogeWord());
Optional<String>DataWord_opt = ObjB_opt.map(B_var -> B_var.getDataWord());
//Substitution
wantData = Hogeword_opt.orElseGet(() -> null);
if(wantData == null){
wantData =DataWord_opt .orElseGet(() -> null);
}
System.out.println(wantData);
~
C'est dur de voir de la merde, et je me demande si "si" sort, ce qui est le plus. Expliquons le code avant d'y entrer.
J'utilise toutes les méthodes facultatives. Tout d'abord, la méthode **. Of Nullable () **. Cela encapsule la variable potentiellement nulle dans un type facultatif. Cette fois, nous déclarons un type facultatif qui stocke un objet de type A_class.
Puis la méthode **. Map () **. Utilisez une expression lambda pour obtenir une variable avec la valeur de retour sur la droite encapsulée dans Facultatif. Cette fois, je veux que le getter renvoie une chaîne, j'utilise donc un objet facultatif qui stocke le type String.
Enfin, la méthode ** getElse () **. Ici, nous obtenons la valeur que nous mettons dans l'objet facultatif. À droite de l'expression lambda se trouve ** "valeur à attribuer lorsque la valeur est nulle" **.
Il convient de noter ici que la méthode de type facultatif renvoie le type facultatif. En d'autres termes, il peut être ** en une ligne avec une chaîne de méthodes **.
Si vous écrivez ceci en connectant la chaîne de méthodes, ce sera comme ça.
foo.java
~
String wantData = null;
wantData = Optional.ofNullable(A_var) //Valeur d'emballage facultative
.map(A_var-> A_var.gethogeWord())//Exécution de méthode avec l'option renvoyée
.orElseGet(() -> null);//Obtenez la valeur.
wantData = Optional.ofNullable(B_var) //Valeur d'emballage facultative
.map(B_var-> B_var.getDataWord())//Exécution de méthode avec l'option renvoyée
.orElseGet(() -> null);//Obtenez la valeur.
wantData = Optional.ofNullable(wantData)
.getElse(() -> "Ni l'un ni l'autre n'a été inclus.");
System.out.println(wantData);
~
Une technique qui peut être réalisée car tous les types de retour sont facultatifs. Je pense avoir écrit un code assez propre. C'est plus lisible que l'instruction if, et je pense qu'il est plus facile de créer des conditions similaires et d'ajouter ou de modifier des conditions.
Je pense qu'une déclaration if est bien pour cela, mais je pense que l'effet sera compris si les conditions se compliquent.
J'ai pu écrire des cas hautement lisibles sans utiliser de blocs.
Oui, comme commenté, cela remplacera le résultat de B quelle que soit la valeur de A. C'est terrible. C'est le code qui fonctionne correctement
foo.java
~
String wantData = null;
//Déclarer des variables facultatives
Optional<A_class> A_opt = Optional.ofNullable(A_var);
Optional<B_class> B_opt = Optional.ofNullable(B_var);
wantData =A_opt.map(haitteru_A -> haitteru_A.gethogeWord())
.orElseGet(() ->//Faites une nidification à la lambda!
cm_opt.map(haitteru_B -> haitteru_B.getDataWord())//Obtenu par la méthode côté objet B
.orElseGet(() -> "No Password!") //Exécution de l'expression Lambda à nouveau Ce qui est affecté lorsque les deux sont nuls
);
System.out.println(wantData);
~
La compréhension de l'expression lambda est également délicate, et la version avancée est désagréable w J'ai essayé de le faire, mais ... à la fin, il est inévitable qu'il ait une structure en forme de nid ...
Une chose à noter dans ce code est que la valeur finale attribuée à wantData doit être de type Spring ** La méthode .orElsGet () fonctionne comme une simple instruction If sur le côté droit de l'expression lambda, et elle la génère même. ** Veuillez noter qu'une erreur de compilation se produira si vous entrez Integer en chemin **. Vous devez faire un design solide ici.
Facultatif Utilisons plus. Faire des progrès.
Recommended Posts