无法创建特定对象的数组并且无法正确使用比较方法

Question

在这个项目中，我的目标是对一个有理数数组进行排序（我已经创建了一个允许这样做的有理数类）。要对数组进行排序，我必须为该类编写一个comareto方法（我的类扩展了可比较的接口）。但是当我检查我的comareto方法时，它总是返回一个0值。此外，当我创建一个有理数类元素数组时，程序只是在那个点上继续运行而没有输出任何结果。我不明白为什么？下面是我的代码，其中还包括方法和部分：

public class MuhammadChaudryProject4 {
    public static void main(String[] args) {
        Rational a = new Rational(1, 4);
        Rational b = new Rational(1, 8);

        System.out.println(a + " + " + b + " = " + a.add(b));
        System.out.println(a + " - " + b + " = " + a.sub(b));
        System.out.println(a + " * " + b + " = " + a.mul(b));
        System.out.println(a + " / " + b + " = " + a.div(b));

        Rational[] arr = {new Rational(7, 1), new Rational(6, 1),
                      new Rational(5, 1), new Rational(4, 1),
                      new Rational(3, 1), new Rational(2, 1),
                      new Rational(1, 1), new Rational(1, 2),
                      new Rational(1, 3), new Rational(1, 4),
                      new Rational(1, 5), new Rational(1, 6),
                      new Rational(1, 7), new Rational(1, 8),
                      new Rational(1, 9), new Rational(0, 1)};

       selectSort(arr);

       for (Rational r : arr) {
            System.out.println(r);
       }

       Number n = new Rational(7, 3);

       System.out.println(n.doubleValue());
       System.out.println(n.floatValue());
       System.out.println(n.intValue());
       System.out.println(n.longValue());
       }

 public static <T extends Comparable<? super T>> void selectSort(T[] array)        
 {

      T temp;
      int mini;

      for (int i = 0; i < array.length - 1; ++i) {

          mini = i;
          for (int j = i + 1; j < array.length; ++j) {
               if (array[j].compareTo(array[mini]) < 0) {
                    mini = j;
                }
          }

         if (i != mini) {
             temp = array[i];
             array[i] = array[mini];
             array[mini] = temp;
             }
         }
         }
   }


   class Rational extends Number implements Comparable<Rational> {
       private int num, denom;


       public Rational(int num, int denom) {
           this.num = num;
           this.denom = denom;
           reduce();

        }

        public Rational add(Rational o){

            return new Rational((denom * o.num) + (o.denom * num), denom * o.denom);
        }

        public Rational sub(Rational o) {
             return new Rational((o.denom * num) - (denom * o.num), denom * o.denom);
        }

        public Rational mul(Rational o) {

            return new Rational(num * o.num, denom * o.denom);
        }

        public Rational div(Rational o) {

            return new Rational(num * o.denom, denom * o.num);
        }

        private int gcd (int num, int denom)
        {
           while (num != denom)
               if (num > denom)
                   num = num - denom;
               else
                   denom = denom - num;

               return num;
        }
        private void reduce() {
            int common = gcd(Math.abs(num), denom);
            num = num / common;
            denom = denom / common;
        }

        public String toString() {
             if (denom == 1) {
                 return(num + " ");
             }
             if (num == 0) {
                 return("0");
             } 
             else {
                 return(num + "/" + denom);
             }
        }


        public int compareTo(Rational a) {
             if ((double)(this.num)/(double)(this.denom) > (double)(a.num)/(double)(a.denom) ){
                return 1;
            }
            if ((double)(this.num)/(double)(this.denom) < (double)(a.num)/(double)(a.denom) ){
                return -1;
             }
            else {
                return 0;
                }

         }

         public double doubleValue() {
              return((double)num/denom);
         }

        public float floatValue() {
            return((float)num/denom);
        }

        public int intValue() {
            return((int)num/denom);
        }

        public long longValue() {
            return((long)num/denom);
        }
    }

更新——此代码已修复Compareto，感谢@Izruo帮助

Answer 1

但是当我检查我的比较方法时，它总是返回一个 0 值。

当计算Rational的实际值时，请执行以下操作：

double rational = (double) (this.num / this.denom);

对于 this.num 小于 this.denm 的任何星座，这将产生 0，因为计算本身是在整数算术中完成的，并且结果被转换为双精度。

要实际进行您想要的计算，您必须转换每个值，如下所示:

double rational = (double) this.num / (double) this.denom;

我只是试图忽略eclipse警告的所有错误来运行您的代码。例如，每当我遇到编译时错误时，我通常不会尝试执行代码，因为我非常确定可能会发生一些真正意想不到的事情。更多信息请见下文。

此外，当我创建一个有理类元素数组时，程序只是在该点继续运行而不输出任何结果。

您的程序在＜code＞int gcd（int num，int denom）＜/code＞方法中运行无限循环，输入值＜code＞num＝0＜/code＞和＜code＞denom＝1＜/code>。

为了解决这个问题，我建议将< code>0值作为一种特殊情况来处理，任何具有< code>num = 0的值肯定是(< code>0 / x = 0)。因此，在您的方法中，您应该添加一个附加检查，作为第一条语句:

if(num == 0) {
    denom = 1;
    return 0;
}

类Rational未能实现一些抽象方法。我不知道为什么您的代码仍然能够运行，尽管有编译错误。但是，我强烈建议修复这些错误，因此实现以下方法：

int
• intValue（）
long
• longValue（）
float
• floatValue（）
• 双倍值（）

这些只是转换方法，因此非常容易实现。事实上，双值（）方法的目的正是我在回答您问题的第一部分时所解释的。其他方法只是相似。