java求x的y次方

Ⅰ java中怎样怎样算出求函数的幂次方

java中通常进行数学运算的东西都在Math类中，求函数的幂次方就是Math类中的pow方法：public static double pow(doublea,doubleb)，返回第一个参数的第二个参数次幂的值。

例如求2的3次方，代码如下：

public class test {

public static void main(String[] args) {

double a= Math.pow(2, 3);

}

}

运行结果为8

(1)java求x的y次方扩展阅读：

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

与 StrictMath 类的某些数学方法不同，并非 Math 类所有等价函数的实现都定义为返回逐位相同的结果。此类在不需要严格重复的地方可以得到更好的执行。

默认情况下，很多 Math 方法仅调用 StrictMath 中的等价方法来完成它们的实现。建议代码生成器使用特定于平台的本机库或者微处理器指令（可用时）来提供 Math 方法更高性能的实现。这种更高性能的实现仍然必须遵守 Math 的规范。

实现规范的质量涉及到两种属性，即返回结果的准确性和方法的单调性。浮点 Math 方法的准确性根据 ulp（units in the last place，最后一位的进退位）来衡量。对于给定的浮点格式，特定实数值的 ulp 是包括该数值的两个浮点值的差。当作为一个整体而不是针对具体参数讨论方法的准确性时，引入的 ulp 数用于任何参数最差情况下的误差。

如果一个方法的误差总是小于 0.5 ulp，那么该方法始终返回最接近准确结果的浮点数；这种方法就是正确舍入。一个正确舍入的方法通常能得到最佳的浮点近似值；然而，对于许多浮点方法，进行正确舍入有些不切实际。

相反，对于Math 类，某些方法允许误差在 1 或 2 ulp 的范围内。非正式地，对于 1 ulp的误差范围，当准确结果是可表示的数值时，应该按照计算结果返回准确结果；否则，返回包括准确结果的两个浮点值中的一个。对于值很大的准确结果，括号的一端可以是无穷大。除了个别参数的准确性之外，维护不同参数的方法之间的正确关系也很重要。

因此，大多数误差大于 0.5 ulp 的方法都要求是半单调的：只要数学函数是非递减的，浮点近似值就是非递减的；同样，只要数学函数是非递增的，浮点近似值就是非递增的。并非所有准确性为 1
ulp 的近似值都能自动满足单调性要求。

Oracle官方API接口-Java™ Platform, Standard Edition 7 API Specification

Ⅱ 用java语言：编程输入两个数整数想x，y，求x的y次幂。

Math.Pow(x,y)不是整数也支持

Ⅲ Java 用递归求x的n次方 输入参数

importjava.util.Scanner;


publicclassTest{
	publicstaticvoidmain(String[]args){
		Scannersc=newScanner(System.in);
		System.out.println("输入x：");
		intx=sc.nextInt();
		System.out.println("输入n：");
		intn=sc.nextInt();
		System.out.println(function(x,n));
		
	}
	publicstaticintfunction(intx,intn){
		if(n>0){
			returnx*function(x,n-1);
		}
		return1;
	}
}

Ⅳ java 问题 math.pow(x，y)不是x的y次方吗 为什么算圆的面积这么写呢谢谢

3.14159*Math.pow(radius,2);

Ⅳ 求JAVA编写的计算器，用AWT编写，且可以算x的y次方，x开y次根号

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class Counter extends WindowAdapter
{
static JFrame f=new JFrame("计算器");
static JTextField text1=new JTextField("0.");
static String source="";
static String cal="";
static String object="";
static boolean flag=false;
static boolean flag1=true;
static boolean flag2=false;
public void init()
{
try
{
Container c=f.getContentPane();
JPanel pan1=new JPanel();
JButton b1=new JButton("1");
JButton b2=new JButton("2");
JButton b3=new JButton("3");
JButton b4=new JButton("4");
JButton b5=new JButton("5");
JButton b6=new JButton("6");
JButton b7=new JButton("7");
JButton b8=new JButton("8");
JButton b9=new JButton("9");
JButton b0=new JButton("0");
JButton b11=new JButton("+");
JButton b12=new JButton("-");
JButton b13=new JButton("*");
JButton b14=new JButton("/");
JButton b15=new JButton(".");
JButton b16=new JButton("=");
JButton bclar=new JButton("清零");
text1.setHorizontalAlignment(JTextField.RIGHT);
c.add(text1,"North");
c.add(pan1);
A aa=new A();
Result re=new Result();
Opertion op=new Opertion();
Clar cl=new Clar();
b1.addActionListener(aa);
b2.addActionListener(aa);
b3.addActionListener(aa);
b4.addActionListener(aa);
b5.addActionListener(aa);
b6.addActionListener(aa);
b7.addActionListener(aa);
b8.addActionListener(aa);
b9.addActionListener(aa);
b0.addActionListener(aa);
b11.addActionListener(op);
b12.addActionListener(op);
b13.addActionListener(op);
b14.addActionListener(op);
b16.addActionListener(re);
b15.addActionListener(aa);
bclar.addActionListener(cl);
pan1.add(b1);
pan1.add(b2);
pan1.add(b3);
pan1.add(b11);
pan1.add(b4);
pan1.add(b5);
pan1.add(b6);
pan1.add(b12);
pan1.add(b7);
pan1.add(b8);
pan1.add(b9);
pan1.add(b13);
pan1.add(b0);
pan1.add(b15);
pan1.add(b16);
pan1.add(b14);
pan1.add(bclar);
f.setSize(200,220);
f.setVisible(true);
}
catch(Exception e)
{
System.out.println(e.getMessage());
}

}
class A implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
String a=text1.getText();
String s=e.getActionCommand();
if(a.equals("0.")||a.equals("+")||a.equals("-")||a.equals("*")||a.equals("/"))
text1.setText(s);
else {
if(flag2)
{
text1.setText(s);
flag2=false;
}
else
text1.setText(a+s);

}
}
}
class Opertion implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
cal=e.getActionCommand();
if(flag1==true)
source=text1.getText();
text1.setText(cal);
flag1=false;
flag=true;
}
}
class Result implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
double num1;
num1=Double.parseDouble(source);
object=text1.getText();
double num2;
num2=Double.parseDouble(object);
double result=0;
if(cal.equals("+"))
result=num1+num2;
if(cal.equals("-"))
result=num1-num2;
if(cal.equals("*"))
result=num1*num2;
if(cal.equals("/"))
if(num2==0)
text1.setText("除数不能为0");
else
result=num1/num2;
String s1=Double.toString(result);
text1.setText(s1);
flag1=true;
flag2=true;
}
}
class Clar implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
text1.setText("0.");
}
}

public static void main(String[] args)
{
Counter count=new Counter();
count.init();
}

public void windowClosing(WindowEvent e){
System.exit(1);
}
public void windowOpened(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
}

Ⅵ java：编写程序，求x的y次方，x为double型，y为int型

例如：
double x=1.2;
int y=2;
System.out.println(Math.pow(x, y));
返回值是double型的

其实这个查下API就可以知道的

Ⅶ java里如何写x乘y的n次方

使用Math.pow方法

Math.pow(x*y,n);//表示x乘以y后的n次方

补充：
1、定义
1）public static double pow(double a, double b)

Math.pow() 方法包含两个参数。这两个参数包括底数和指数
2）参数
a -- 底数.
b -- 指数
3）返回值
此方法返回 ab.

Ⅷ java 例如y的n次幂等于x，在知道x和y情况下如何求n

package com.demo;

public class demo {

public static void main(String[] args) {
System.out.println(new demo().getLog(100, 10));
}

public double getLog(double x,double y)
{
return Math.log(x)/Math.log(y);
}

}

Ⅸ 麻烦哪位JAVA编程高手帮我看看，这个计算器中的X的Y次方怎么做 怎么把科学和标准型分开 ，选择

仅供参考。

Ⅹ 编写java循环程序，从键盘输入一个双精度数x和一个整数y，使用循环语句，求x的y次方

double result =0;
double x= 0;
for(int i=1;i<=y)
{
result = result*x;
}