Class Wrapper

Di dalam bahasa pemrograman Java, Wrapper Class (Kelas Pembungkus) adalah suatu

mekanisme yang digunakan untuk mengconvert atau mengubah suatu nilai yang di definisikan,
dari tipe data primitif menjadi sebuah nilai dengan tipe data referensi (Objek). Selain itu,
Wrapper Class mendukung method dari tipe data primitif, contohnya seperti Boolean,
Character, Integer, Long, Float, dsb.

Pada bahasa pemrograman Java, terdapat 2 jenis tipe data, yaitu primitif dan referensi
(objek), Tipe Data Primitif adalah tipe data yang tidak memiliki method, hanya memiliki
data saja. Tipe data ini bukanlah sebuah object, sedangkan Tipe Data Referensi  adalah
tipe data yang digunakan untuk memegang referensi dari sebuah object ( instance dari
class).

Class-class wrapper ini berada dalam  java.lang package yang berjumlah 8 class,

yaitu :

Tipe Data Tipe Data

Primitif Referensi

char Character

byte Byte

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

Penggunan Wrapper Class pada Java

Pada contoh program berikut ini, kita menggunakan Wrapper Class serta mambuat
objek dari class tersebut, dengan tipe data, seperti Character, Integer, Long, Boolean
Float dan Double. Lalu mendefinisikan nilainya pada argumen didalam Constructornya.
package sastra_java;

public class Class_wrapper {

public static void main(String[] args){

/* Menginstansi Objek Dari Wrapper Class Dan

* Menggunakan Argumen Dari Tipe Data Primitif
*/

Character objChar = new Character('W');

Byte objByte = new Byte("12");
Short objShort = new Short("100");
Integer objInt = new Integer(523);
Long objLong = new Long(7689);
Boolean objBoolean = new Boolean(true);
Float objFloat = new Float(82.89f);
Double objDouble = new Double(34.67);

//Menampilkan Output dari Class Wrapper

System.out.println("Character: "+objChar);
System.out.println("Byte: "+objByte);
System.out.println("Short: "+objShort);
System.out.println("Integer: "+objInt);
System.out.println("Long: "+objLong);
System.out.println("Boolean: "+objBoolean);
System.out.println("Float: "+objFloat);
System.out.println("Double: "+objDouble);
}
}

Output :

Pada tipe data Byte dan Short, harus dimasukan argumen berupa String, selain
menggunakan constructor dengan kata kunci new. Dapat juga membuat objek serta
argumennya seperti berikut ini:
Character objChar = 'W';
Integer objInt = 523;
Boolean objBoolean = true;
Float objFloat = 82.89f;
Double objDouble = 34.67;

Kecuali pada Byte, Short dan Long.

Selain menampilkan nilai dari argumen tersebut, dapat pula melihat batasan nilai
maximal dan minimal dari tipe data Byte, Short, Integer, Long, Float, Double. Dengan
menggunakan fungsi MAX_VALUE dan MIN_VALUE, seperti berikut ini:
public static void main(String[] args){

System.out.println("=============== MAXIMUM VALUE ==============");

//Melihat Batas Maximal Pada Tipe Data Angka (Bilangan Bulat &
Floating)
System.out.println("Max Value Pada Byte: "+Byte.MAX_VALUE);
System.out.println("Max Value Pada Short: "+Short.MAX_VALUE);
System.out.println("Max Value Pada Integer: "+Integer.MAX_VALUE);
System.out.println("Max Value Pada Long: "+Long.MAX_VALUE);
System.out.println("Max Value Pada Float: "+Float.MAX_VALUE);
System.out.println("Max Value Pada Double: "+Double.MAX_VALUE);

System.out.println("=============== MINIMUM VALUE ==============");

//Melihat Batas Minimal Pada Tipe Data Angka (Bilangan Bulat &
Floating)
System.out.println("Max Value Pada Byte: "+Byte.MIN_VALUE);
System.out.println("Max Value Pada Short: "+Short.MIN_VALUE);
System.out.println("Max Value Pada Integer: "+Integer.MIN_VALUE);
System.out.println("Max Value Pada Long: "+Long.MIN_VALUE);
System.out.println("Max Value Pada Float: "+Float.MIN_VALUE);
System.out.println("Max Value Pada Double: "+Double.MIN_VALUE);
}

output :
Konversi Tipe Data Primitif ke Wrapper Class (Referensi), dan sebaliknya:

Contoh program berikutnya adalah mengubah atau mengkonvert tipe data Primitif ke
Referensi atau sebaliknya, seperti char ke Character, int ke Integer, boolean ke
Boolean, double ke Double dan sebaliknya:

public static void main(String[] args){

//Mengkonversi Tipe Data Primitif ke Wrapper Class (Referensi)

char karakter = 'W';
int angka = 256;
boolean status = true;
double pecahan = 67.3;

Character ConvChar = Character.valueOf(karakter); //Konversi char ke

Charcter
Integer ConvInt = Integer.valueOf(angka); //Konversi int ke Integer
Boolean ConvBoolaen = Boolean.valueOf(status); //Konversi boolean ke
Boolean
Double ConvDouble = Double.valueOf(pecahan); //Konversi double ke
Double

//Mengkonversi Tipe Data Wrapper Class (Referensi) ke Primitif

Character refChar = new Character('W');
Integer refInt = new Integer(332);
Boolean refBoolean = new Boolean(true);
Double refDouble = new Double(84.63);

char primChar = refChar.charValue(); //Konversi Charcter ke char

int primInt = refInt.intValue(); //Konversi Integer ke int
boolean primBoolean = refBoolean.booleanValue(); //Boolean char ke
boolean
 double primDouble = refDouble.doubleValue(); //Konversi Double ke
double
}

Pada program tersebut, untuk mengubah tipe data Primitif ke Wrapper Class, dapat
digunakan fungsi valueOf(). Untuk sebaliknya dapat menggunakan fungsi charValue,
intValue, booleanValue, dsb.

Seperti kita ketahui sebelumnya, nilai primitif bukanlah objek, namun nilai

ini bisa dibungkus (wrap) dengan menggunakan class-class wrapper di Java API
(Application Programming Interface). Karena Java adalah pemrograman yang
berorientasi objek, maka kinerjanya akan terpengaruh bila nilai dari tipe data
primitif ini diperlakukan sebagai objek. Namun, terlepas dari itu semua,
banyak method pada Java yang memerlukan penggunaan objek-objek
sebagai argumen (pass by value).

Autoboxing dan Inboxing

Sebelum JDK 1.5, tidak mudah untuk melakukan konversi dari tipe primitif
seperti int, char, float, double, byte, long, short, atau boolean menjadi equivalen
dengan objeknya dari class Integer, Character, Float, Double, Byte, Long, Short
atau Boolean.

Dalam Java, proses konversi dari tipe primitif menjadi objek dikenal
dengan autoboxing, dan sebaliknya konversi dari objek ke tipe primitif disebut
dengan inboxing. Fitur ini mulai berjalan secara otomatis sejak J2SE 5.0.

Beberapa method dari class-class tersebut yang digunakan untuk proses autoboxing

dan inboxing adalah
 doubleValue()
 floatValue()
 intValue()
 longValue()
 shortValue()
 byteValue()

Namun autoboxing dan inboxing ini hadir dengan peringatan tertentu yang
perlu dipahami sebelum menggunakannya pada saat melakukan coding,  yang
menjadi lebih penting lagi. Karena ini terjadi secara otomatis sehingga
berpeluang membuat bug halus jika anda tidak dapat mengetahui
kapan autoboxing atau inboxing terjadi.

Sebelum Java 1.5, sering terdapat topik penting mengenai jika anda
menggunakan Collections seperti Hashmap ataupun ArrayList, maka anda tidak
bisa menyimpan secara langsung tipe data primitif ke dalam Collections tersebut,
melainkan anda harus mengonversi tipe data primitif tersebut menjadi Objek
baru kemudian anda bisa menyimpannya kedalam Collections.

Dengan diperkenalkannya autoboxing dan inboxing ini, maka compiler Java

secara otomatis melakukan konversi tipe primitif menjadi objek sehingga lebih
memudahkan dalam pembacaan kode.

Kondisi penggunaan autoboxing dan inboxing

Autoboxing diaplikasikan oleh compiler pada kondisi berikut:

 Ketika melakukan pemanggilan method dimana objek sebagai argumen

diharapkan, jika nilai primitif di-pass-kan maka Java secara otomatis akan
mengkonversi nilai primitif tersebut menjadi nilai Objek yang sama.
 Ketika nilai primitif ditetapkan pada variabel dari wrapper class terkait.

Autoboxing saat nilai primitif ditetapkan pada variabel dari wrapper class

Sebelum JDK 1.5 jika kita ingin menggunakan tipe primitif dalam Collection
misalnya array list, maka kita perlu mem-“box” nya. Karena tidak ada auto boxing
atau unboxing sebelum JDK 1.5. Berikut ini adalah kode yang ditulis dalam versi
JDK 1.4:
1 import java.util.ArrayList;
2  
3     public class TestBoxing {
4         //Contoh kode program dalam jdk 1.4
5         public static void main(String[] args) {
6             ArrayList listAngka = new ArrayList();
7             listAngka.add(5);//compilation error
8             listAngka.add(new Integer(5));//Bekerja ketika "Boxed"
9             //unboxed menggunakan "intValue()" untuk mendapatkan nilai "int"
10             int elementPertama = ((Integer)listAngka.get(0)).intValue();
11     }
12 }
Perbedaan Setelah fitur autoboxing diperkenalkan :
1 Import java.util.ArrayList;
2  
3     public class TestBoxing {
4         //Contoh kode program dalam jdk 1.5
5         public static void main(String[] args) {
6             ArrayList listAngka = new ArrayList();
7             listAngka.add(5); //boxed otomatis
8             int elemenPertama = (Integer) listAngka.get(0); //Otomatis unboxed; tanpa method "intValue()".
9     }
10 }

Untuk menghindari konversi tipe (mis. (Integer) listAngka.get (0) – dalam contoh
diatas); Maka bisa digunakan generics. Sehingga kodenya akan terlihat lebih
mudah dibaca, seperti contoh di bawah ini:
1 import java.util.ArrayList;
2 
3     public class TestBoxing {
4         public static void main(String[] args) {
5             ArrayList<Integer> listAngka = new ArrayList<Integer>();
6             listAngka.add(5);
7             int elementPertama = listAngka.get(0);
8     }
9}

Unboxing Dalam Java

Sesuai dokumentasi java ada dua situasi dimana bisa terjadi Autoboxing
atau Unboxing. Pertama, bila method mengharapkan class wrapper dan
pemanggil / caller melewati tipe primitif yang sesuai, maka tipe primitif akan di-
autobox. Seperti contoh berikut ini:

1 public void tampilkan(Integer i){

2   System.out.print(i);
3}
4 int x = 10;
5 display(x);
Kedua, jika tipe primitif ditetapkan ke variabel class wrapper yang sesuai
maka nilai primitif akan di-autobox. Contoh kode di bawah ini menggambarkan
hal yang sama.
1 int x = 10;
2 Integer y = x;

Jika situasi di atas terjadi sebaliknya, maka Unboxing dilakukan oleh kompiler
java.

Dan jika operasi unary atau kondisional dilakukan pada objek class wrapper
maka unboxing dilakukan oleh kompiler. Berikut ini adalah contoh kode
programnya.
1 Integer i = new Integer(10);
2 i++; //Unboxing
3 int sum = 0;
4 
5 if (i % 2 == 0) {//Unboxing
6 sum += i;//Unboxing
7}

Autoboxing dan Unboxing dengan method

overloading
Nilai data primitif dapat di-autobox ke wrapper class jika parameter pada
method mengharapkan objek wrapper. Tetapi ada berbagai kemungkinan jika
metode itu overload dengan method lain yang memiliki tipe parameter lain.

Widening dengan Boxing

Widening akan mengubah suatu variabel ke variabel lain dengan tipe yang lebih
luas. Misalnya String -> Object, byte -> int, int -> long, dll. Jika overloading
terdapat dalam kasus di mana satu metode memiliki parameter “widening” dan
metode lainnya memiliki parameter “box” maka widening akan mengambil
prioritas daripada boxing. Dengan kata lain widening akan mengalahkan boxing.

Contoh program diberikan di bawah ini.

1 public class TestBoxing {
2     
3     public static void tampilkan(Integer i) {
4         System.out.print("Integer");
5     }
6     
7     public static void tampilkan(int i) {
8         System.out.print("int");
9     }
10     
11     public static void main(String[] args) {
12         short x = 5;
13         tampilkan(x);
14     }
15 }

Output:
1 Int

Varargs dengan Boxing

Varargs adalah fitur lain yang diperkenalkan di jdk 1.5. Jika Varargs digunakan
sebagai parameter dalam suatu metode dan metode itu overload, maka Boxing
lebih diprioritaskan daripada Varargs, dengan kata lain Boxing mengalahkan
Varargs.
Contoh program diberikan di bawah ini.
1 public class TestBoxing {
2     
3         public static void display(Integer i) {
4           System.out.print("Integer");
5         }
6
7         public static void display(Integer... i) {
8           System.out.print("Integer...");
9         }
10
11         public static void main(String[] args) {
12           int x = 10;
13           display(x);
14         }
15 }

Output:
1 Integer

Akhirnya satu hal yang perlu diingat, operasi otomatis seperti “widening
lalu boxing” tidak bisa dilakukan. Jadi satu variabel hanya dapat “diperlebar” atau
“di-autoboxed” pada satu waktu. Proses keduanya secara bersamaan tidak
memungkinkan.

Jadi, kode berikut tidak akan dikompilasi.

1 public class TestBoxing {
2     
3       public static void display(Long i) {
4         System.out.print("long");
5       }
6
7       public static void main(String[] args) {
8         int x = 10;
9         display(x);
10       }
11 }