Question

因此，我试图在一个父类中使用getter / setter方法在一个子类中更改一个变量。但是，价值只是保持不变，我不知道为什么。我在做什么错？任何帮助表示赞赏！

以下是该程序的细目分类：在驱动程序类中，您选择要执行的操作，然后它使用当前值变量和您选择的数字（operand2）获得答案。加，减，乘和除在内存计算器类中。还可以清除，这会将当前值变量设置为零。现在，我们向其中添加一个处理指数和对数的子类。
特性：当我尝试在ScientificMemCalc类中使用power或log方法时，MemoryCalc类中的变量currentValue保持不变。在该类中，它使用getter方法获取当前值，然后尝试使用setter方法更改当前值。但是什么都没有改变。另一个问题是：getter方法从currentValue字段中获取零值。

这是具有主要方法的驱动程序类：

package ScientificMemCalc;

import java.util.Scanner;

import ScientificMemCalc.MemoryCalc;

public class ScientificCalcDriver {

    public static void main(String[] args) {

    Scanner input = new Scanner(System.in);

    MemoryCalc calculator = new MemoryCalc();
    ScientificMemCalc scientificCalc = new ScientificMemCalc();


    int menu = 0;
    double operand2, answer;

    while (menu !=8) {

        answer = calculator.getCurrentValue();
        System.out.println("The current value is: " + answer);  

        menu = getMenuOption();

        switch(menu) {
        case 1:
            // Add
            operand2 = calculator.getOperand("What is the second number?: ");
            calculator.add(operand2);
            break;

        case 2:
            // Subtract
            operand2 = calculator.getOperand("What is the second number?: ");
            calculator.subtract(operand2);
            break;

        case 3:
            // Multiply
            operand2 = calculator.getOperand("What is the second number?: ");
            calculator.multiply(operand2);
            break;

        case 4:
            // Divide
            operand2 = calculator.getOperand("What is the second number?: ");
            calculator.divide(operand2);
            break;

        case 5:
            // Power
            operand2 = calculator.getOperand("What is the second number?: ");
            scientificCalc.power(operand2);
            break;

        case 6:
            // Logarithm
            scientificCalc.log();
            break;

        case 7:
            // Clear
            operand2 = 0;
            calculator.clear();
            break;

        case 8:
            // Quit
            System.out.println("Goodbye!");
            break;
        }
    }
}

public static int getMenuOption() {

    Scanner input = new Scanner(System.in); 

    int choice = 0;

    // Display menu
    System.out.println("Menu:");
    System.out.println("1. Add");
    System.out.println("2. Subtract");
    System.out.println("3. Multiply");
    System.out.println("4. Divide");
    System.out.println("5. Power");
    System.out.println("6. Logarithm");
    System.out.println("7. Clear");
    System.out.println("8. Quit");

    // Get menu input
    System.out.print("What would you like to do?: ");
    choice = input.nextInt();

    while (choice < 1 || choice > 8) {
        System.out.print("Invalid. Try again: ");
        choice = input.nextInt();
    }

    return choice;
    }
}

这是内存计算器类：

package ScientificMemCalc;

import java.util.Scanner;

public class MemoryCalc {

private double currentValue;

public double getOperand(String prompt) {

    Scanner input = new Scanner(System.in);

    System.out.print(prompt);
    return input.nextDouble();

}
public double getCurrentValue() {
    return currentValue;
}
public void setCurrentValue(double temp) {
    currentValue = temp;
}
public void add(double operand2) {
    // Add
    currentValue += operand2;
}
public void subtract(double operand2) {
    // Subtract
    currentValue -= operand2;
}
public void multiply(double operand2) {
    // Multiply
    currentValue *= operand2;
}
public void divide(double operand2) {
    // Divide
    if (operand2 == 0) {
        System.out.println("You cannot divide by zero!");
        currentValue = Double.NaN;
    }
    else {
        currentValue /= operand2;
    }
}
public void clear() {
    // Clear
    currentValue = 0;

    }
}

最后是添加科学功能的子类：

package ScientificMemCalc;

public class ScientificMemCalc extends MemoryCalc {

public void power(double operand2) {
    // Power
    double currentValue = getCurrentValue();
    double temp = Math.pow(currentValue, operand2);
    setCurrentValue(temp);
}
public void log() {
    // Logarithm
    double currentValue = getCurrentValue();
    double temp = Math.log(currentValue);
    setCurrentValue(temp);
    }

}

Answer 1

在ScientificMemCalc类中，您扩展MemoryCalc，这使ScientificMemCalc可以调用MemoryCalc中创建的方法，并提供对MemoryCalc中自己的变量集的访问。但是，在为每个类创建两个单独的对象时，它们都可以访问相同名称和类型的变量，但是在两个单独的对象中它们将是两个单独的变量。

一种解决方案是将MemoryCalc对象传递到ScientificMemCalc类的构造函数中，然后针对该对象调用getCurrentValue（）/ setCurrentValue（）方法。允许访问相同的变量。

package scientificMemCalc;

public class ScientificMemCalc {

    //store the MemoryCalc object so we have access to the needed data
    private MemoryCalc memCalc;

    //store the MemoryCalc
    public ScientificMemCalc(MemoryCalc memCalc) {
        this.memCalc = memCalc;
    }

    public void power(double operand2) {

        // Power
        double currentValue = memCalc.getCurrentValue();
        double temp = Math.pow(currentValue, operand2);
        memCalc.setCurrentValue(temp);

    }

    public void log() {

        // Logarithm
        double currentValue = memCalc.getCurrentValue();
        double temp = Math.log(currentValue);
        memCalc.setCurrentValue(temp);

    }

}

然后，在实例化ScientificMemCalc对象时，将其传递给MemoryCalc的引用。

MemoryCalc calculator = new MemoryCalc();
ScientificMemCalc scientificCalc = new ScientificMemCalc(calculator);

希望这会有所帮助！

Answer 2

简短答案

您正在与两个不同的对象calculator和scientificCalc进行交互。他们没有任何状态。

您能做什么？

使用scientificCalc进行所有计算。因此，该值将是一个且只有一个。

缺点：一旦引入其他计算器类型，事情就会变得更加复杂

将calculator作为构造参数传递给ScientificMemCalc的构造函数。

缺点：与＃1相同

使用单独的类/对象存储状态。（由@ user2864740建议）

请勿将状态存储在计算器内（为什么需要它？）。将所有操作数（当前状态始终是操作数＃1）传递给方法，并将结果返回给调用方：

int menu = 0;
double operand2, answer;
while (menu !=8) {

    // You don't need this line
    //answer = calculator.getCurrentValue();

    System.out.println("The current value is: " + answer);  

    menu = getMenuOption();

    switch(menu) {
    case 1:
        // Add
        operand2 = calculator.getOperand("What is the second number?: ");
        // 
        answer = calculator.add(answer, operand2);
        break;
        //... modify other operations in the same way
}

Java-父类中的字段不变

2 个答案: