Uri ng Java Casting

Ano ang Uri ng Casting sa Java?

Ang uri ng data ay isang paunang natukoy na hanay ng mga halaga na tumutukoy sa uri ng mga halaga na maaaring maimbak dito kasama ng operasyon na maaaring isagawa sa mga ito. Ang Java Type Casting ay isang proseso kung saan ang isang uri ng data ay na-convert sa isa pa. Maaari itong maging implicit at tahasang . Ang implicit typecasting na kilala rin bilang automatic typecasting ay ginagawa ng compiler. Ang tahasang typecasting ay ginagawa nang manu-mano ng programmer sa code.

Bakit Kinakailangan ang Uri ng Casting?

Ang Java ay may iba't ibang primitive na uri ng data na nangangailangan ng iba't ibang espasyo sa memorya. Maaari itong magdulot ng mga isyu sa compatibility habang nagtatalaga ng halaga ng isang uri ng data sa isa pa. Kung ang mga datatype ay tugma na, ang typecasting ay awtomatikong ginagawa ng compiler. Kaya, nalulutas ng typecasting ang isang pangunahing problema sa compatibility kapag nakikitungo sa iba't ibang uri ng data sa aming programa.

Mga Uri ng Java Type Casting

Mayroong dalawang uri ng uri ng paghahagis sa Java.

1. Widening Type Casting — Kilala rin bilang Implicit o Automatic Type Casting
2. Narrowing Type Casting — Kilala rin bilang Explicit o Manual Type Casting

Pagpapalawak ng Uri ng Casting

Ang pagpapalawak ng typecasting, gaya ng ipinahihiwatig ng pangalan, ay tumutukoy sa pagpapalawak ng isang mas maliit na uri ng data sa isang mas malaking uri ng data. Ginagawa namin ang typecasting na ito kapag gusto naming i-convert ang isang maliit na uri sa isang malaking uri. Ang mga uri ng data ay dapat na magkatugma sa isa't isa. Walang implicit na conversion mula sa numeric patungo sa char o boolean na uri. Sa Java, hindi tugma ang mga uri ng char at boolean. Ang ganitong uri ng paghahagis ay awtomatikong ginagawa ng compiler nang walang anumang pagkawala ng impormasyon. Hindi ito nangangailangan ng anumang panlabas na trigger ng programmer.

Halimbawa

//Automatic type conversion
public class WideningExample {
   public static void main(String[] args) {

       int i = 100;
       System.out.println("int value: " + i);

       // int to long type
       long l = i;
       System.out.println("int to long value: " + l);

       // long to float type
       float f = l;
       System.out.println("int to float value: " + f);


       byte b = 1;
       System.out.println("byte value: " + b);

       // byte to int type
       i = b;
       System.out.println("byte to int value: " + i);

       char c = 'a';
       System.out.println("char value: " + c);

       // char to int type
       i = c;

       // prints the ASCII value of the given character
       // ASCII value of 'a' = 97
       System.out.println("char to int value: " + i);
   }
}

Output

Paliwanag

Sa code sa itaas, ipinakita namin ang widening typecasting na awtomatikong ginagawa ng compiler. Una sa lahat, nagtalaga kami ng mga halaga sa isang int , byte , at char . Pagkatapos ay itinalaga namin ang mga halaga ng int sa isang long at float , na parehong mas malaki kaysa sa int . Nagtalaga din kami ng mga halaga ng byte at char sa int . Ang parehong byte at char ay mas maliit na mga uri ng data kaysa sa int , kaya, ang mga conversion na ito ay implicit.

Narrowing Type Casting

Ang narrowing typecasting, gaya ng ipinahihiwatig ng pangalan, ay tumutukoy sa pagpapaliit ng isang mas malaking uri ng data sa isang mas maliit na uri ng data. Ginagawa namin ang typecasting na ito kapag gusto naming i-convert ang isang malaking uri sa isang maliit na uri. Para sa ganitong uri ng pag-cast, ino-override namin ang default na conversion ng Java sa pamamagitan ng pagtukoy sa sarili naming conversion. Upang makamit ito, isinusulat namin ang variable o halaga na kailangang i-typecast na unahan ng target na uri ng data sa mga panaklong '()'. Gayunpaman, ang ganitong uri ng paghahagis ay maaaring magresulta sa isang posibleng pagkawala ng katumpakan.

Halimbawa

//Manual Type Conversion
public class NarrowingExample {
   public static void main(String[] arg) {

       // double data type
       double d = 97.04;
       // Print statements
       System.out.println("double value: " + d);

       // Narrowing type casting from double to long
       // implicitly writing the target data type in () followed by initial data type
       long l = (long) d;

       // fractional part lost - loss of precision
       System.out.println("long value: " + l);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       int i = (int) l;

       // fractional part lost - loss of precision
       System.out.println("int value: " + i);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       char c = (char) i;

       // displaying character corresponding to the ASCII value of 100
       System.out.println("char value: " + c);
   }
}

Output

Paliwanag

Ang pagpapaliit ng typecasting ay kailangang tahasang gawin ng programmer gamit ang isang karaniwang syntax. Sa programa sa itaas, nagsimula kami sa isang dobleng halaga na mas malaki kaysa sa mahaba at int na mga uri ng data. Na-typecast namin ito ng doble sa mahaba at int sa pamamagitan ng paggamit ng mga panaklong na may mga gustong uri ng target na data. Manu-mano rin kaming nag-type ng 'int' sa 'char'.

Konklusyon

Sa pagtatapos ng post na ito, umaasa kaming nasanay ka na sa Java Type Casting nang detalyado. Natutunan mo ang dalawang uri ng typecasting sa java. Natutunan mo rin kung paano manu-manong i-cast ang mga hindi tugmang uri ng data gamit ang Narrowing typecasting. Maaari mong subukan ang iba pang mga kumbinasyon ng mga uri ng data na may iba't ibang mga halaga sa iyong sarili upang maunawaan ito nang mas malalim. Panatilihin ang pagsasanay para sa isang mas malalim na utos ng konsepto. Hanggang doon, patuloy na lumago at patuloy na nagniningning!