ืฉืคืช Java ืืฆืืืืช ืืกืคืจืืื ืืงืืคื ืืคืื ืงืฆืืืช ืืคืขืืืืช ืืชืืืืืช. ืื ื ืงืจื ืืืืืงื "Math", ืืืื ื ืืฆื ืืืืืืช java.lang . ืกืคืจืืืช ืืืชืืืืงื ืืืืืช ืฉืืืืช ืืคืขืืืืช ืืกืคืจืืืช ืืกืืกืืืช, ืืจืืืื ืืืืจืื, ืืฆืืืช ืืื ืืืื-ืืงืก, ืืฆืืจืช ืืกืคืจืื ืืงืจืืืื ืืคืขืืืืช ืืืืจืืชืืืืช. ืืืืจืื ืฉื ืืืื, ื ืชืืงื ืืฉืืืช Math.pow() ืืืฉืืฉืช ืืืืฉืื ืืืงืืช ืฉื ืืกืคืจืื ืืืืฆืขืืช ืืกืืก ืืืขืจืื. ืืืื ื ืชืืื. ื ืืชื ืืืชืื ืืชืืืืช ืืช ืืืืืื 'ืืืง n' ืฉื a ื- n . ืื ื ืืืืืื ืืืืืืจ ืืช ืืืื ืืื ืืืืืืืื ืืืืงืื. a - base n - ืืขืจืื ืืื ื ืืงื ืืืฉืืื ืืช ืืืขืจืื. ืื ื ืืืืืื ืืืืืช ืืืชื ืืืกืคืจ ืืคืขืืื ืฉืืื ืืืืจืช ืคืขืืืช ืืืคื. ืืืกืืก ืืื ืืืกืคืจ ืฉืืืืคื ืืขืฆืื. ืืื ื ืืฆืืจ ืืขืช ืฉืืืช Java ืคืฉืืื ืืืืฉืื ืืืื ืฉื ืืกืคืจ. ืฉืืื ืื ืฉืืืืืื ืืืื, ืื ื ืืขืืืจืื ืฉื ื ืืจืืืื ืืื ืืืชืืื powerFunction() ืฉืื ืืืกืืก ืืืืขืจืื, ืืืชืืื.
public class Main {
public static void main(String[] args) {
int result = powerFunction(2, 5);
System.out.println("2 raised to the power of 5 = " + result);
}
static int powerFunction(int base, int exponent) {
int result = 1;
for (int i = 0; i < exponent; i++) {
result = base * result;
}
return result;
}
}
ืื ื ืจืืฅ ืืช ืืงืื ืืืืืื ืฉืืืขืื, ืืื ืืืืืจ 32. ืืชื ืืืื ืืืืืื ืืื ืื ืื ื ืื ืืืืืื ืืืชืื base^exponent. ืื ืื ื ืื ืืืืืื ืืขืฉืืช ืืช ืื ืื ื-Java ืืื ืืืคืจืืืจ ืืงืกืคืื ื ืฆืื ืฉืื ืื ื ืืืืืื ืืืฉืชืืฉ ืื ืืฉืืจืช ืงืื ืืืช. ืืืชืืฉื ืืงืื ืืขืื, ืืจืืจ ืฉืืืื ื ืฆืจืืืื ืืืฉืงืืข ืื ืืขื ืืื ืืืชืืืช ืฉืืื ืื. ืืชืจื ืืื, ืื ืื ื ืืชืืืื ืื ืืืฉื ืืกืคืงืื ืืืืืื, ืืฉืืื ืืืงื ืืื ืื ืืืืื ืืื ืืืฉืืื ืืช ืืืืฉืืืื ืืืื ืืืืืื ืฉืื ื ืืฉืชืืฉืื ืืืืืืืช. ืื ืืกืฃ ืืื, ืืืืืืช ืืื ืขื ืืืืชื ื ืืืฆืข ืืืฉืืื ืืกืคืง ืขื ืืงืกืคืื ื ืืื ืฉืืจืื. ืืืฉืืื ืื ืืื ืืืจืืืืช ืืืฉืืืืช ืืืื, ืื ืืื ืืื ื ื ืืื ืืืืืื ืืืืืื ืฉืืฉ ืืืชืจ ืืงืื ืืืืคืืืืืืฆืื. ืืืชืืฉื ืืืืื ืชืืืจืืช ืืงืกืคืื ืฆืื ืืคืขืืืืช ืืชืืืืืช ืืืจืืช ืืฉืืฉืืช ืขื ืืื ืืชืื ืชืื, ืืืื ื ืืคืชืื Java ืืฆืจื ืกืคืจืืื ืืฉื 'ืืชืืืืงื', ืืืืงืืฉืช ืืืงื ืขื ืคืขืืืืช ืืชืืืืืช. ืืื, ืืืงืื ืืืชืื ืคืื ืงืฆืืืช ืืื ืืืคืก, ื ืืื ืื ืฆื ืืช ืืกืคืจืืื ืืื ืืืืืื ืืืืืืช Java Lang.
ืืื ืฉืืืช Math.pow ืืืืฆื ืื ื ืืฉืชืืฉืื ืื?
ื ืืชื ืืืฆืื ืืช Math.pow ืืืืืืช java.lang ืืฉืืื ืฉื โโืกืคืจืืืช Math. ืืื ืืฉืืฉ ืืืืฉืื ืืืื ืฉื ืืกืคืจืื, ืื ืืกืคืจืื ืฉืืืื ืืื ืืคืืืื. ืืืื ื ืฉืงืื ืืช ืืชืืืืจ ืฉืื.public static double pow(double base, double exponent)
ืืคื ืฉืื ื ืืืืืื ืืจืืืช ืืชืืืืจ, ืฉืืืช java.lang.Math.pow() ืืืงืืช ืฉื ื ืืจืืืื ืืื. ืืจืืฉืื ืืื ืืืกืืก ืืืฉื ื ืืื ืืืขืจืื. ืื ืืืืืจ ืืขืจืื ืืกืืก ืืชืืจ ืืคืื ืฉืื. ืืื ื ืจืื ืืื ืื ืื ื ืืืืืื ืืงืจืื ืืื.
ืืขืืืช ืืกืคืจ ืืขืืฆืื ื-Java ืืืืฆืขืืช Math.pow
ืืื ื ืืฆื ืืช ืืขืจื ืฉื 5 4 ืืืืฆืขืืช Math.pow .import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(5, 4);
// java.lang.Math.pow() method
System.out.println("5 raised to the power of 4 = " + answer);
}
}
ืืคืื ืืื 625.0. ืืคื ืฉืืชื ืืืื ืืจืืืช, ืื ืขืจื ืืคืื. ืื ืื ืงืืื ืืขืฉืจืื ืืช ืืืจืืื ืืืชื, ื ืืื ืืืืคืืจ ืืื ื ืืงืืืช ืขื ืืื ืืืืช ืืืกืคืจ ืืืกืคืจ ืฉืื ืืืืคื ืืื. ืฉืืื ืื ืฉืื ื ืืฉื ืื ืืช ืืฉืืจื ืืจืืฉืื ื ืืชืื ืืฉืืื ืืจืืฉืืช.
int answer = (int) Math.pow(5, 4);
ืืขืช ืืชืืฆืื ืืื 625. ืืื ื ืฉืชืืฉ ืืืกืคืจืื ืฉืืจืื ืื ืืืกืืก ืืื ืืืขืจืื ืื ื ืกื ืืงืื ืชืฉืืื. ืืื ื ืจืื ืื ืืขืจื ืฉื 1.25 4.5 .
import java.lang.Math;
public class MyClass {
public static void main(String[] args) {
double answer = Math.pow(1.25, 4.5);
// java.lang.Math.pow() method
System.out.println("1.25 raised to the power of 4.5 = " + answer);
}
}
ืื ืืืฆืื 2.729575167846423. ืื ืืชื ืืฉืชืืฉ ืืืืฉืืื, ืชืจืื ืฉืืื ืืืืืจ ืืช ืืืชื ืชืฉืืื. ืืืื ื ืขืืืจ ืขื ืืืืื ื ืืกืคืช ืืคื ื ืฉื ืขืืืจ ืืกืขืืฃ ืืื. ื ืขืื ืืกืคืจ ืืืืงื ืฉืืืืืช ืื ืฉืืื ืืช ืืชืืฆืืืช. ืขืืืจ ืืืืื ืื, ื ืืืจ 4 ืืืกืืก ื-2 ืืืขืจืื.
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(4, -2);
// java.lang.Math.pow() method
System.out.println(answer);
}
}
ืื ื ืืงืืืื ืืช ืืคืื 0.0625.
ืืืืื ืืืืจื: ืืื ืืขืื ืืช ืืชืฉืืื ืฉืื
ื ืืื, ืื ืื ื ืฆืจืืืื ืืืฆืื ืืช ืืขืจื ืฉื 1.25 4.5 . ืืชืฉืืื ืืื 2.729575167846423. ืืขืชืื ืงืจืืืืช ืืฉ ืฆืืจื ืืขืื ืืช ืืชืืฆืื. ืืืื ื ื ืกื ืืงืื ืชืฉืืื ืืืืืงืช ืืืงืื ืืขืฉืจืื ื ืืจืืืขื. ืืื ืืขืฉืืช ืืช ืื? ืื ืื ื ืืจืืฉ ืจืง ืืช 4 ืืืงืืืืช ืืขืฉืจืื ืืื ืืจืืฉืื ืื? ืื ืื ื ืืืืืื ืืืฉืชืืฉ ืืฉืืืช java.lang.Math.round ืืฉืืื ืื. ืขื ืืืช, ืืืฉืจ Math.round ืืขืื ืืช ืืขืจื ืืืกืคืจ ืืฉืื ืืงืจืื ืืืืชืจ, ื ืฆืืจื ืืืืคืื ืืืชื ืืืกืคืจ ืืืงืืืืช ืืขืฉืจืื ืืื ืืืืืจ ืืื ืืขืื ืืืืืง ืฉืื.import java.lang.Math;
public class MyClass{
public static void main(String []args){
double answer = Math.pow(1.25, 4.5);
answer = Math.round(answer*100.0)/100.0;
System.out.println(answer);
}
}
ืืคืื ืืื 2.73.
ืืืฆื ืืืฉืชืืฉ ืืจืืื ื- Math.pow
ืืืฉืจ ืื ื ืืฉืชืืฉืื ืืฉืืืช java.lang.Math.pow , ืืฉ ืืื ืืืจืื ืฉืืืื ืืืืืจ.- ืื ืคืจืืืจ ืืืขืจืื ืืื ืืคืก, ืืคืื ืืืื 1.0. ืืกืืื ืืื ืืื ืฉืืืืงื ืฉื ืืคืก ืขืืืจ ืื ืืกืคืจ ืืืืืจืช ืืืื.
- ืื ืืคืจืืืจ ืืืขืจืื ืืื ืืื, ืืคืื ืืืื ืคืจืืืจ ืืืกืืก. ืืกืืื ืืื ืืื ืฉืื ืืขืืื ืืกืคืจ ืืืฉืื ืืืืงืช 1, ืืชืืฆืื ืืื ืืืกืืก.
- ืื ืืืกืืก ืืื ืืคืก ืฉืืืื/ืืืืื ืืืคืจืืืจ ืืืขืจืื ืืื ืืกืคืจ ืฉืืืื, ืืชืืฆืื ืืื ืืื ืกืืฃ. (ืืคืกืื ืฉืืืืืื ืืืืืื ืืืชืจืืฉ ืขืงื ืขืืืื ืืืกืคืจืื ืืื ืืคืก ืืืกืคืจ ืืฉืืืื ืฉืืื ื ืืคืก ืืงืื ืืืืชืจ ืฉื ืืชื ืืืืฆืื).
- ืื ืืคืจืืืจ ืืืขืจืื ืืื NaN, ืืคืื ืืืื ืื NaN.
import java.lang.Math;
public class MyClass{
public static void main(String []args){
double base = 5;
double exponent = Double.NaN;
double answer = Math.pow(base, exponent);
System.out.println(answer);
}
}
ืื ืืืฆืื NaN. ืืื, ืื ืืงืื ืฉืื ืืืืื ื-NaN, ืืืื ืื ืืื ืืืืืง ืื ืืืจืืืื ื ืืืขืจืื ืืื NaN. ืืืงืจื ืฉืืชื ืชืืื ืื ืื NaN, ืื ืืืืจ 'ืื ืืกืคืจ' ืืืฆืืื ืฉืืขืจื ืื ืืืืืจ. ืื ื ืืืืื ืื ืฉืืืืื ืืืื ืื ืืขืช ืืืืฉืื ืืืืื ืืก ืืช lang.Math.pow() ืืฉืืืืฉ ืืืืฉืืืื ืฉืืื.
GO TO FULL VERSION