Java double keyword

Ang Java double keyword, tulad ng sa anumang iba pang wika, ay nagpapahiwatig ng format ng computer para sa kumakatawan sa isang floating point number, na sumasakop sa 64 bits, o 8 bytes, sa memorya. Sa artikulong ito ay pag-uusapan natin ang tungkol sa doble at tingnan ang ilang mga halimbawa.

Floating point at computing: isang maikling paglalarawan sa matematika

Ang mga fractional na numero ay alinman sa fixed o floating point. Ang unang opsyon ay maaaring katawanin bilang isang regular na fraction, kung saan ang numerator (ang numero mismo) at ang denominator (ang scaling factor nito) ay magiging mga integer. Halimbawa, ang numero 2.7 ay 27 na may scaling factor na 10, 3.14 - 314 na may factor na 100. Gayunpaman, ang diskarteng ito ay hindi masyadong tumpak mula sa isang computational point of view, samakatuwid, madalas silang gumagamit ng floating point representation. Sa pag-compute, ang floating-point arithmetic ay isang espesyal na representasyon ng aritmetika ng mga tunay na numero bilang isang pagtatantya upang suportahan ang isang trade-off sa pagitan ng saklaw at katumpakan. Ang pangunahing format para sa kumakatawan sa mga floating point na numero sa Java ay tinatawag na float. Ang pangalan nito ay nagmula sa floating point. Ang Float ay 32 bits, kung saan 1 bit ay signed bit, 8 bit para sa exponent at 23 bit para sa significand. Ang saklaw nito ay ±3. 40282347E + 38F ie 6-7 makabuluhang digit. Ang pangalang double ay nagmula sa double float. Angang double type ay dalawang beses na mas malaki kaysa sa float : 8 bytes kumpara sa 4. Tinatawag din itong double precision real number. Sa 64 bits na nakalaan para sa double number, 1 ay signed bit, 11 bits ay para sa exponent at 52 bits ay para sa significand. Ang Java double fraction ay nag-iimbak ng mga numero sa hanay na ±1.79769313486231570E + 308 ie 15-16 makabuluhang digit. Ang double ay isang mas tumpak na format. Kaya't kung kailangan mong mag-imbak ng talagang malalaking numero na mas pinipili ang doble sa float ay isang magandang ideya. Sa pamamagitan ng paraan, ang mga pamamaraan ng matematika tulad ng sqrt, sin o cos at marami pang iba ay nagbabalik ng dobleng halaga. Gayunpaman, dapat kang magbayad para sa dobleng katumpakan na may memorya.

Paglikha ng dobleng variable

Ang dobleng uri ay ginagamit upang mag-imbak ng mga tunay na numero. Upang lumikha ng isang variable sa code na makakapag-imbak ng mga tunay na numero, kailangan mong gamitin ang command:

double name;

Kung saan ang pangalan ay ang pangalan ng variable.

double myPrice;  //here we create a variable called myPrice
double action; //and here -- action.

Maaari mo ring gamitin ang shorthand upang lumikha ng maramihang mga variable ng uri double :

double name1, name2, name3;

Mga Halimbawa ng Java double keyword

Magbigay tayo ng ilang halimbawa ng paggamit ng Java double keyword upang lumikha ng variable.

double myPrice = 5.0;
double height = 180;
double x = 7.1, y = 3.0;

Dito sa variable myPrice mayroon tayong value na 5.0, sa variable na taas — 180, sa x inilalagay natin ang value na 7.1, at 3.0 sa y .

Doble bilang isang integer

Sa Java, ang mga dobleng variable ay maaaring italaga ng parehong tunay at integer na mga numero. Kapag nagtatalaga ng mga integer, kino-convert lang ang mga ito sa mga tunay na numero. Bagaman kung minsan ang isang bahagyang pagkawala ng katumpakan ay posible.

double height = 180;
int k = 2;
int i = 5;
double myDouble = k*i;

Sa katunayan, iniimbak ng variable ng taas ang numerong 180.0, at iniimbak ng variable ng myDouble ang numerong 10.0.

Doble at integer na pakikipag-ugnayan

Bilang karagdagan, kung ang isang integer at isang tunay na numero ay kasangkot sa ilang expression, ang integer ay unang mako-convert sa isang tunay na numero at pagkatapos ay nakikipag-ugnayan sa isa pang tunay na numero.

public class DoubleDemo {
   public static void main(String[] args) {
       int k = 2;
       double myDouble1 = 5;
       double myDouble = k*7.0;
       System.out.println(myDouble1);
       System.out.println(k*myDouble1);
       System.out.println(myDouble);
   }
}

Sa halimbawang ito, ang magiging output ay:

5.0 10.0 14.0

Kahit na ang numerong myDouble1 ay tinukoy bilang 5 at hindi 5.0, nakikita ng Java ang numerong ito bilang double , kaya talagang mukhang 5.0 ito. Kung i-multiply natin ang int at double, palagi tayong nakakakuha ng double , kahit na ang numerong ito ay isang integer. Maaari kaming magtalaga ng mga variable ng uri double sa mga variable ng uri int . Upang gawin ito, kailangan mong gumawa ng isang tahasang uri ng conversion. Siyempre, ang fractional na bahagi ay itatapon, ang numero ay puputulin sa isang mas maliit na integer.

public class DoubleDemo {
   public static void main(String[] args) {
       double x = 57.789;
       int almostX;
       almostX = (int)x;
       System.out.println(almostX);
   }
}

Ang output ay:

Sa wakas, pag-usapan natin ang tungkol sa dibisyon. Ito ang pinakakawili-wiling bagay. Maaaring nakita mo na ang katotohanan na kung hahatiin mo ang dalawang integer, kung gayon bilang resulta ng paghahati ay makakakuha tayo ng isang integer, kahit na hindi sila pantay na mahahati sa isa't isa:

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7/2;
       System.out.println(myDouble);
   }
}

Ang resulta ay:

3.0

Ito ay dahil ang Java machine ay unang naghahati ng dalawang integer (at nakakakuha ng 3), at pagkatapos ay iniimbak ang halagang ito sa isang variable na doble ang uri, at nakakakuha ng 3.0 bilang resulta. Upang makakuha ng hindi integer, ngunit karaniwang dibisyon, kailangan mong manloko. Halimbawa, isulat ang isa sa mga numero bilang isang tunay na numero (pagkatapos ang buong expression ay awtomatikong na-convert sa tunay). Kung nagtatrabaho tayo sa mga variable ng uri ng integer, maaari silang i-multiply sa 1.0. Hindi nito babaguhin ang halaga, ngunit babaguhin nito ang uri ng variable mula int hanggang double .

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7.0/2;
       int x = 5;
       int y = 2;
       System.out.println(myDouble);
       System.out.println(x*1.0/y);
   }
}

Ang output ay:

3.5 2.5