2021-09-27

import java.util.regex.Pattern;

public final class Rational implements Comparable{
    private final int numerator;
    private final int denominator;
        //输入整数的构造方法
    public Rational(int num) {
            this.numerator = num;
            this.denominator = 1;
        }
        //输入分子和分母的构造方法
    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;
        }
        //输入字符串的构造方法
    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("输入的字符串是不合法的参数");
            }

        }
        //求 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;
            }
            //逆转负号，把分母的负号转移到分子上
            if(denominator < 0) {
                num2 = -num2;
            }
            return num2;
        }
        //判断是否是整数
        private static boolean isInteger(String str) {
            Pattern pattern = Pattern.compile("^[-\+]?[\d]*$");
            return pattern.matcher(str).matches();
    }
    //加法运算
    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);
    }

    //返回绝对值
    public Rational abs() {
        if(this.          numerator < 0) {
            return new Rational(-1 * this.getNumerator(),this.getDenominator());
        }
        else {
            return new Rational(this.getNumerator(),this.getDenominator());
        }
    }
    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;
    }
    //有理数转化为 int 类型
    public int intValue() {
        return (int) this.numerator / this.denominator;
    }
    //有理数转化为 double 类型
    public double doublevalue(){
        return (double) this.numerator / this.denominator;
    }
    //获得分母
    public int getNumerator() {
        return numerator;
    }
    //获得分子
    public int getDenominator() {
        return denominator;
    }

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

    @Override
    //实现 Comparable 接口的所有方法
    public int compareTo(Rational num2) {
        return this.subtract(num2).getNumerator();
    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        public static void main(String[] args) {
            //构造方法测试
            Rational array[] = new Rational[11];
            array[0] = new Rational(0);
            array[1] = new Rational(1);
            array[2] = new Rational("2");
            array[3] = new Rational("6/2");
            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");
            array[9] = new Rational(-1,2);
            array[10] = new Rational("3/-5");
            for(int i = 0; i < array.length; i++) {
                System.out.println("array[" + i + "]:" + array[i].toString());
            }
            //加法运算测试
            System.out.println("加法测试1:" + array[0].add(array[1]));
            System.out.println("加法测试2:" + array[2].add(array[5]));
            //减法运算测试
            System.out.println("减法测试1:" + array[3].subtract(array[4]));
            System.out.println("减法测试2:" + array[2].subtract(array[6]));
            //乘法运算测试
            System.out.println("乘法测试1:" + array[2].multply(array[3]));
            System.out.println("乘法测试2:" + array[4].multply(array[6]));
            //除法运算测试
            System.out.println("除法测试1:" + array[4].divide(array[2]));
            System.out.println("除法测试2:" + array[3].divide(array[8]));
            //绝对值运算测试
            System.out.println("绝对值测试1:" + array[7].abs().toString());
            System.out.println("绝对值测试2:" + array[9].abs().toString());

            //Comparable 接口测试
            Arrays.sort(array);
            for(int i = 0; i < array.length; i++) {
                System.out.println("array[" + i + "]:" + array[i].toString());
            }
            //相等判断测试
            Double test_num1 = null;
            Integer test_num2 = 1;
            Rational test_num3 = new Rational(0);
            System.out.println("相等测试1:" + test_num3.equals(test_num1));
            System.out.println("相等测试2:" + test_num3.equals(test_num2));
            System.out.println("相等测试3:" + test_num3.equals(array[2]));
            System.out.println("相等测试4:" + test_num3.equals(array[1]));
            //数制转换测试
            System.out.println("数制转换测试1:" + array[6].doublevalue());
            System.out.println("数制转换测试2:" + array[6].intValue());
        }
    }
}

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

该程序将关于有理数的操作全部封装在一个类中。

别人如何复用你的代码?

将该类打包，别人下载使用import即可使用该类。

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

别人的代码依赖我的有理数类的属性，当我的由有理数类的属性修改时不会影响他人调用有理数类的代码。、

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

public 定义的方法表示任何类的任何方法都可以调用，而private定义的方法表示只能在该类中使用该方法。有理数类中的public方法均是外界需使用的方法，故设置合适。而该类中设置为private的只在该类中使用，外界不需要使用，故设置为private。