Java 程序设计：有理数类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 程序设计：有理数类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16845字，纯文字阅读大概需要25分钟。

内容图文

• 需求分析
• 类的定义
• 类字段
• 构造方法
  • Rational(int num) 方法
  • Rational(int numerator, int denominator) 方法
  • Rational(String str) 方法
  • 辅助方法
    • GetGCD(int numerator, int denominator) 方法
    • isInteger(String str) 方法
• 基本运算方法
• 实现 Comparable 接口
• equals() 方法
• 字段访问器和 toString() 方法
• 类测试代码
  • 错误输入测试
  • 类功能测试
• 问题讨论
  • 问题一
  • 问题二
  • 问题三
  • 问题四
• 参考资料

需求分析

有理数是整数（正整数、0、负整数）和分数的统称，是整数和分数的集合。由于有理数的子集分别是整数和分数，因此对于类的字段的设计，需要提供满足这两种数的表达方式。由于有理数本质上是数，因此有理数类需要实现数能做的事，也就是基本的四则运算。又由于有理数本质上是数，是数就有大小之分，因此实现有理数的比较非常重要。equals() 方法是每个类都可能需要频繁用到的方法，它是从 Object 类继承下来的方法，尤其是对于大小特征鲜明的数字，该方法也很有必要实现。最后再加上必要的字段访问器和 toString() 方法，有理数类编写的需求思维导图如下：

设计一个类的一些建议如下：

1. 保证数据私有，不要破坏封装性；
2. 数据都要初始化，不应当以来 Java 的默认值；
3. 不要在类中使用过多的基本类型，而是用其他类来替换；
4. 并不是所有的字段都需要单独的字段访问器和字段更改器；
5. 分解有过多职责的类，例如类可以明显地分为两个简单的类；
6. 类名和方法要尽量体现它们的职责；
7. 优先使用不可变类，即没有方法可以修改对象状态的类。

类的定义

有理数类应该是一个轮子类，它会被广泛应用于一些需要有理数承载数据的地方。将方法或类声明为 final 可以确保其不会在子类中改变语义，例如 String 类这种不可变类就要注意避免这种事发生，Rational 类同理。因为我们希望更方便地进行有理数的大小比较，并且希望兼容 Arrays 的 sort() 方法进行排序，因此此处用 implements 关键字启用 Comparable 接口。

public final class Rational implements Comparable<Rational>

类字段

根据需求，设计类字段时需要考虑整数和分数。不过整数也可以认为是分数的子集，因为整数可以看作是分母为 1 的分数。因此这里只需要 2 个字段分别表示分子和分母，不需要更多的字段或者状态变量来进行管理。
为了保证数据私有，不要破坏封装性，此处将所有字段的访问修饰符都设置为 private。同时我选择将实例字段定义为 final 字段，这样的字段必须在构造对象是初始化，并且之后不能再修改。final 修饰符对于类型为基本类型或者不可变类字段很有用，例如 String 类就是个不可变类，而有理数类是类似于 String 类起到轮子功能的类。

private final int numerator;
private final int denominator;

我们考虑一个重要的问题，用户永远无法输入无限不循环小数，我们是否需要考虑接收用户的小数呢(有限位数的小数是有理数)？无论数学上还是理论上可行，此处我的个人建议是绝对不要这么做。做到这一点并不难，比如说把分子改为是诸如 double 类型的字段，然后分母统一设置为 1。用户没办法表示一个无限不循环小数，因为用户输入的小数始终会是有限个的，不过用户也可以用表达式注入参数，此时我们无法保证某个表达式的计算结果不会是无理数。
实践经验告诉我们，永远不要相信所有用户，不要天真地希望他们会按照开发者的心意来使用工具。如果我们这里开放了有理数的小数表示，则会留下别有用心或者胡来的用户注入无理数等奇怪的东西，从而使得我们的“有理数类”逻辑不清，定语形同虚设，这个类就是个失败的类。所以这里我们就把字段写死了，不允许任何浮点数被输入。

构造方法

由于用户输入的数字可能是整数或小数，因此我们需要重载一些类的构造方法。

Rational(int num) 方法

该方法对应的是最简单的情况，即用户输入的是个整数，整数一定是有理数了。

//输入整数的构造方法
public Rational(int num) {
      this.numerator = num;
      this.denominator = 1;
}

