Inférence de type Java

L'inférence de type en Java est un processus de compilation qui déduit automatiquement les paramètres de types de données non spécifiés à partir des informations contextuelles. Prenons un exemple où nous souhaitons créer un objet de type classe générique. Donc, pour créer cet objet, nous devons appeler la construction d'une classe générique avec le type de paramètres spécifié, comme String, Float, Integer etc., qui augmentent la longueur du code. Pour réduire ce codage, Java offre la flexibilité d'apprendre le paramètre de type vide tant que le compilateur juge ou devine le type de paramètre à partir du contexte. En plus de cela, Java fournit également les caractères génériques qui permettent à l'utilisateur d'obtenir l'héritage dans un paramètre de type. Java 8 fournit une version améliorée de l'inférence de type. En cas de type, l'inférence n'est pas utilisée alors le compilateur génère un avertissement de conversion non vérifié.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

La syntaxe est la suivante :

Generic_class < type_parameter > obj = new Generic_class<> ( );
Where -
Generic_class – Generic_class  is an  user create generic class.
<type_parameter> - type_parameter is a type parameter, which represented by agular brakets(<>), that can have one or more type of parameter separated by commas.
Obj – obj is the object of the generic class.
< > − < > (diamond) represents the type inference.

Exemples d'implémentation de l'inférence de type Java

Ensuite, nous écrivons le code Java pour comprendre cela plus clairement avec l'exemple suivant où nous créons une classe générique pour accepter la paire de valeurs en utilisant le constructeur de classe générique et créons les objets de la classe générique pour différentes paires de données. types, puis utilisez l'inférence de type pour les paramètres de type, comme ci-dessous –

Exemple n°1

Code :

package p1;
class Pair <x, y>
{
private x first;
private y second;
public Pair(x a, y b)
{
first=a;
second=b;
}
public x getFirst() {
return first;
}
public y getSecond() {
return second;
}
}
public class Demo
{
public static void main( String[] arg)
{
// unchecked conversion warning
Pair <Integer, String> ob1 = new Pair<Integer, String>(25, "Test1");
System.out.println("Integer value is : "+ob1.getFirst());
System.out.println("String valueis : "+ob1.getSecond());
System.out.println( );
// unchecked conversion warning
Pair <String, Integer> ob2 = new Pair<String, Integer>("Test2", 30);
System.out.println("String valueis : "+ob2.getFirst());
System.out.println("Integer is : "+ob2.getSecond());
System.out.println( );
// type inference, < > left it blank, compiler will infer type
Pair <String, Integer> ob3 = new Pair<String, Integer>("Test3", 30);
System.out.println("Integer valueis : "+ob3.getFirst());
System.out.println("Integer value is : "+ob3.getSecond());
System.out.println( );
// type inference, < > left it blank, compiler will infer type
Pair <Integer, Integer> ob4 = new Pair< >(35, 40);
System.out.println("Integer value is : "+ob4.getFirst());
System.out.println("Integer value is : "+ob4.getSecond());
System.out.println( );
}
}

Sortie :

Explication : Comme dans le code ci-dessus, la classe générique Pair peut contenir deux types de données différents dans la classe comme x et y. Ici, les deux premiers objets créés en mentionnant explicitement le type entier et/ou chaîne des deux côtés, qui sont les versions antérieures de Java. Et dans les deux derniers objets créant des exemples, les types sont mentionnés d'un côté (nous pouvons laisser <> le deuxième côté vide), ce qui a été introduit dans Java 7. Et plus tard, introduisez l'appel d'une méthode spécifiée sans mentionner explicitement le type. d'arguments en java 8, que nous verrons dans l'exemple suivant.

Exemple n°2

Ensuite, nous écrivons le code Java pour comprendre la nouvelle inférence de type où nous créons une classe générique pour accepter les différents types de messages en utilisant la classe générique de la méthode setter et créons les objets de la classe générique pour les différents messages de différents types de données, puis utilisez l'inférence de type pour les paramètres de type, comme ci-dessous :

Code :

package demo;
class myGeneric < x >
{
private x msg;
public x getMsg() {
return msg;
}
public void setMsg(x msg) {
this.msg = msg;
}
public String genInf1(myGeneric <String> m){
m.setMsg( "This is a Hello Message." );
return m.msg;
}
public Integer genInf2(myGeneric <Integer> m){
m.setMsg( 100 );;
return m.msg;
}
}
public class Demo {
public static void main(String[] args) {
// Before java 7 an old approach to create generic class object
myGeneric <String> msg1 = new myGeneric <String>();
msg1.setMsg( "This is a first Message.");
System.out.println(msg1.getMsg());
// type inference
myGeneric <Integer> msg2 = new myGeneric <>();
msg2.setMsg(20);
System.out.println(msg2.getMsg());
// New type inference
System.out.println(msg1.genInf1( new myGeneric<>() ));
System.out.println(msg1.genInf2( new myGeneric<>() ));
System.out.println(msg2.genInf1( new myGeneric<>() ));
System.out.println(msg2.genInf2( new myGeneric<>() ));
}
}

Sortie :

Explication : Comme dans le code ci-dessus, appeler des méthodes spécifiques (genInf1() et genInf2()) sans mentionner explicitement le type d'arguments qui sont l'exemple de la nouvelle inférence de type introduite dans Java 8.

Exemple #3

Ensuite, nous écrivons le code pour comprendre la nouvelle inférence de type où nous créons une liste du message en utilisant la classe générique List et créons les objets de la classe générique list pour les différents messages de différents types de données, puis utilisons le inférence de type et nouvelle inférence de type pour les paramètres de type, comme ci-dessous :

Code :

package demo;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main( String[] arg) {
// Before Java 7 to create a list
List <String> msg1 = new ArrayList <String>();
msg1.add("This is a first Message.");
getMsg(msg1);
// Java 7 type inference
List<String> msg2 = new ArrayList<>();
msg2.add("This is a second Message.");
getMsg(msg2);
// as list is generic class so add integer
List<Integer> msg3 = new ArrayList<>();
msg3.add(100);
getMsg1(msg3);
// Java 8 Compiler type infers type of ArrayList
getMsg(new ArrayList<>());
}
public static void getMsg(List <String> m){
if(!m.isEmpty()){
m.forEach(System.out::println);
}else System.out.println("No Message.");
}
public static void getMsg1(List <Integer> m){
if(!m.isEmpty()){
m.forEach(System.out::println);
}else System.out.println("No Message.");
}
}

Sortie :

Conclusion

L'inférence de type est utilisée pour créer un objet de type classe générique et si nous voulons que le compilateur déduise automatiquement les paramètres de types de données non spécifiés à partir de la passe de contexte.

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!