La conversion automatique des types de données primitifs en leur type Wrapper équivalent est connue sous le nom de boxing et l'opération inverse est connue sous le nom de unboxing. C'est la nouvelle fonctionnalité de Java5. Le programmeur Java n'a donc pas besoin d'écrire le code de conversion.
int pour chaîne java
Avantage de l'Autoboxing et du Unboxing :
| Pas besoin de conversion manuelle entre les primitives et les Wrappers, donc moins de codage est requis. |
Exemple simple d'Autoboxing en Java :
class BoxingExample1{ public static void main(String args[]){ int a=50; Integer a2=new Integer(a);//Boxing Integer a3=5;//Boxing System.out.println(a2+' '+a3); } } Testez-le maintenant Output:50 5
téléchargez cet exemple
Exemple simple de déballage en Java :
La conversion automatique du type de classe wrapper en type primitif correspondant est connue sous le nom de Unboxing. Voyons l'exemple d'unboxing :
class UnboxingExample1{ public static void main(String args[]){ Integer i=new Integer(50); int a=i; System.out.println(a); } } Testez-le maintenant Sortir:
50
Autoboxing et Unboxing avec opérateurs de comparaison
| L'autoboxing peut être effectué avec des opérateurs de comparaison. Voyons l'exemple de la boxe avec opérateur de comparaison : |
class UnboxingExample2{ public static void main(String args[]){ Integer i=new Integer(50); if(i<100){ unboxing internally system.out.println(i); } < pre> <span> Test it Now </span> <pre> Output:50 </pre> <hr> <h3>Autoboxing and Unboxing with method overloading</h3> <table class="table"> <tr><td>In method overloading, boxing and unboxing can be performed. There are some rules for method overloading with boxing: <ul> <tr><td>Widening beats boxing</td> </tr><tr><td>Widening beats varargs</td> </tr><tr><td>Boxing beats varargs</td> </tr></ul> </td></tr> </table> <h3>1) Example of Autoboxing where widening beats boxing</h3> <table class="table"> <tr><td>If there is possibility of widening and boxing, widening beats boxing.</td></tr> </table> <pre> class Boxing1{ static void m(int i){System.out.println('int');} static void m(Integer i){System.out.println('Integer');} public static void main(String args[]){ short s=30; m(s); } } </pre> <span> Test it Now </span> <pre> Output:int </pre> <hr> <h3>2) Example of Autoboxing where widening beats varargs</h3> <table class="table"> <tr><td>If there is possibility of widening and varargs, widening beats var-args.</td></tr> </table> <pre> class Boxing2{ static void m(int i, int i2){System.out.println('int int');} static void m(Integer... i){System.out.println('Integer...');} public static void main(String args[]){ short s1=30,s2=40; m(s1,s2); } } </pre> <span> Test it Now </span> <pre> Output:int int </pre> <hr> <h3>3) Example of Autoboxing where boxing beats varargs</h3> <table class="table"> <tr><td>Let's see the program where boxing beats variable argument:</td></tr> </table> <pre> class Boxing3{ static void m(Integer i){System.out.println('Integer');} static void m(Integer... i){System.out.println('Integer...');} public static void main(String args[]){ int a=30; m(a); } } </pre> <span> Test it Now </span> <pre> Output:Integer </pre> <hr> <h3>Method overloading with Widening and Boxing</h3> <table class="table"> <tr><td>Widening and Boxing can't be performed as given below:</td></tr> </table> <pre> class Boxing4{ static void m(Long l){System.out.println('Long');} public static void main(String args[]){ int a=30; m(a); } } </pre> <span> Test it Now </span> <pre> Output:Compile Time Error </pre></100){>
Autoboxing et Unboxing avec surcharge de méthodes
| En cas de surcharge de méthodes, le boxing et le unboxing peuvent être effectués. Il existe quelques règles pour la surcharge de méthodes avec la boxe : |
1) Exemple d'Autoboxing où l'élargissement bat la boxe
| S’il existe une possibilité d’élargissement et de boxe, l’élargissement bat la boxe. |
class Boxing1{ static void m(int i){System.out.println('int');} static void m(Integer i){System.out.println('Integer');} public static void main(String args[]){ short s=30; m(s); } } Testez-le maintenant Output:int
2) Exemple d'Autoboxing où l'élargissement bat les varargs
| S'il existe une possibilité d'élargissement et de varargs, l'élargissement bat les var-args. |
class Boxing2{ static void m(int i, int i2){System.out.println('int int');} static void m(Integer... i){System.out.println('Integer...');} public static void main(String args[]){ short s1=30,s2=40; m(s1,s2); } } Testez-le maintenant Output:int int
3) Exemple d'Autoboxing où la boxe bat les varargs
| Voyons le programme dans lequel la boxe bat l'argument variable : |
class Boxing3{ static void m(Integer i){System.out.println('Integer');} static void m(Integer... i){System.out.println('Integer...');} public static void main(String args[]){ int a=30; m(a); } } Testez-le maintenant Output:Integer
Surcharge de méthodes avec Widening et Boxing
| L'élargissement et la boxe ne peuvent pas être effectués comme indiqué ci-dessous : |
class Boxing4{ static void m(Long l){System.out.println('Long');} public static void main(String args[]){ int a=30; m(a); } } Testez-le maintenant Output:Compile Time Error
