Java：如何将两个变量设置为相同的值，然后更改其中一个而不更改另一个？

我正在尝试创建一个递归方法来计算指数。我使用构造函数将

product

设置为等于

base

。问题是，当我执行我的

power

方法时，每次

product

都被

base

方法操作为相同的值

   public Power (double base, double exponent) {  //constructor
          this.base = base;
          this.exponent = exponent;
          product = base;
   }

   public void setBase(double base) {  //set base variable, set product equal to base
       this.base = base;
       product = base;
   }

   public double power(double base, double exponent) {  //calculates base^exponent = product
       if(exponent == 1) {
           return product;
       }
       product = product * base;
       return power( product,  (exponent - 1 ) );
   }

}

---

因此，2^3=16。这是不正确的。预期结果应为2^3=8。有没有办法在

幂

方法之前将

产品

的值设置为等于

基

，并防止它们在递归方法期间一起更改值？

您的实现混合了字段和方法参数，隐藏了

指数

变量，这使得代码难以读取。递归方法不需要字段，因为它使用堆栈从嵌套函数调用传递值

问题出在

power（base*base，exp-1）

逻辑中，因为您正在平方运算。对2^3的第一次调用递归调用将执行

power（2*2，3-1）

，然后

power（4*4，2-1）

，然后返回

16

应该是：

public int power(int base, int exponent) {
    if (exponent == 0) {
        return 1;
    }
    if (exponent == 1) {
        return base;
    }
    return base * power(base, exponent - 1);
}

---

您的实现混合了字段和方法参数，隐藏了

指数

变量，这使得代码很难读取。递归方法不需要字段，因为它使用堆栈从嵌套函数调用传递值

问题出在

power（base*base，exp-1）

逻辑中，因为您正在平方运算。对2^3的第一次调用递归调用将执行

power（2*2，3-1）

，然后

power（4*4，2-1）

，然后返回

16

应该是：

public int power(int base, int exponent) {
    if (exponent == 0) {
        return 1;
    }
    if (exponent == 1) {
        return base;
    }
    return base * power(base, exponent - 1);
}

---

您当前的设计可能导致类状态不一致。您可以多次调用

setBase（）

或

power（）

，然后将

base

、

exponent

和

product

作为一个整体来考虑，它们毫无意义

我会让你只把

base

和

exponent

传递给构造函数，然后它们是只读的。递归方法只能从构造函数调用一次。然后，将使用getter方法检索这三个值，以便在事件发生后不能更改它们

比如：

public class Power
{

    public static void main(String[] args)
    {
        Power p1 = new Power(2, 3);
        Power p2 = new Power(3, 4);
        Power p3 = new Power(5, 2);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
    }

    private int base;
    private int exponent;
    private int product;

    private Power() {}

    public Power (int base, int exponent) {  
        this.base = base;
        this.exponent = exponent;
        this.product = power(base, exponent);
    }

    private int power(int base, int exponent) { 
        return (exponent == 0) ? 1 : base * power(base, --exponent);
    }

    public String toString()
    {
        return base + "^" + exponent + " = " + product;
    }

    private double getBase()
    {
       return base;
    }

    private double getExponent()
    {
       return exponent;
    }

    private double getProduct()
    {
       return product;
    }

}

输出：

2^3 = 8
3^4 = 81
5^2 = 25

---

您当前的设计可能导致类状态不一致。您可以多次调用

setBase（）

或

power（）

，然后将

base

、

exponent

和

product

作为一个整体来考虑，它们毫无意义

我会让你只把

base

和

exponent

传递给构造函数，然后它们是只读的。递归方法只能从构造函数调用一次。然后，将使用getter方法检索这三个值，以便在事件发生后不能更改它们

比如：

public class Power
{

    public static void main(String[] args)
    {
        Power p1 = new Power(2, 3);
        Power p2 = new Power(3, 4);
        Power p3 = new Power(5, 2);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
    }

    private int base;
    private int exponent;
    private int product;

    private Power() {}

    public Power (int base, int exponent) {  
        this.base = base;
        this.exponent = exponent;
        this.product = power(base, exponent);
    }

    private int power(int base, int exponent) { 
        return (exponent == 0) ? 1 : base * power(base, --exponent);
    }

    public String toString()
    {
        return base + "^" + exponent + " = " + product;
    }

    private double getBase()
    {
       return base;
    }

    private double getExponent()
    {
       return exponent;
    }

    private double getProduct()
    {
       return product;
    }

}

输出：

2^3 = 8
3^4 = 81
5^2 = 25

---

您需要将指数设置为整数。现在您可以将其设置为1.1，它将永远不会结束。您需要将指数设置为整数。现在您可以将其设置为1.1，它将永远不会完成