Melakukan casting tipe data adalah menempatkan nilai dari tipe data asal kedalam tipe data yang berbeda.

pada bahasa pemograman java terdapat dua cara untuk melakukan casting:

Widening Casting(Implicit)
Narrowing Casting(Explicit)

widening casting adalah cara menempatkan nilai dari tipe data yang ukuran lebih kecil ke ukuran tipe data yang lebih besar.

sintaks dasar widening casting adalah:

    /* casting dilakukan secara otomatis */
    TIPEDATA variable = variable

narrowing casting adalah cara menempatkan nilai dari tipe data ukuran yang besar kedalam ukuran tipe data yang lebih kecil.

sintaks dasar narrowing casting adalah:

    /* casting dilakukan secara manualy */
    TIPEDATA variable = (TIPE DATA) variable

Type Casting Number Primitive

cara mengkonversi tipe data number primitive pada java.

Java | Cara Konversi Tipe Data Number Primitive

widening casting number primitive:

public class Main {
  public static void main(String[] xxx) {
 
    byte b = 127;
    short s = b; // dilakukan secara otomatis: byte to short
    int i = b; // dilakukan secara otomatis: byte to int
    long l = b; // dilakukan secara otomatis: byte to long
    float f = b; // dilakukan secara otomatis: byte to float
    double d = b; // dilakukan secara otomatis: byte to double
 
    System.out.println(s); // Output: 127
    System.out.println(i); // Output: 127
    System.out.println(l); // Output: 127
    System.out.println(f); // Output: 127.0
    System.out.println(d); // Output: 127.0
 
  }
}

narrowing casting number primitive:

public class Main {
  public static void main(String[] xxx) {
 
    float floatValue = 14.05F;
    long longValue = 10_000;
    char charValue = '1';
 
    int intValue = (int) longValue; //dilakukan secara manual: long to int
    short shortValue = (short) floatValue; //dilakukan secara manual: float to short
    byte byteValue = (byte) charValue;
 
    System.out.println(intValue); //Output: 10000
    System.out.println(shortValue); //Output: 14
    System.out.println(byteValue); //Output: 49
 
  }
}

Type Casting Number Non-Primitive

cara mengkonversi tipe data number non-primitive to number primitive, atau sebaliknya.

sintaks dasar casting non-primitive to primitive:

        /* tipe data non-primitive */
        TIPEDATA data_non_primitive = 120;
 
        /* non-primitive to primitive */
        TIPEDATA variable = data_non_primitive.xxxValue() 
 
        /* bisa dilakukan secara implicit jika tipedata nya sama */
        TIPEDATA variable = data_non_primitive

Casting Non-Primitive to Primitive:

public class Main {
  public static void main(String[] xxx) {
    Long l = 120L;
 
    short var1 = l.shortValue();    // Long to short primitive
    int var2 = l.intValue();      // Long to int primitive
    long var3 = l;                // Long to long primitive
    float var4 = l.floatValue();  // Long to float primitive
    double var5 = l.doubleValue();// Long to double primitive
 
    System.out.println(var1); // Output: 120
    System.out.println(var2); // Output: 120
    System.out.println(var3); // Output: 120
    System.out.println(var4); // Output: 120.0
    System.out.println(var5); // Output: 120.0
  }
}

xxxValue() merupakan method turunan dari class Number, method ini mengembalikan nilai tipe data primitive.

sintaks dasar casting primitive to non-primitive:

        TIPEDATA data_primitive = 120
 
        /* primitive to non-primitive */
        TIPEDATA variable = Integer.valueOf(data_primitive)
 
        /* bisa dilakukan secara implicit jika tipedata nya sama */
        TIPEDATA variable = data_primitive

contoh sintaks dasar diatas, valueOf(data_primitive) merupakan static method class Integer, method ini mengembalikan nilai Integer non-primitive.

Casting Primitive to Non-Primitive:

