Dies ist ein neuer Inhalt, der nach jdk1.5 eingeführt wurde. Da ich darauf bestehe, dass das Veröffentlichen das beste Gedächtnis ist, habe ich beschlossen, mein Gedächtnis durch einen Blog zu ersetzen:
In der Java-Sprachspezifikation heißt es: In vielen Fällen wird das Packen und Entpacken vom Compiler selbst durchgeführt (in diesem Fall wird das Packen als Boxen bezeichnet, und das Entpacken wird als Unboxing bezeichnet);
Tatsächlich kann automatisches Boxen nach meinem eigenen Verständnis einfach als Kapselung grundlegender Datentypen in Objekttypen verstanden werden, um der Objektorientierung von Java zu entsprechen. Verwenden Sie beispielsweise int:
Kopieren Sie den Codecode wie folgt:
//Deklarieren Sie ein Integer-Objekt
Ganzzahl = 10;
// Die obige Anweisung verwendet automatisches Boxen: analysiert als
Integer num = new Integer(10); Das Obige ist ein gutes Beispiel, da 10 zum Basisdatentyp gehört. Im Prinzip kann es einem Objekt nicht direkt zugewiesen werden. Nach jdk1.5 können Sie dies tun Der Reiz des Autoboxing besteht darin, grundlegende Datentypen automatisch in entsprechende gekapselte Typen umzuwandeln. Nachdem Sie ein Objekt geworden sind, können Sie alle vom Objekt deklarierten Methoden aufrufen, um es automatisch zu entpacken: daher der Name, es bedeutet, das Objekt wieder in einen Basisdatentyp umzuwandeln:
//Boxen
Ganzzahl = 10;
//Auspacken
int num1 = num; Eine sehr typische Verwendung des automatischen Unboxings ist die Durchführung von Operationen: Denn Objekte werden nicht direkt bearbeitet, sondern müssen in grundlegende Datentypen umgewandelt werden, bevor Addition, Subtraktion, Multiplikation und Division durchgeführt werden können.
Ganzzahl = 10;
// Automatisches Unboxing ist bei der Durchführung von Berechnungen implizit
System.out.print(num--); Haha, es sollte sich sehr einfach anfühlen. Jetzt werde ich über etwas Schwierigeres sprechen.
//Zahlen außerhalb von -128~127
Ganzzahlige Zahl1 = 297; Ganzzahlige Zahl2 = 297;
System.out.println("num1==num2: "+(num1==num2));
// Zahl zwischen -128 und 127
Ganzzahl num3 = 97; Ganzzahl num4 = 97;
System.out.println("num3==num4: "+(num3==num4)); Das gedruckte Ergebnis ist: num1==num2: false num3==num4: true
Es ist seltsam: Dies liegt an Javas Design des automatischen Boxens und Unboxings von Integer und Int. Es handelt sich um einen Modus, der Flyweight-Modus (Fliegengewicht) genannt wird.
Um die Wiederverwendung einfacher Zahlen zu erhöhen, definiert Java Folgendes: Beim automatischen Boxen werden Werte zwischen 128 und 127 nach dem Boxen in Ganzzahlobjekte zur Wiederverwendung im Speicher gespeichert, und es gibt immer nur einen Und wenn es den Wert zwischen 128 und 127 überschreitet, wird das geboxte Integer-Objekt nicht wiederverwendet, was der Erstellung eines neuen Integer-Objekts jedes Mal entspricht, wenn es geboxt wird. Verstehen Sie, dass das obige Phänomen auf die Verwendung von zurückzuführen ist Autoboxing: Wenn Sie kein Autoboxing verwenden, sondern new zum Instanziieren wie eine allgemeine Klasse verwenden, wird jedes Mal ein neues Objekt erstellt.
Dieses automatische Ein- und Auspacken wird nicht nur in Basisdatentypen verwendet, sondern auch in der String-Klasse. Wenn wir beispielsweise häufig ein String-Objekt deklarieren:
Kopieren Sie den Codecode wie folgt:
String str = "sl";
//Ersetzen Sie die folgende Deklarationsmethode
String str = new String("sl");
Autoboxing und Unboxing grundlegender Datentypen (Primitive) sind Funktionen, die seit J2SE 5.0 bereitgestellt werden. Obwohl es Ihnen das Packen grundlegender Datentypen erleichtert, werden auch die Details ausgeblendet. Es wird empfohlen, es nur zu verwenden, wenn Sie den Unterschied zwischen grundlegenden Datentypen und Objekten unterscheiden können.
Autoboxing und Unboxing
In Java ist fast alles, was verarbeitet werden soll, ein Objekt (Objekt). Der zuvor verwendete Scanner ist ebenfalls ein Objekt, und der String (String) ist ebenfalls ein Objekt. Grundlegende Datentypen sind jedoch keine Objekte, d. h. Variablen, die Sie mit int, double, boolean usw. definieren, und Literalkonstanten, in die Sie direkt schreiben.
Im vorherigen Abschnitt haben wir grob gesehen, wie praktisch die Bedienung von Objekten ist, und jeder, der Java schon länger verwendet, weiß, dass es manchmal notwendig ist, grundlegende Datentypen in Objekte umzuwandeln. Wenn Sie beispielsweise die put()-Methode eines Map-Objekts verwenden, müssen die Parameter, die übergeben werden müssen, Objekte und keine Basisdatentypen sein.
Sie müssen Wrapper-Typen (Wrapper-Typen) verwenden, um grundlegende Datentypen in Objekte zu verpacken. Im vorherigen Abschnitt wissen Sie bereits, dass Sie vor J2SE 5.0 die folgende Anweisung verwenden müssen, um int in ein Integer-Objekt zu verpacken: Integer integer = new Ganzzahl(10) ;
Die Auto-Boxing-Funktion wird nach J2SE 5.0 bereitgestellt. Sie können die folgende Anweisung direkt zum Packen grundlegender Datentypen verwenden: Integer integer = 10;
Beim Kompilieren bestimmt der Compiler anhand der von Ihnen geschriebenen Anweisungen automatisch, ob das automatische Boxen durchgeführt werden soll. Im obigen Beispiel bezieht sich Integer auf eine Instanz der Integer-Klasse. Die gleiche Aktion kann auf grundlegende Datentypen wie Boolean, Byte, Short, Char, Long, Float, Double usw. angewendet werden. Die entsprechenden Wrapper-Typen (Wrapper-Typen) Boolean, Byte, Short, Character, Long, Float oder Double werden verwendet jeweils genutzt werden. Lassen Sie uns direkt die Autoboxing-Funktion verwenden, um Beispiel 4.4 neu zu schreiben.
Beispiel 4.5 AutoBoxDemo.java
Kopieren Sie den Codecode wie folgt:
öffentliche Klasse AutoBoxDemo {
public static void main(String[] args) {
Ganzzahlige Daten1 = 10;
Ganzzahlige Daten2 = 20;
//In doppelten Wert umwandeln und durch 3 dividieren
System.out.println(data1.doubleValue() / 3);
//Zwei Werte vergleichen
System.out.println(data1.compareTo(data2));
}
}
Das Programm scheint viel einfacher zu sein, da data1 und data2 zur Laufzeit Instanzen von Integer sind und Objektoperationen direkt ausführen können. Das Ergebnis ist wie folgt:
3.3333333333333335
1
Die Methode zur Verwendung des automatischen Boxens kann auch wie folgt aussehen:
Kopieren Sie den Codecode wie folgt:
int i = 10;
Ganzzahl ganze Zahl = i;
Sie können für das Autoboxing auch die allgemeinere Klasse java.lang.Number verwenden. Zum Beispiel:
Zahl Zahl = 3,14f;
3.14f wird automatisch als Float geboxt und dann der Nummer zugewiesen.
Ab J2SE 5.0 sind automatisches Boxen und automatisches Unboxen verfügbar, dh die grundlegenden Datenformularinformationen im Objekt werden automatisch aus dem Objekt entnommen. Es ist beispielsweise möglich, Folgendes zu schreiben:
Kopieren Sie den Codecode wie folgt:
Ganzzahl fooInteger = 10;
int fooPrimitive = fooInteger;
Nachdem fooInteger auf eine Instanz verwiesen wurde, die automatisch als Integer geboxt wird, wird sie, wenn sie einer Variablen fooPrimitive vom Typ int zugewiesen wird, automatisch in den Typ int geändert und dann fooPrimitive zugewiesen. Während des Betriebs kann auch ein automatisches Ein- und Auspacken durchgeführt werden. Zum Beispiel:
Kopieren Sie den Codecode wie folgt:
Ganzzahl i = 10;
System.out.println(i + 10);
System.out.println(i++);
Im obigen Beispiel werden 20 und 10 angezeigt. Der Compiler führt automatisch das Boxen und Entpacken durch, dh 10 wird zuerst geboxt und dann zuerst entpackt, und die Additionsoperation wird ausgeführt Die Zeile wird ebenfalls zuerst entpackt und dann der Inkrementierungsvorgang durchgeführt. Schauen wir uns ein anderes Beispiel an:
Kopieren Sie den Codecode wie folgt:
Boolean boo = true;
System.out.println(boo && false);
Das gleiche boo ist ursprünglich eine Instanz von Boolean. Bei der Durchführung einer UND-Operation wird boo zuerst entpackt und dann mit „false“ verknüpft, und das Ergebnis wird „false“ anzeigen.
////////////////////////////////////////////////////////////////////////// /// /////////////////
Boxen: Das Konvertieren von einem Basistyp in einen Objekttyp wird als Boxen bezeichnet. ***Unboxing: Der Vorgang des Konvertierens von einem Objekt in einen Basistyp wird als Unboxing bezeichnet. Diese Operation wird häufig im Reflexionsprozess verwendet.
Packen: Erstellen Sie eine Objektinstanz im Heap und kopieren Sie den von Ihnen angegebenen Wert. ***Unboxing: Bestimmen Sie, ob die Informationen im Heap, auf die die Referenz zeigt, von dem Typ sind, der geteilt werden soll, und nehmen Sie den Wert aus dem Heap und senden Sie ihn es an die Stack-Variable, andernfalls wird eine Ausnahme gemeldet
////////////////////////////////////////////////////////////////////////// /// //////////////////
Boxing ist eine Einsiedlerkonvertierung eines Werttyps in einen Objekttyp oder in einen beliebigen Schnittstellentyp, den der Werttyp implementiert.
Durch das Boxen eines Werttyps wird eine Objektinstanz zugewiesen und der Wert in ein neues Objekt kopiert.
Kopieren Sie den Codecode wie folgt:
int i=123;
Objekt o=i;
Das Ergebnis dieses Satzes ist die Erstellung eines Objekts o auf dem Stapel, das auf einen Wert vom Typ int auf dem Heap verweist. Dieser Wert wird der Variablen i zugewiesen
Eine Kopie des Werttyps value.
Unten sehen Sie eine Anzeige, die die Boxkonvertierung durchführt
Kopieren Sie den Codecode wie folgt:
int i=123;
Objekt o=(Objekt)i;
In diesem Beispiel wird die Ganzzahlvariable i durch Boxen in das Objekt o konvertiert. Auf diese Weise ändert sich der in der Variablen i gespeicherte Wert von 123 auf 456. Dieses Beispiel zeigt, dass das Objekt eine Originalkopie des Inhalts behält. Das sind 123.
Unboxing ist eine explizite Konvertierung von einem Objekttyp in einen Werttyp oder von einem Schnittstellentyp in einen Werttyp, der die Schnittstelle implementiert. Zu den Unboxing-Vorgängen gehören:
Überprüft die Objektinstanz, um sicherzustellen, dass es sich um einen geschachtelten Wert des angegebenen Werttyps handelt.
Kopiert den Wert aus der Instanz in eine Variable vom Typ Wert.
Beispiel:
Kopieren Sie den Codecode wie folgt:
int i=123;
Objektbox=i;
int j=(int)box;
