Question

我是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);
}

}}

Answer 1

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

备选方案＃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() {1}}的副本。例如：

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：

考虑到选择，这将是我的偏好，但前提是你已经学习了一些关于面向对象的编程。如果你还没有学到这一点，我会采用另一种方法（但如果你很好奇，可以随意阅读。）

我会创建一个分数类，它具有分子和denomonator的成员变量（如果你需要支持那个整数部分 - 尽管我个人会将整数部分的分数减少到只有分子和denomonator，无论如何，因为那是我做数学的方式）。然后我创建一个带有String参数的构造函数，该构造函数的主体就像你的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);

Answer 2

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

这是variable scope上的有用资源。

Answer 3

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

如果您想使用String frac执行此操作

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();
        }
    }
}

Answer 4

假设您希望函数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;

Answer 5

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

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
    }
}

Answer 6

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

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);
//      }
//  }
}

Java分数计算器

6 个答案: