ืืงืฆืจื ืขื ืกืืืื ืืกืื int ื-Double ื-Java
int ืืื ืกืื Java ืคืจืืืืืืื ืขืืืจ ืืกืคืจืื ืฉืืืื (ืืืื -25, 0, 1828182845). ืกืื ืื ืืฉืชืืฉ ื-32 ืกืืืืืช ืืืืกืื ืขืจื ืืฉืชื ื. ืืืืื ืฉื ืืกืคืจื int ืืื ื -231 ืขื 231 - 1 ืื, ืฉืื ืืืชื ืืืืจ, ื -2147483648 ืขื 2147483647. ืกืื ืืคืื ื-Java ืืืืฆื ืืกืคืจื ื ืงืืื ืฆืคื, ืืงืฆื 64 ืกืืืืืช ืืืืืจืื ืืืืื ืืกืื ืืื -1.7 *10308 ืขื 1.7*10308. ืื ืืชื ืืืืฆื ืืช ืืืืื ืฉื int ืืืืชื ืฆืืจื, ืืื ืืืื -2*109 ืขื +2*109. ืื ื ืืืฉื ืฉืื ืืจืืจ ืฉืื ืืกืคืจ ืกืื int ืืชืืื ืืืืืจืื ืฉืืืงืฆื ืืืกืคืจ ืกืืืื ืคืจืืืืืืืืื ืืคืืืื. ืื ืืกืฃ, ืื ืืกืคืจ ืฉืื ืืืื ืืืืืช ืืืืฆื ืืืกืคืจ ืฉืืจ ืขื ืืืง ืฉืืจ ืืคืก. ืื ืงืืืช ืืื ืืชืืืืช, ืืื ืกืคืง ืฉ: 5 = 5.0 ืื -57.0 = -57.ืืืจืช int ืืืคืืื
ืื ืงืืืช ืืื ืฉื Java, ืื ืกืืื double ื-int ืชืืืืื. ืืืืืื ืฉืืืจืช int ื-double ืขืืกืงืช ืืืืื ืฉื ืืืื ืืงืื ืืืชืจ, ืกืื ืื ืฉื ืืืจื ืงืืจื ืืืืชืืืช ืื ืืจืืืืช ืืกืื ืืจืืื. ื ืืชื ืืืืืจ int ืืืคืื ื-Java ืืืืคื ืืืืืืื, ืขื ืืื ืืงืฆืืช ืขืจื int ืืืฉืชื ื ืืคืื. ืืื ื ืืื ืืืืื ืืงืื ื-typecasting:public class intToDouble {
public static void main(String[] args) {
int myInt1 = 10;
int myInt2 = 2147483647;
double myDouble1, myDouble2;
System.out.println("my integers are: " + myInt1 + ", " + myInt2);
myDouble1 = myInt1;
myDouble2 = myInt2;
System.out.println("after typecasting/widening to double: " + myDouble1 + ", " + myDouble2);
}
}
ืื ื ืืคืื:
ืืืกืคืจืื ืืฉืืืื ืฉืื ืื: 10, 2147483647 ืืืืจ ืฉืืืืจ/ืืจืืื ืืืืคืื: 10.0, 2.147483647E9
ืืขืจืืช: E9 ืืื ืคืืจืืฉื 109, ืื ื ืงืจื ืกืืืื ืืืขื. ืฉืื ืื ืื ืฉืืกืคืจืื ืืคืืืื ื ืืชืืื ืืืจื ืืื ืขื ื ืงืืื ืืืคืจืืื ืืื ืืืืง ืืฉืืจื. ืื ืืืจืืืื ืขื ืืฉืชื ื ืฉื ืืคืื ืืืื ืืกืื ืื ืขืจื, ืืื ืฆืืจื ืืขืฉืืช ืืืช, ืืื ืืคืื ืืืกืคืจ ืืืคืื ืชืืื ืืืื ืืืง ืฉืืจ, ืื ืื ืืื ืืคืก.
ืืืจืช int ืืืคืืื ืืืืฆืขืืช ืคืขืืื ืืกืคืจืืช ื ืืืจืืืช
ืืชืจื ืืื, ืื ืืคืขืืืืช ืืืกืคืจืืืช ืขื ืืฉืชื ืื ืืกืืืื ืฉืื ืื ื-Java ืืืืืืืช ืืืจืืืช ืกืื. ืืืืืจ, ืชืืฆืืช ืืคืขืืื ืชืืื ืืกืื ืจืื ืืืชืจ. ืืื, ืืื ืืืืืจ ื-int ืืืคืื, ืืชื ืืืื ืืืฉืชืืฉ ืืคืขืืื "ื ืืืืจืืืช". ืืืืืื, ืืืคื int ื-1.0 (ืืกืคืจ ืืคืื) ืื ืืืกืฃ 0.0 ื-int. ืื ื ืืืืื ืืืืืคcasting ืฉืืื:public class intToDouble {
public static void main(String[] args) {
double a = 1; //you can also write 1.0 here. If you print it out it will be 1.0
int b = 5, x = 7;
System.out.println(x + 0.0);
System.out.println(a*b);
}
}
ืืคืื ืืื:
7.0 5.0
ืืื, ืืชื ืืืื ืืืืืจ ืืืคืื ืื ืจืง ื-int, ืืื ืืื ืืืืคืืกืื ืืคืจืืืืืืืืื ืืืกืคืจืืื. ืืืื ืกืืจ ืืืืจื ืืืคืฉืจื ืืืงืื ืืืืื ืืืืชืจ:
Byte -> Short -> Char -> Int -> Long -> Float -> Double
ืงืจืืื ื ืืกืคืช: |
---|
GO TO FULL VERSION