Rational(int numerator, int denominator) 方法

该方法对应的是分数形式的有理数，方法传入该有理数的分子和分母，分别将其赋值给对应字段。注意此时传入的分母不能为 0，否则这是个不合法的输入，应该主动抛出一个异常告知类的使用者。

//输入分子和分母的构造方法
public Rational(int numerator, int denominator) throws IllegalArgumentException{	
      if(denominator == 0) {    //不合法有理数判断，分母不为 0
            throw new IllegalArgumentException("分母是个不合法的参数");
      }
		
      int gcd = GetGCD(numerator, denominator);    //取分子和分母的最大公约数，用于化简
      this.numerator = numerator / gcd;
      this.denominator = denominator / gcd;
}

注意到我们使用了 throws 关键字进行异常规范声明，展示这个方法可能抛出的异常。我们选择抛出的异常是 IllegalArgumentException 异常，这个是 Exception 类分支下的不合法的参数异常类。

Rational(String str) 方法

这是最令人头疼而难办的方法，因为类通常会重载一个支持用字符串进行初始化的构造器，以满足不同的需求(例如从文件流中读入数据创建对象)。但是参数是字符串意味着用户可以将任何内容以字符串的形式注入构造器，上面的需求写到了，我们定义的 Rational 类仅支持整数形式和分数形式 2 种表示方法。也就是说我们需要判断字符串是否是我们所期望的输入形式，如果是其他恶意的输入，我们的方法应当主动地过滤掉并抛出异常。

//输入字符串的构造方法
public Rational(String str) throws IllegalArgumentException{
		
      int idx = 0;
      if(isInteger(str)){    //检测是否是整数型输入
            this.numerator = Integer.valueOf(str);
            this.denominator = 1;
      }
      else if(str.indexOf("/") != -1){    //检测是否是分数型输入
            String numerator_str = str.substring(0, str.indexOf("/"));
            String denominator_str = str.substring(str.indexOf("/") + 1, str.length());
			
            if(isInteger(numerator_str) && isInteger(denominator_str)){    //判断除号两边是否是整数
	          int numerator = Integer.valueOf(numerator_str);
		  int denominator = Integer.valueOf(denominator_str);
		  if(denominator == 0) {
		        throw new IllegalArgumentException("分母是个不合法的参数");
		  }
				
		  int gcd = GetGCD(numerator, denominator);
		  this.numerator = numerator / gcd;
		  this.denominator = denominator / gcd;
	    }
	    else {    //除号两遍不是整数
	          throw new IllegalArgumentException("输入的字符串是不合法的参数");
	    }
      }
      else {    //不合法输入
            throw new IllegalArgumentException("输入的字符串是不合法的参数");
      }	
		
}

仔细阅读代码，我们首先使用 isInteger() 方法判断传入的字符串是否是整数，如果是则将字符串转换成整数后进行实例化。如果不是整数，则进入下一步的判断，即判断传入的字符串是否是以分数形式出现。若字符串中有除号 “/”，则使用 isInteger() 方法进一步判断除号两侧的字符串是否是整数。如果这 2 个验证都通过了，就按照分数形式进行实例化，否则就应该抛出一个 IllegalArgumentException 异常。

辅助方法

GetGCD(int numerator, int denominator) 方法

该方法用于取分子和分母的最大公约数，用于给分数进行化简，使用的是大家熟知的辗转相除法。需要注意的是分子和分母的大小关系不一定，因此进入算法之前应该用个分支判断哪个是大数，不过这个应该是编程的初学者才会欠考虑的地方。

//求 2 个整数的最大公约数，用于分数化简
private int GetGCD(int numerator, int denominator){
      int num1;
      int num2;
      //保证是大数除小数
      if(numerator > denominator) {	
            num1 = Math.abs(numerator);
	    num2 = Math.abs(denominator);
      }
      else {
	    num1 = Math.abs(denominator);
	    num2 = Math.abs(numerator);
      }
		
      int remainder = num1 % num2;
      while (remainder != 0) {
            num1 = num2;
            num2 = remainder;
            remainder = num1 % num2;
      }
      return num2;
}

isInteger(String str) 方法

该方法就是上述代码中用于判断字符串是否是整数的方法，它使用正则表达式实现。Java 要启用正则表达式之前，需要先把 Pattern 包含进来。

