无法创建特定对象的数组，并且无法正确使用compare to方法

Question

在这个项目中，我的目标是对有理数数组进行排序（我创建了一个有理数类来允许这样做）。 为了对数组进行排序，我必须为该类编写一个compareto方法（我的类扩展了可比较的接口）。 但是，当我检查我的compareto方法时，它总是返回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);
        }
    }

更新-由于@Izruo帮助，此代码已修复compareto

Answer 1

但是，当我检查我的compareto方法时，它总是返回0值。

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

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

对于this.num小于this.denom任何星座，这都会产生0 ，因为计算本身是通过integer算术完成的，并且结果转换为double 。

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

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

---

编辑

我只是尝试运行您的代码，而忽略了Eclipse警告过的所有错误。 例如，每当遇到编译时错误时，我通常都不会尝试执行代码，因为我敢肯定，某些​​事情可能真的发生了。 下面附注的更多信息。

同样，当我制作一个有理类元素数组时，该程序只是在此时继续运行而没有输出任何结果。

您的程序在输入值num = 0和denom = 1的int gcd(int num, int denom)方法内陷入无限循环。

为了解决这个问题，我建议处理0值，在特殊情况下， num = 0任何值肯定是（ 0 / x = 0 ）。 因此，在您的方法中，应在第一条语句中添加如下所示的其他检查：

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

---

注意

Rational类错过了实现一些抽象方法的机会。 我不知道为什么尽管有编译错误，您的代码为什么仍然可以运行。 但是，我强烈建议您修复这些错误，从而实现以下方法：

• int intValue()
• long longValue()
• float floatValue()
• double doubleValue()

这些仅仅是转换方法，因此非常容易实现。 实际上， doubleValue()方法是按照我在回答问题的第一部分时所做的解释来做的。 其他方法都差不多。