Typinferenz in Java ist ein Compilerprozess, der automatisch nicht spezifizierte Datentypparameter aus den Kontextinformationen ableitet. Betrachten Sie ein Beispiel, in dem wir ein Objekt vom Typ generische Klasse erstellen möchten. Um dieses Objekt zu erstellen, müssen wir das Konstrukt einer generischen Klasse mit dem angegebenen Parametertyp wie String, Float, Integer usw. aufrufen, was die Länge des Codes erhöht. Um diese Codierung zu reduzieren, bietet Java die Flexibilität, den Typparameter leer zu lernen, solange der Compiler den Typ des Parameters aus dem Kontext beurteilt oder errät. Darüber hinaus stellt Java auch Platzhalter bereit, mit denen der Benutzer die Vererbung in einem Typparameter erreichen kann. Java 8 bietet eine verbesserte Version der Typinferenz. Im Falle des Typs wird die Inferenz nicht verwendet, dann generiert der Compiler eine ungeprüfte Konvertierungswarnung.
Starten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Die Syntax lautet wie folgt:
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.
Als nächstes schreiben wir den Java-Code, um dies anhand des folgenden Beispiels besser zu verstehen, in dem wir eine generische Klasse erstellen, um das Wertepaar zu akzeptieren, indem wir den generischen Klassenkonstruktor verwenden und die Objekte der generischen Klasse für verschiedene Datenpaare erstellen Typen und verwenden Sie dann die Typinferenz für die Typparameter, wie unten –
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( );
}
}Ausgabe:
Erklärung: Wie im obigen Code kann die generische Klasse Pair zwei verschiedene Datentypen in der Klasse als x und y enthalten. Hier werden die ersten beiden Objekte durch explizite Erwähnung des Integer- und/oder String-Typs auf beiden Seiten erstellt, bei denen es sich um frühere Versionen von Java handelt. Und in den letzten beiden Beispielen zum Erstellen von Objekten werden die Typen auf einer Seite erwähnt (wir können die zweite Seite leer lassen), was in Java 7 eingeführt wurde. Und später wird eingeführt, wie man eine angegebene Methode aufruft, ohne den Typ explizit zu erwähnen von Argumenten in Java 8, die wir im nächsten Beispiel sehen werden.
Als nächstes schreiben wir den Java-Code, um die neue Typinferenz zu verstehen, wobei wir eine generische Klasse erstellen, um die verschiedenen Nachrichtentypen zu akzeptieren, indem wir die generische Klasse der Setter-Methode verwenden und die Objekte der generischen Klasse für die verschiedenen Nachrichten erstellen verschiedene Datentypen und verwenden Sie dann die Typinferenz für die Typparameter, wie unten:
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<>() ));
}
}Ausgabe:
Erklärung: Wie im obigen Code, Aufruf einer bestimmten Methode (genInf1() und genInf2()) ohne explizite Erwähnung des Argumenttyps, der ein Beispiel für die in Java 8 eingeführte neue Typinferenz darstellt.
Als nächstes schreiben wir den Code, um die neue Typinferenz zu verstehen, wobei wir eine Liste der Nachrichten erstellen, indem wir die generische Klasse List verwenden, und die Objekte der generischen Listenklasse für die verschiedenen Nachrichten unterschiedlicher Datentypen erstellen und dann die verwenden Typinferenz und neue Typinferenz für die Typparameter, wie unten:
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.");
}
}Ausgabe:
Typinferenz wird verwendet, um ein Objekt vom Typ generische Klasse zu erstellen und wenn wir möchten, dass der Compiler automatisch nicht spezifizierte Datentypparameter aus der Kontextübergabe ableitet.
Das obige ist der detaillierte Inhalt vonJava-Typinferenz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