import java.util.regex.Pattern;

我们先造一个 Pattern 对象来编写正则表达式，Pattern 对象是一个正则表达式的编译表示，compile() 方法用于编译正则表达式。Matcher 对象是对输入字符串进行解释和匹配操作的引擎，我们需要调用 Pattern 对象的 matcher() 方法来获得一个 Matcher 对象。最后使用 matches() 方法，尝试将整个区域与模式匹配。

//判断是否是整数
private static boolean isInteger(String str) {  
      Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");  
      return pattern.matcher(str).matches();  
}

注意到这里我使用 static 关键字，将 isInteger(String str) 定义为静态方法。当方法被定义为静态方法时，该方法不在对象上执行(或者说没有 this 参数)，例如 Math 类的 pow 方法，该方法实现幂运算是不需要 Math 对象。当方法不需要访问对象状态，或方法只需要访问类的静态字段时，可以将方法定义为静态方法。这里定义成静态方法的好处是正则表达式只需要编译一次，就可以供整个类来使用，否则每次调用方法都编译一次正则表达式，是一笔较大的开销。

基本运算方法

有理数类肯定要支持基本的四则运算啦，实现的思路也很简单。因为我们把整数当做是分母为 1 的小数，因此所有四则运算的方法都可以按照小数的计算思路来实现。方法将会返回一个新的 Rational 对象，由于调用构造器时会自动对分数进行化简，因此我们不需要对计算结果进行多余的化简操作。同样一个 Rational 对象能够创建，其分母一定不为 0，这里无需对除零进行多余的判断，也自然不需要抛出多余的异常。

//加法运算
public Rational add(Rational num2) {
      int numerator = this.numerator * num2.denominator + denominator * num2.numerator;
      int denominator = this.denominator * num2.denominator;
      return new Rational(numerator, denominator);
}
//减法运算
public Rational subtract(Rational num2) {
      int numerator = this.numerator * num2.denominator - denominator * num2.numerator;
      int denominator = this.denominator * num2.denominator;
      return new Rational(numerator, denominator);
}
//乘法运算
public Rational multply(Rational num2) {
      int numerator = this.numerator * num2.numerator;
      int denominator = this.denominator * num2.denominator;
      return new Rational(numerator, denominator);
}
//除法运算
public Rational divide(Rational num2) {
      int numerator = this.numerator * num2.denominator;
      int denominator = this.denominator * num2.numerator;
      return new Rational(numerator, denominator);
}

总之思路还是一样的，一开始就应该把该做的过滤操作做好，不要放任何可能出现问题的数据进到其他方法。执行基本运算的方法仅负责进行基本运算，由其他方法完成的任务，就不要让这些方法多做考虑。

实现 Comparable 接口

我们编写的是有理数类，有理数是数字，自然有大小之分。我们希望能够用合适的方式比较有理数类对象的大小，同时我们还希望有理数类可以兼容 sort() 方法享受快排的快感。 Arrays 类中的 sort 方法可以对对象数组进行排序，但是 sort 应该按照什么规则进行排序呢？这个时候就可以使用 Comparable 接口，这个接口能够用于描述某个类比较大小的规则。
接口用于描述类应该做什么，而不是指定类具体要怎么实现，一个类中可以实现多个接口。在有些情况下，我们的需求符合这些接口的描述，就可以使用实现这个接口的类的对象。一旦类启用了接口，就必须要实现接口中的所有方法，Comparable 接口中仅有 compareTo() 方法，这就是 sort() 方法比较大小的依据。

//实现 Comparable 接口的所有方法
public int compareTo(Rational num2) {
      int result = this.subtract(num2).getNumerator();
      if(result > 0){
            result = 1;
      }
      else if(result < 0) {
            result = -1;
      }
      return result;
}

equals() 方法

Object 类是 Java 中所有类的超类，Java 中的每个类都是 Object 类的子类。equals() 方法可以检测一个对象是否等于另一个对象，在 Object 类中的判断方式是判断 2 个对象的引用是否相等。但是在很多情况下我们不关心他们的引用是否相等，而是关系各个状态字段是否相等。因此在基础 equals 方法时，我们经常需要针对状态来进行覆盖。设计 equals() 方法时可以参考以下几点：

1. 显式参数命名为 otherObject，比较时用强制类型转换为另一个 other 变量；
2. 检测 this 和 otherObject 是否相等；
3. 检测 otherObject 是否是 null；
4. 比较 this 与 otherObject 的类是否相同；
5. 将 otherObject 强制类型转换为相应的类类型变量，比较各个字段。

public boolean equals(Object obj) {
      //检测 this 和 otherObject 是否相等
      if(this == obj) {
            return true;
      }
      //检测 otherObject 是否是 null
      if(obj == null){
            return false;
      }
      //比较 this 与 otherObject 的类是否相同
      if(this.getClass() != obj.getClass()) {
            return false;
      }
      //强制类型转换为相应的类类型变量，比较各个字段
      Rational num2 = (Rational) obj;
      return this.numerator == num2.numerator
          && this.denominator == num2.denominator;
}

字段访问器和 toString() 方法

public int getNumerator() {
      return numerator;
}

public int getDenominator() {
      return denominator;
}

public String toString() {
      if(this.denominator == 1) {
            return "The Rational is " + this.numerator;
      }
      else {
            return "The Rational is " + this.numerator + "/" + this.denominator;
      }
}

类测试代码

完整 Rational 类代码在此，测试一个类的功能是否正常，需要注入错误的参数进行报错参数，看看类是否能够过滤错误的参数。也要输入具有不同特征的测试数据，对类的各个方法逐一测试。

错误输入测试

public static void main(String[] args) {
      Rational num1 = new Rational("我是恶/意注入");
      System.out.println(num1.toString());
}

public static void main(String[] args) {
      Rational num1 = new Rational("我不是有理数");
      System.out.println(num1.toString());
}

类功能测试

public static void main(String[] args) {
      //构造器测试
      Rational array[] = new Rational[9];
      array[0] = new Rational(0);
      array[1] = new Rational(1);
      array[2] = new Rational("2");
      array[3] = new Rational("3/1");
      array[4] = new Rational(4,1);
      array[5] = new Rational(1,2);
      array[6] = new Rational("1/3");
      array[7] = new Rational(2,5);
      array[8] = new Rational("5/8");
      for(Rational num:array) {
            System.out.println(num.toString());
      }
		
      //加法运算测试
      System.out.println(array[0].add(array[1]));
      System.out.println(array[2].add(array[5]));
      //减法运算测试
      System.out.println(array[3].subtract(array[4]));
      System.out.println(array[2].subtract(array[6]));
      //乘法运算测试
      System.out.println(array[2].multply(array[3]));
      System.out.println(array[4].multply(array[6]));
      //除法运算测试
      System.out.println(array[4].divide(array[2]));
      System.out.println(array[3].divide(array[8]));
		
      //排序测试
      Arrays.sort(array);
      for(Rational num:array) {
            System.out.println(num.toString());
      }
		
      //相等判断测试
      Double test_num1 = null;
      Integer test_num2 = new Integer(1);
      Rational test_num3 = new Rational(0);
      System.out.println(test_num3.equals(test_num1));
      System.out.println(test_num3.equals(test_num2));
      System.out.println(test_num3.equals(array[0]));
      System.out.println(test_num3.equals(array[1]));
}

问题讨论

问题一

描述与 C 语言的有理数代码相比较，为什么你设计的类更加面向对象?

这个问题我认为问法不是很好，为了讲清这个问题，我们还是得先回顾下为什么需要面向对象编程。由于 C 语言是面向过程的语言，因此我们使用 C 语言只能实现结构化程序设计。所谓结构化程序设计就是“程序 = 数据结构 + 算法”，而在编写有理数结构时程序中会有很多可以相互调用的函数和变量。可以显然地看出，这种编程风格存在不少缺点。首先由于函数之间可以相互调用，任何函数都可以修改全局变量，这就导致了函数、数据结构之间的关系一段乱麻，尤其是当代码量很长的时候，代码的理解也变得极其困难。

• 这个函数是用来操作哪个还是哪些数据数据结构？
• 这个数据结构可以被哪些函数操作，代表什么含义？
• 不同的函数能够相互调用吗？关系是什么？

