Java分数计算器

我对Java编程非常陌生，我的AP计算机编程课有一个作业要交，请耐心听我说。我得想办法把两个分数相乘。我想知道是否有任何方法可以在方法内部声明一个变量，并在该方法外部使用它（intro方法中的while循环）。谢谢你，希望这不会让人困惑

import java.util.Scanner;
import java.util.StringTokenizer;

public class javatest3 {
    static int num1 = 0;
    static int num2 = 0;
    static int denom1 = 0;
    static int denom2 = 0;
    public static void main(String[] args){
    System.out.println("Enter an expression (or \"quit\"): "); //prompts user for input
    intro();

}
public static void intro(){
    Scanner input = new Scanner(System.in); 
    String user= input.nextLine();
    while (!user.equals("quit") & input.hasNextLine()){ //processes code when user input does not equal quit
        StringTokenizer chunks = new StringTokenizer(user, " "); //parses by white space
        String fraction1 = chunks.nextToken(); //first fraction
        String operand = chunks.nextToken(); //operator 
        String fraction2 = chunks.nextToken(); //second fraction
        System.out.println("Fraction 1: " + fraction1); 
        System.out.println("Operation: " + operand); 
        System.out.println("Fraction 2: " + fraction2); 
        System.out.println("Enter an expression (or \"quit\"): "); //prompts user for more input


    while (user.contains("*")){
        parse(fraction1);
        parse(fraction2);
        System.out.println("hi");
        int num = num1 * num2;
        int denom = denom1 * denom2;
        System.out.println(num + "/" + denom);
        user = input.next();

    }

    }
}

public static void parse(String fraction) {
    if (fraction.contains("_")){
        StringTokenizer mixed = new StringTokenizer(fraction, "_");
        int wholeNumber = Integer.parseInt(mixed.nextToken());
        System.out.println(wholeNumber);
        String frac = mixed.nextToken();
        System.out.println(frac);
        StringTokenizer parseFraction = new StringTokenizer(frac, "/"); //parses by forward slash
        int num = Integer.parseInt(parseFraction.nextToken());  
        System.out.println(num);
        int denom = Integer.parseInt(parseFraction.nextToken());
        System.out.println(denom);




    }
    else if (!fraction.contains("_") && fraction.contains("/")){
        StringTokenizer parseFraction = new StringTokenizer(fraction, "/"); //parses by forward slash
        int num = Integer.parseInt(parseFraction.nextToken());  
        System.out.println(num);
        int denom = Integer.parseInt(parseFraction.nextToken());
        System.out.println(denom);



    }else{ 
        StringTokenizer whiteSpace = new StringTokenizer(fraction, " "); 
        int num = Integer.parseInt(whiteSpace.nextToken());  
        System.out.println(num);
}

---

}}只需在任何方法之外声明变量即可。确保并使变量为静态。然后在方法中初始化。这样，它就可以在该类中的任何方法中使用。这里有一个例子说明你是如何做到这一点的

package testPackage;

public class Test {
    public static int waffle = 5;

    public static void main(String[] args) {
        method1();
        method2();
    }

    public static void method1() {
        System.out.println("Heyy Everyone");
        System.out.println("Waffle is " + waffle); // Print waffle before change
        waffle = waffle + 12 - 4; // Change waffle;
        System.out.println("Method 1 set waffle to " + waffle); // Print waffle after change after 
    }                                                           // change in method2

    public static void method2() {
        System.out.println("Waffle is " + waffle); // Print waffle in method2 after method1's change
        waffle = waffle * 3; // Change waffle
        System.out.println("Waffle is now set to " + waffle);// Print waffle/ after change in method2
    }
}

---

不，变量的作用域将限于您在其中创建它的方法。 如果要在该方法之外使用该变量，则必须在该方法之外声明该变量

---

这里有一个关于的有用资源。

方法内声明的变量被封装为局部变量，不能在方法外使用

如果您想使用

字符串压裂

执行此操作

public class javatest3 {
    static String frac;

    public static void main(String[] args){

        // now you can use frac here
    }

    public static void parse(String fraction) {
        if (fraction.contains("_")){
            ...
            frac = mixed.nextToken();
        }
    }
}

---

假设希望函数parse（）同时返回分子和分母，有几种方法可以实现这一点

OO方法是定义一个包含两个字段（分子和分母）的类，并让parse（）返回此类型的实例