public class Main {
  public static void main(String[] xxx) {
 
    long long_primitive = 120;
    Long long_nonPrimitive = long_primitive; //long to Long Non-Primitive
 
    int int_primitive = 10;
    Integer int_nonPrimitive = Integer.valueOf(int_primitive); //int to Integer Non-Primitive
 
    double double_primitive = 14.03;
    Double double_nonPrimitive = Double.valueOf(double_primitive); //double to Double Non_primitive
 
 
    System.out.println(long_nonPrimitive); //Output: 120
    System.out.println(int_nonPrimitive);  //Output: 10
    System.out.println(double_nonPrimitive); //Output:1.03
 
  }
}

Catatan: casting ini hanya bisa dilakukan dalam satu jenis tipedata yang sama. Contohnya long primitive tidak bisa dicasting ke Integer non-primitive, hanya bisa di casting ke Long non-primitive.

Type Casting String

cara mengkonversi tipe data String to Number primitive atau non-primitive.

sintaks dasar casting String to primitive:

parseXXX(String value)

Casting String to Primitive:

public class Main {
  public static void main(String[] xxx) {
 
    String str = "100";
 
    int i = Integer.parseInt(str);
    long l = Long.parseLong(str);
    double d = Double.parseDouble(str);
 
    System.out.println(i); //Output: 100
    System.out.println(l); //Output: 100
    System.out.println(d); //Output: 100.0
 
  }
}

parseXXX(String value) merupakan static method, class turunan class Number, method ini akan mengembalikan nilai primitive.

sintaks dasar casting String to non-primitive:

valueOf(String value)

Casting String to Non-Primitive:

public class Main {
  public static void main(String[] xxx) {
    String str = "100";
 
    Integer i = Integer.valueOf(str);
    Long l = Long.valueOf(str);
    Double d = Double.valueOf(str);
 
    System.out.println(i); //Output: 100
    System.out.println(l); //Output: 100
    System.out.println(d); //Output: 100.0
  }
}

valueOf(String value) merupakan static method, class turunan class Number, method ini akan mengembalikan nilai non-primitive.

Catatan: jika anda salah mengkonversi String to Number, baik itu menggunakan method parseXXX() atau valueOf(), method ini akan melempar NumberFormatException.

String str = "100A"
 
int variable = Integer.parseInt(str)
Integer variable = Integer.valueOf(str)

Type Casting Object

cara mengkonversi tipe data object

Upcasting

mengkonversi dari subclass ke superclass, upcasting sangat erat kaitannya dengan inheritance.

contoh mendemonstrasikan upcasting, mari buat class Animal:

public class Animal {
  public void seyHello() {
    System.out.println("Hello Animal!!!");
  }
}

selanjutnya buat class Tiger extend Animal:

public class Tiger extends Animal {
  public void seyHello() {
    System.out.println("Hello Animal Tiger!!!");
  }
 
  public void roar() {
    System.out.println("Arrggggg!!");
  }
}

sekarang buat class BabyTiger extend Tiger:

public class BabyTiger extends Tiger {
  public void seyHello() {
    System.out.println("Hello Baby Tiger!!!");
  }
 
  public void roar() {
    System.out.println("Arrr!!");
  }
 