对于变量来说，有的变量可能是只能被一些函数修改，而不能被某些函数操作，但是由于你不能给变量“上锁”，因此这个变量会很轻松地被修改。当然你可以说可以搞成常量，那我如果要修改呢？搞成常引用？算了吧，这样变量间的关系就跟复杂了。而且，某个数据结构会被多个函数调用，而如果出现了错误，是哪个函数出错了呢？是函数一、函数二、函数 N，还是都有错？除了调试好像还真没啥好办法。同时作为一个懒人，如果我的一个程序的某个功能我曾经写过，那么我就很喜欢去把以前的代码搞来用。可是往往这会是一件困难的事情，因为这段代码的源程序的变量和函数间本身就有复杂的逻辑关系，接口可能完全不一样，最后你发现还不如重写一遍。

简单地说，面向对象程序设计就是把某个客观事物的共同特点归纳出来，形成一个数据结构。对象既表示客观世界问题空间中的某个具体事物，有表示软件系统解空间中的基本元素。在面向对象的编程风格中“对象 = 属性 + 方法”，对象中既包含属性(数据)，也包含方法(代码)，是某一类具体事物的特殊实例。此处我们将有理数这个对于计算机来说抽象的概念，利用代码把它具体化为一种对象，这种对象具有分子和分母 2 个状态需要记录。同时这个对象与特定的动作绑定在一起，这些动作都是这个对象独有的具有的可发生的操作。而面向过程的编程风格不仅没有封装性，更不能在语法上将对象和方法绑定在一起，函数和变量的关系真的只能靠开发者自觉遵守。

问题二

别人如何复用你的代码?

Java 提供了非常好用的“包 (package)”机制来实现代码的复用，包能够很好地组织类，同时也用于区别类名的命名空间。包把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。基于这种机制，开发者可以自己把一组类和接口等打包，让其他开发者复用，同时这也能帮助其他开发者更容易地确定哪些类、接口、枚举和注释等是相关的。使用包中的某个类时，其他开发者可以使用 import 把类导入进来用。
同时包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类，这也使得其他程序员复用代码时不能瞎用、瞎继承我们的代码。

问题三

别人的代码是否依赖你的有理数类的属性?当你的有理数类的属性修改时,是否会影响他人调用你有理数类的代码?

这个问题的表述我觉得有点含糊，我按照我对题目的理解来讨论。当其他开发者在他们的代码上复用了有理数类，并且实例化出对象来使用时，这些实例化出来的对象与我无瓜。因为类是一种抽象模型，是一种概念性的存在，实例化对象的字段时就需要根据字段的要求填充数据。当类实例化赋予了具体的状态之后，这些实例化的类就会成为彼此独立而有用的个体。我和其他开发者可能都会大范围使用到有理数类，但是使用的情景可能完全不相同，而实例化的对象没有任何关系，因为他们是独立的个体。
所以别人的代码依赖我的有理数类的属性，因为这些属性是我给这个对象抽象出来的状态，因为有了这些状态我们才能具体地描述这些对象。如果我修改了有理数的字段，那么其他开发者调用时就得跟着用我修改的内容。但是如果对于实例化之后的对象，对象彼此之间是独立的个体，不会对代码调用产生影响。

问题四

有理数类的 public 方法是否设置合适?为什么有的方法设置为 private?

public 定义的方法表示任何类的任何方法都可以调用，不过有时候可能会破坏封装性。对于方法来说，一个方法的实现可以被拆分出几个辅助方法，这些辅助方法对于外界来说不应该成为公共接口的一部分。例如上述我写的代码，在构造器的编写时就使用了 GetGCD(int numerator, int denominator) 和 isInteger(String str) 两个辅助方法。此时我使用 private 来定义，使得方法被定义为私有方法。这种做法的好处在于当你原来的方法重新设计而不需要辅助方法时，由于是私有方法，你不用担心这个方法会被其他程序所需要，可以直接删除。如果它是共有地的方法，即使你本人不再使用，也不能确定在其他开发者的程序中也不再使用。

参考资料

《Java 核心技术 卷Ⅰ》，[美]Cay S.Horstmann 著，林琪 苏钰涵 等译，机械工业出版社
Java 面向对象：对象、字段和方法
Java 面向对象：类的继承
Java 面向对象：Object 类
Java 面向对象：接口
Java 异常类与捕获异常
Python 面向对象编程
Java 正则表达式
Java 包(package)
Java中判断字符串是否为数字的五种方法

内容总结

以上是互联网集市为您收集整理的Java 程序设计：有理数类全部内容，希望文章能够帮你解决Java 程序设计：有理数类所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端