class Fraction {
    public int Numerator = 0;
    public int Denominator = 1;
    public Fraction(int numerator, int denominator) {
        Numerator = numerator;
        Denominator = denominator;
    }
    public static Fraction parse(String fractionString) {
        int num, denom;

        // Your parse code (without the int num and int denom declarations) goes here.

        return new Fraction(num, denom);
    }
}

您的呼叫代码如下所示：

    Fraction f1, f2;
    f1= Fraction.parse(fraction1);
    f2= Fraction.parse(fraction2);
    int num = f1.Numerator * f2.Numerator;
    int denom = f1.Denominator * f2.Denominator;

这个简短的回答是“不”。其他人已经解释了为什么。。。但这里有两种可能的选择。我不知道您是否已经学习了这些概念，但是第一种选择是通过引用传递还是通过值传递，第二种选择是通过面向对象编程

备选方案#1：

您可以在方法外部声明变量，将其传递给方法并使用它，然后该变量在方法外部可用，因为它是在方法外部声明的。我认为一个例子将有助于更清楚地说明这一点：

void foo () {
    Integer a = 1;
    Integer b = 2;
    bar(a,b);
    System.out.println("a = " + a + ", b = " + b);
}

void bar (Integer a, Integer b) {
    a = 4;
    b = 8;
}

结果应该是a=4，b=8。但是，需要注意的是，这是非常重要的，因为

Integer

（不同于

int

）是一个类，所以它的对象是通过引用传递的。如果

a

和

b

只是

int

s，那么它们将按值传递。这意味着

bar（）

将有自己的

a

和

b

副本与

foo（）

分开，并且对

bar（）

中变量的修改不会影响

foo（）

的副本。例如：

void foo () {
    int a = 1;
    int b = 2;
    bar(a,b);
    System.out.println("a = " + a + ", b = " + b);
}

void bar (int a, int b) {
    a = 4;
    b = 8;
}

这将产生结果

a=1，b=2

我真的不喜欢这种方法，因为它很难看，很容易出错，但如果做得正确，它是可能的，也会起作用。另外，如果您没有编写面向对象的代码，您的选择可能是这样，也可能只是不为该部分使用函数（这通常不是好的设计）。虽然这种事情在C语言和C++语言中更为常见。但是这些语言对于按值传递或引用传递更为明确，并且您必须手动操作指针（而Java对程序员隐藏其指针），因此很难混淆什么时候会按值传递或引用传递（尽管更容易犯其他类型的错误）

备选方案2：

如果有选择的话，这将是我的首选，但前提是您已经了解了一些面向对象编程。如果你还没有学会这一点，我会选择另一种方法（但如果你好奇的话，请随意阅读）

我会创建一个分数类，其中包含分子和名词的成员变量（如果你需要支持的话，还有整数部分——尽管我个人会将带有整数部分的分数简化为分子和名词，因为我是这样做的）。然后我将创建一个接受字符串参数的构造函数，该构造函数的主体将与您的

parse（）

方法非常相似。这样你就可以做这样的事情

String strFractionString = /* initialize the string, e.g., reading from input */
Fraction myFrac = new Fraction(strFractionString); // parses string and assigns num & denom
System.out.println("My Fraction: " + myFrac.numerator + "/" + myFrac.denominator);

---

这是我的代码乘以分数。更简单，希望能回答你的问题

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class javatest3
{
    static int num1 = 0;
    static int num2 = 0;
    static int denom1 = 0;
    static int denom2 = 0;

    public static void main(String[] args)
    {
        javatest3 javatest3 = new javatest3();
        System.out.println("Enter an expression (or \"quit\"): "); // prompts
                                                                    // user for
                                                                    // input
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] array = null;
        try {
            array = in.readLine().trim().split(" ");
            /*
             * I get the array[0] and array[2], it because 2/3 * 3/4
             * 2/3 is array[0], * is array[1] and 3/4 is array[2]
             */
            String[] arrayX = array[0].split("/");
            String[] arrayY = array[2].split("/");
            String result = javatest3.multiplyFaction(
                    Integer.valueOf(arrayX[0]), Integer.valueOf(arrayY[0]),
                    Integer.valueOf(arrayX[1]), Integer.valueOf(arrayY[1]));

            System.out.println("Result: " + result);
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        // intro();

    }

    private String multiplyFaction(int x1, int y1, int x2, int y2)
    {
        int mf1 = x1 * y1;
        int mf2 = x2 * y2;

        return String.valueOf(mf1) + "/" + String.valueOf(mf2);
    }

//  public static void intro()
//  {
//      Scanner input = new Scanner(System.in);
//      String user = input.nextLine();
//      while (!user.equals("quit") & input.hasNextLine()) { // processes code
//                                                              // when user
//                                                              // input does
//                                                              // not equal
//                                                              // quit
//          StringTokenizer chunks = new StringTokenizer(user, " "); // parses
//                                                                      // by
//                                                                      // white
//                                                                      // space
//          String fraction1 = chunks.nextToken(); // first fraction
//          String operand = chunks.nextToken(); // operator
//          String fraction2 = chunks.nextToken(); // second fraction
//          System.out.println("Fraction 1: " + fraction1);
//          System.out.println("Operation: " + operand);
//          System.out.println("Fraction 2: " + fraction2);
//          System.out.println("Enter an expression (or \"quit\"): "); // prompts
//                                                                      // user
//                                                                      // for
//                                                                      // more
//                                                                      // input
//
//          while (user.contains("*")) {
//              parse(fraction1);
//              parse(fraction2);
//              System.out.println("hi");
//              int num = num1 * num2;
//              int denom = denom1 * denom2;
//              System.out.println(num + "/" + denom);
//              user = input.next();
//
//          }
//
//      }
//  }

//  public static void parse(String fraction)
//  {
//      if (fraction.contains("_")) {
//          StringTokenizer mixed = new StringTokenizer(fraction, "_");
//          int wholeNumber = Integer.parseInt(mixed.nextToken());
//          System.out.println(wholeNumber);
//          String frac = mixed.nextToken();
//          System.out.println(frac);
//          StringTokenizer parseFraction = new StringTokenizer(frac, "/"); // parses
//                                                                          // by
//                                                                          // forward
//                                                                          // slash
//          int num = Integer.parseInt(parseFraction.nextToken());
//          System.out.println(num);
//          int denom = Integer.parseInt(parseFraction.nextToken());
//          System.out.println(denom);
//
//      }
//      else if (!fraction.contains("_") && fraction.contains("/")) {
//          StringTokenizer parseFraction = new StringTokenizer(fraction, "/"); // parses
//                                                                              // by
//                                                                              // forward
//                                                                              // slash
//          int num = Integer.parseInt(parseFraction.nextToken());
//          System.out.println(num);
//          int denom = Integer.parseInt(parseFraction.nextToken());
//          System.out.println(denom);
//
//      }
//      else {
//          StringTokenizer whiteSpace = new StringTokenizer(fraction, " ");
//          int num = Integer.parseInt(whiteSpace.nextToken());
//          System.out.println(num);
//      }
//  }
}

---

原始代码打印并分隔分数和操作数。我们现在在AP CS中的赋值要求我们将分数分为分子、操作数和分解数。它看起来像这样

StringTokenizer st=新的StringTokenizer（输入）；

---

然后使用find（）；方法调用

中的每个部分不确定您要问什么--您想知道如何让parse（）返回调用它的代码可以使用的分子和Demominator吗？方法内声明的变量被封装为局部变量，不能在方法外使用。可以创建readFraction方法，它接受

fraction1

并返回一个（新类型：分数，带有分子和分母字段），然后可以以合理的方式进行乘法。我认为在这种情况下，这是一种糟糕的编码方式。由于程序只有一个类，并且所有方法都是该类的成员，因此这基本上等同于生成一个全局变量（语义上，虽然不是物理上）。（另外，如果要执行此操作，成员变量必须是

静态的

，才能从静态方法访问。）那么，声明变量，然后将其设置为方法内的num、denom等？我试着这么做，但没有成功。也许我做得不对……这个问题显然是课堂作业。（OP对此很明确，他应该如此。）请不要简单地给出课堂作业/家庭作业/项目的解决方案。允许OP复制粘贴解决方案无助于他学习并鼓励作弊。（当然，我不会对这篇文章是否会作弊发表任何评论！我想不会。）：）此外，这也违反了SO w.r.t.的政策。相反，请帮助他理解他实际提出的问题的答案，并了解为什么会这样，但请允许他这样做