用java写一个OOP

Question

我的教授希望我用 Java 编写一个面向对象的程序，它可以解决一些二次方程的次数与定义的 args[0] 一样多，例如 computer-:Desktop User$ java program_name 3 将迭代程序 3 次。（我希望这很清楚够了）。

除了“面向对象的程序”之外，我什么都写好了，我不知道如何使它面向对象，说明并没有给我留下太多的工作空间（除了使用构造函数方法）。

我一直在尝试这样做：

public class assignment {
assignment(double method_inp){
    double coeff = method_inp;
}
public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    int input_number = Integer.parseInt(args[0]);

    if (input_number > 0) {
        for (int i = 0; i < input_number; i++) {

            // isn't this object oriented?
            assignment a = new assignment(readCoeff(input));
            assignment b = new assignment(readCoeff(input));
            assignment c = new assignment(readCoeff(input)); 

(readCoeff(input) 只是转到扫描仪并让用户输入值。 但似乎我不能使用a、b 和c 作为变量。也不会将它们转换为变量，因为它们不能转换为双精度。我能做些什么？有没有更好的方法让我的程序面向对象？

编辑：我不能使用全局变量

编辑：readCoeff(input) 的内容是：

static double readCoeff(Scanner inn) {
    System.out.print("Please enter coefficient of a quadratic equation: ");
    return inn.nextDouble();

Answer 1

任何时候你使用静态这个词，你都“一般”不在 OOP 模型中。

为什么？

因为静态将状态（在设计意义上）从对象上下文提升到模块上下文。您的所有编程都在静态方法中进行（求解器除外）。

这是我喜欢做的事

public class Program
{
  public static void main(String[] args) {
     Parser p = new MyCommandlineParser();
     Options op = p.Parse(args);

     Solver solver = new Solver();
     s.SolveVariables(op.getTimesToSolve());
     System.out.println("Done.  OOP is about design not programming");
  }
}

从设计开始，然后编程；

Answer 2

通过强制 OOP 来做一些可以在没有对象的情况下更有效、更干净地完成的事情有点迟钝。但是，有这样的老师（我也知道一些）。所以，这就是我的做法：

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int inputNumber = Integer.parseInt(args[0]);

        if (inputNumber > 0) {
            for (int i = 0; i < inputNumber; i++) {
                int[] coefficients;
                //read coefficients into the array
                QuadraticEquation equation = new QuadraticEquation(coefficients);
                System.out.println(equation.solve());
            }
        }
    }
}


class QuadraticEquation {
    private int[] coefficients;

    QuadraticEquation(int[] coefficients) {
        this.coefficients = coefficients;
    }

    double solve() {
        //solve the equation using coefficients and return the result
    }
}

如果需要，将变量/字段名称替换为更合理的名称。此外，类名应始终为大写。编译器不会抱怨，但这是一个被广泛接受的约定。

现在，在上面的代码中实际发生的是我们定义了一个名为QuadraticEquation 的类，它由它的系数定义，我们将它们传递给构造函数。现在，当对象拥有所有必要的信息时，我们可以在其上调用solve() 来实际做某事，即。 e.给我们结果，我们打印出来（您也可以将所有结果保存在一个数组中并在最后打印出来）。

还要注意我们有两个类。您可以将所有内容合二为一，但我认为您不应该这样做。每个类都应该代表一个可以独立工作的对象（Main 类从这个角度看实际上毫无意义；它只是为了防止main(String[]) 污染其他东西）。

理想情况下，您应该创建一个名为 QuadraticEquation 的单独文件，将 class QuadraticEquation 更改为 public class QuadraticEquation 并在构造函数和方法前加上 public 以使它们可以在任何地方使用，因为它们不与任何特定的东西相关联.我想让事情变得简单，并将所有内容都转储到一个地方，并且因为一个文件中不能有两个公共类，另一个必须是包保护的（默认可见性级别）。

Answer 3

使用单独的类表示您的Equations（二次）。在类中定义要对操作执行的操作定义。将使用 Equation 的实例访问这些操作。

主类assignment 将接受方程式的数量并在方程式数组中创建实例。

import java.util.Scanner;

class Equation {
  double a, b, c;
  Equation(double a, double b, double c) {
    this.a = a;
    this.b = b;
    this.c = c;
  }
  // Perform the operation on equation using specific methods.
}

public class assignment {

  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    int input_number = Integer.parseInt(args[0]);
    Equation objects[];
    double inputA, inputB, inputC;
    if (input_number > 0) {
      objects = new Equation[input_number];
      for (int i = 0; i < input_number; i++) {
        inputA = readCoeff(input);
        inputB = readCoeff(input);
        inputC= readCoeff(input);
        objects[i] = new Equation(inputA, inputB, inputC);
      }
    }
  }
  static double readCoeff(Scanner inn) {
    System.out.print("Please enter coefficient of a quadratic equation: ");
    return inn.nextDouble();
  }
}

Answer 4

import java.util.Scanner;

/**
 * Created by EpicPandaForce on 2015.09.20..
 */
public class Main {
    public static void main(String[] args) {
        int iterationCount;
        if (args.length > 0) {
            iterationCount = Integer.parseInt(args[0]);
        } else {
            iterationCount = 1;
        }
        new Main().execute(iterationCount);
    }

    private Scanner scanner;

    public Main() {
        scanner = new Scanner(System.in);
    }

    public void askForCoefficientInput() {
        System.out.println("Please enter the three coefficients");
    }

    public double readCoefficient() {
        return scanner.nextDouble();
    }

    public void execute(int iterationCount) {
        double inputA, inputB, inputC;
        if (iterationCount > 0) {
            for (int i = 0; i < iterationCount; i++) {
                askForCoefficientInput();
                inputA = readCoefficient();
                inputB = readCoefficient();
                inputC = readCoefficient();
                Equation equation = new Equation(inputA, inputB, inputC);
                equation.printResults();
            }
        }
    }

    public static class Equation {
        private double a;
        private double b;
        private double c;

        private double result1;
        private double result2;
        private boolean hasResult;

        public Equation(double a, double b, double c) {
            this.a = a;
            this.b = b;
            this.c = c;
            calculate();
        }

        protected final void calculate() {
            if (a != 0) {
                if ((b * b - 4 * a * c) >= 0) {
                    this.result1 = ((-1) * b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);
                    this.result2 = ((-1) * b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);
                    this.hasResult = true;
                }
            } else {
                if (b != 0) {
                    this.result1 = ((-1) * c) / b;
                    this.result2 = ((-1) * c) / b;
                    this.hasResult = true;
                } else {
                    if (c == 0) {
                        this.result1 = 0;
                        this.result2 = 0;
                        this.hasResult = true;
                    }
                }
            }
        }

        public void printResults() {
            System.out.println(
                    "The equation [" + a + "x^2 " + (b >= 0 ? "+" + b : b) + "x " + (c >= 0 ? "+" + c : c) + "] had " + (this.hasResult() ? "" : "no ") + "results" + (this.hasResult() ? ", these are: [" + this
                            .getFirstResult() + "] and [" + this.getSecondResult() + "]." : "." + "\n"));
        }

        public double getFirstResult() {
            return this.result1;
        }

        public double getSecondResult() {
            return this.result2;
        }

        public boolean hasResult() {
            return this.hasResult;
        }
    }
}

结果：

>> Executing quadratic.Main

Please enter the three coefficients
1 -8 12
The equation [1.0x^2 -8.0x +12.0] had results, these are: [6.0] and [2.0].

Please enter the three coefficients
3 8 12
The equation [3.0x^2 +8.0x +12.0] had no results.

Process finished with exit code 0