  public void drink() {
    System.out.println("breast-feed..");
  }

Sekarang kita instance class Tiger dan BabyTiger sebagai Object dengan menetapkannya ke variable reference, tiger & babyTiger:

Tiger tiger = new Tiger(); //instance kelas Tiger
BabyTiger babyTiger = new BabyTiger(); //instance kelas BabyTiger

Kita bisa menetapkan variable reference tiger & babyTiger kedalam reference tipe animal. Caranya:

Animal animal1 = tiger; //upcasting
Animal animal2 = babyTiger //upcasting

contoh sintaks diatas upcasting pun terjadi secara implicit. kita bisa melakukannya secara explicit Caranya:

Animal animal1 = (Animal) tiger; //upcasting secara explicit
Animal animal2 = (Animal) babyTiger; //upcasting secara explicit

namun tidak perlu melakukan upcasting secara explicit, compiler sudah tau bahwa tiger & babyTiger adalah tipe Animal.

Kita bisa menetapkan reference babyTiger kedalam Tiger, Caranya:

Tiger tigerMom = babyTiger; //upcasting

sintaks diatas upcasting pun terjadi secara implicit.

Demonstrasi Upcasting:

public class Main {
  public static void main(String[] xxx) {
 
    Tiger tiger = new Tiger();
    BabyTiger babyTiger = new BabyTiger();
 
    /* Upcasting */
    Animal animal1 = tiger;
    Animal animal2 = babyTiger;
 
    /* Upcasting */
    Tiger tigerMom = babyTiger;
 
    animal1.seyHello();     //Output: Hello Animal Tiger!!!
    animal2.seyHello();     //Output: Hello Baby Tiger!!!
    tigerMom.seyHello();    //Output: Hello Baby Tiger!!!
 
  }
}

Problem melakukan Upcasting: kita tidak bisa mengakses informasi seperti method atau field pada subclass Tiger & BabyTiger.

jika dipaksakan akan menyebabkan compiler error

public class Main {
  public static void main(String[] xxx) {
 
    Tiger tiger = new Tiger();
    BabyTiger babyTiger = new BabyTiger();
 
    /* Upcasting */
    Animal animal1 = tiger;
 
    /* Upcasting */
    Tiger tigerMom = babyTiger;
 
    animal1.roar();     //Output: The method roar() is undefined for the type Animal
    tigerMom.drink();   //Output: The method drink() is undefined for the type Tiger
 
  }
}

Downcasting

mengkonversi dari superclass ke subclass, downcasting sangat erat kaitannya dengan inheritance dan sering digunakan dalam polimorphime.

contoh mendemonstrasikan downcasting, mari buat class Animal:

public class Animal {
  public void seyHello() {
    System.out.println("Hello Animal!!!");
  }
}

kemudian buat class Tiger extend Animal:

public class Tiger extends Animal {
  public void seyHello() {
    System.out.println("Hello Animal Tiger!!!");
  }
 
  public void roar() {
    System.out.println("Arrggggg!!");
  }
}

kemudian buat class Wolf extend Animal:

public class Wolf extends Animal {
  public void seyHello() {
    System.out.println("Hello Animal Wolf!!!");
  }
 
  public void roar() {
    System.out.println("wooooo!!");
  }

Demonstrasi Downcasting:

public class Main {
  public static void main(String[] xxx) {
 
    print(new Tiger());
    print(new Wolf());
 
  }
 
  public static void print(Animal animal) {
    if(animal instanceof Tiger) {
      /* Downcasting */
      Tiger tiger = (Tiger) animal;
      tiger.seyHello(); //Output: Hello Animal Tiger!!!
      tiger.roar();     //Output: Arrggggg!!
    }
    else if(animal instanceof Wolf) {
      /* Downcasting */
      Wolf wolf = (Wolf) animal;
      wolf.seyHello();  //Output: Hello Animal Wolf!!!
      wolf.roar();      //Output: wooooo!!
    }
  }

contoh demonstrasi diatas menggunakan keyword operator instanceof untuk melakukan type check sebelum melakukan casting.

Dewa Programmer

Java | Cara Konversi Tipe Data

Type Casting Number Primitive

Type Casting Number Non-Primitive

Type Casting String

Type Casting Object

Posting Komentar

Memahami Tipe Data MySQL: Cara membuat Tipe Data pada MySQL

Belajar OOP Javascript: Berkenalan dengan OOP pada Javascript

Java OOP | Abstract Class

Struktur Data Javascript: 4 Cara Menyimpan Data pada Javascript

Java OOP | Polymorphism

Java OOP | Nested Class

Cara Menulis Kode Javascript pada HTML: yang Wajib dan Benar

Data Structure | Konsep Pointer - Basic Technical

Pengenalan Dasar Javascript: Mengetahui Sejarah dan Perkembangan