Question

这是我在第一堂课中的代码：

public class Factorial {
public void Sequence(){
    String value = JOptionPane.showInputDialog("Please enter the number of which you want your shit.");
    System.out.println("Factorial:");
    System.out.println(fact(Integer.valueOf(value)));
    getValues(Integer.valueOf(value));
}

public static int getValues(int n){
    return n;
}

这是Factorial的一个子类：

public class Fibonacci extends Factorial {
    public void Sequence(){
        Factorial get = new Factorial();
                //not working EDIT: Just realized this obv wont work, but still need help to get it to work
        get.getValues(n);

但是我无法从Factorial类

获取getValues中返回的值

Answer 1

此处（下方）value用于存储用户输入

public class Factorial {
public String value;
public void sequence(){
    value = JOptionPane.showInputDialog("Please enter the number of which you want your shit.");
    System.out.println("Factorial:");
    System.out.println(fact(Integer.valueOf(value)));
    getValues(Integer.valueOf(value));
}

public static int getValues(int n){
    return n;
}
public String getValue(){return value;}
}

public class Fibonacci extends Factorial {
    //Method sequence is overridden here
    public void sequence(){
//can use getValue() here or anywhere...there is no need to use a separate object due to inheritance
}
}

Answer 2

多态性在这里并不是一个糟糕的抽象，但是没有办法“帮助你修复你正在做的事情”。有一些明显的原因，多态性不会像你试图使用它那样起作用。正如我所提到的，其中一个是静态方法无法覆盖，因此getValue只能返回输入数字。另一个原因是你在子类中创建一个超类的实例，并且从不这是必要的原因。您还可以继续在所述超类实例上调用静态方法，这也是不必要的。

所以缺点是，当你来到这里询问有关变量n的编译器错误的问题时，你的代码表明你已经领先于自己了。如果你想学习多态，你应该start with a tutorial。您在评论中所说的内容 - “希望n（用户输入）的值在多个类中使用” - 您在OP中的代码不会帮助您实现这一点，因为它的基本错误是多态设计。我并不是说这是一种侮辱，它只是，你应该重新开始。

这是一个更典型的设计，您可以将其用作指南：

public class Main {
    public static void main(String[] args) {
        String input = JOptionPane.showInputDialog("Enter a number:");
        int n = Integer.parseInt(input);

        System.out.println(new Factorial().getResult(n));
    }
}

public interface Sequence {
    public int getResult(int n);
}

public class Factorial
implements Sequence {
    @Override
    public int getResult(int n) {
        int result = n;
        while(n > 1) {
            n--;
            result *= n;
        }

        return result;
    }
}

Fibonacci在这方面也没有真正的面向对象的原因来扩展Factorial。

如果你真的想要包含使用Sequence类检索输入，你可以像这样做：

public abstract class Sequence {
    private static int getInput() { // static because it relies on no state
        return Integer.parseInt(
            JOptionPane.showInputDialog("Enter a number:")
        );
    }

    public final int getResultFromInput() { // simply calls getInput and getResult
        return getResult(getInput());       // sub classes will not need to do
    }                                       // anything with this method

    public abstract int getResult(int n);   // sub classes override this method
}                                           // to provide their functionality

public class Factorial
extends Sequence {
    @Override
    public int getResult(int n) {

        // same as above factorial

    }
}

然后你可以这样做：

System.out.println(new Factorial().getResultFromInput());

我认为，对于一个数字序列对象来说，执行诸如显示对话框之类的事情并不是真正的OOP正确，但是没有理由你不能做它。

另外，作为次要的注意事项，你应该使用long而不是int。使用int（在12！之后）因子会很快溢出。不知道你究竟何时从斐波那契序列中溢出，当然不会像阶乘一样。

从超类中获取返回整数值

2 个答案: