Fraction.java保持获取对象地址不是我想要的值

Question

我正在处理这个程序并不断得到这个结果。

要转换小数措施， 进入小数措施要转换：3/4

输入小数量减少/增加由它：1/2

转换后的测量：分数@ 6750cf54

零件是粗体是问题。

这是我的主要程序。

import java.util.*; // Scanner 
import java.io.*; // PrintStream 

public class Pierre1 extends Object 
{ 
    public static void main(String args[]) 
    { 
    PrintStream theScreen = new PrintStream(System.out); 
    Scanner theKeyboard = new Scanner(System.in); 
    theScreen.println("\nTo convert fractional measures,"); 
    theScreen.print(" enter the fractional measure you want to convert: "); 
    Fraction oldMeasure = new Fraction(); 
    oldMeasure.read(theKeyboard); 



    theScreen.print("\nEnter the fractional amount to reduce/increase it by: "); 
    Fraction scaleFactor = new Fraction(1,6); 
    scaleFactor.read(theKeyboard); 


    Fraction newMeasure = oldMeasure.times(scaleFactor); 

    theScreen.print("\nThe converted measurement is: "); 
    theScreen.print(newMeasure); 
    theScreen.println(); 
    theScreen.println(); 

    } 
} 

这是我的其他程序。

import java.util.*; // Scanner 
import java.io.*; // PrintStream 

public class Fraction extends Object 
{ 
    private int myNumerator = 0; 
    private int myDenominator = 0; 
    public void print(PrintStream out) 
    { 
     System.out.print(myNumerator + "/" + myDenominator); 
    } 
    public Fraction() 
    { 
    myNumerator = 0; 
    myDenominator = 1; 
    } 

    public Fraction(int numerator, int denominator) 
    { 
    myNumerator = numerator; 
    myDenominator = denominator; 
    }  
    private int numerator() 
    { 
    return myNumerator; 
    }  

    private int denominator() 
    { 
    return myDenominator; 
    }  

    public void read (Scanner in) 
    { 
    String fraction = in.next(); 
    StringTokenizer parser = new StringTokenizer(fraction, "/", false); 
    if (parser.countTokens() != 2) 
     throw new RuntimeException("Bad Fraction Format"); 
    myNumerator = Integer.parseInt(parser.nextToken()); 
    myDenominator = Integer.parseInt(parser.nextToken()); 
    } 

    Fraction times(Fraction rightOperand) 
    { 
    Fraction result 
     = new Fraction(myNumerator*rightOperand.numerator(), 
       myDenominator*rightOperand.denominator()); 

    result.simplify(result); 
    return result; 
    } 


    public Fraction simplify(Fraction getGcd) 
    { 
     Fraction result = new Fraction(); 
     int num = numerator(); 
     int den = denominator();   
     int gcd = greatestCommonDivisor(num, den); 
     if (gcd == 0) 
      return result; 
     else 
     { 
      myNumerator = myNumerator/gcd; 
      myDenominator = myDenominator/gcd; 
     } 

     return result; 
    } 


private static int greatestCommonDivisor(int alpha, int beta) 
{ 
    alpha = Math.abs(alpha); // take absolute values of operands 
    beta = Math.abs(beta); 

    if (beta == 0)  // base case 
     return alpha; 
    else     // induction step 
    { 
     int remainder = alpha % beta; 

     return greatestCommonDivisor(beta, remainder); 
    } 
    } 

} 

我需要做些什么来解决这个问题？ 我一直在扫描程序来查找问题，但是我有限的Java体验正在让我获得最好的体验。任何帮助是极大的赞赏。提前致谢！

Answer 1

看看，我使用Fraction类（它修复了一些你的缺陷的：分子和denumerator应该是最终的，等等）

// code by jph 
package sys.mat;  

/** non degenerate integer fraction in normal form */ 
public class Fraction implements Comparable<Fraction> { 
    /** numerator */ 
    public final int num; 
    /** denominator (always greater than zero) */ 
    public final int den; 

    public static int gcd(int a, int b) { 
    if (b == 0) 
     return a; 
    return gcd(b, a % b); 
    } 

    /** @param num 
    * @param den has to be non-zero 
    * @throws {@link ArithmeticException} if den is zero */ 
    public Fraction(final int num, final int den) { 
    int gcd = gcd(num, den); 
    int res = den/gcd; 
    if (0 < res) { 
     this.num = num/gcd; 
     this.den = res; 
    } else { 
     this.num = -num/gcd; 
     this.den = -res; 
    } 
    } 

    public Fraction add(Fraction myFraction) { 
    return new Fraction(num * myFraction.den + den * myFraction.num, den * myFraction.den); 
    } 

    public Fraction sub(Fraction myFraction) { 
    return new Fraction(num * myFraction.den - den * myFraction.num, den * myFraction.den); 
    } 

    public Fraction mul(Fraction myFraction) { 
    return new Fraction(num * myFraction.num, den * myFraction.den); 
    } 

    public Fraction mul(int myInt) { 
    return new Fraction(num * myInt, den); 
    } 

    public Fraction div(Fraction myFraction) { 
    return new Fraction(num * myFraction.den, den * myFraction.num); 
    } 

    /** also denoted reciprocal 
    * 
    * @return den/num */ 
    public Fraction inverse() { 
    return new Fraction(den, num); 
    } 

    /** @return true if den == 1 */ 
    public boolean isInteger() { 
    return den == 1; 
    }  

    public double toDouble() { 
    return num/(double) den; 
    } 

    /** may only be called if isInteger() returns true 
    * 
    * @return num */ 
    public int toInteger() { 
    if (!isInteger()) // assert den == 1 
     throw new RuntimeException(toString() + " is no integer"); 
    return num; 
    } 

    @Override 
    public int compareTo(Fraction myFraction) { 
    // return num * myFraction.den - den * myFraction.num; // does not work for big integers 
    return Double.compare(toDouble(), myFraction.toDouble()); 
    } 

    public boolean equalsInteger(int value) { 
    return equals(new Fraction(value, 1)); 
    } 

    @Override 
    public boolean equals(Object myObject) { 
    if (myObject == null) // || !(myObject instanceof Fraction) 
     return false; 
    Fraction myFraction = (Fraction) myObject; 
    return num == myFraction.num && den == myFraction.den; // sufficient since in normal form 
    } 

    @Override 
    public int hashCode() { 
    // n/1 is mapped to n, thus is identical to getInteger() 
    return num + den - 1; 
    } 

    @Override 
    public String toString() { 
    return num + "/" + den; 
    }  
}