Java：异常处理我的catch（）有问题

Question

    public class Fraction {
    private int numerator; //  
    private int denominator; // 

    Fraction(int nume, int denom)
    {
        numerator = nume;
        denominator = denom;
    }

     public Fraction divide(Fraction other ) throws FractionDivideByZeroException
    {       

         int nume=0, denom=0;
         try {              
                nume = (this.numerator * other.denominator);
                denom = (this.denominator*other.numerator);
                if(nume!=0 && denom==0) throw new FractionDivideByZeroException();
                return new Fraction(nume, denom);
            } catch (FractionDivideByZeroException e) {             
                e.printError();             
            }       
            return new Fraction(nume, denom);               
    }


}
class FractionDivideByZeroException extends Exception
{
    void printError()
    {
        System.out.println("You can not divide by zero!");
    }
}

这是测试类：

public class FractionTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fraction frac1 = new Fraction(1,2);
        Fraction frac2 = new Fraction(1,3);

        Fraction frac3 = frac1.divide(frac2); // here's the error message saying "Unhandled exception type FractionDivideByZeroException"
        System.out.println(frac3);

    }



}

Answer 1

你说过Divide抛出FractionDivideByZeroException

public Fraction divide(Fraction other ) throws FractionDivideByZeroException

但是要编写代码以确保它不会发生。编译器不知道这一点，因此抱怨您/没有在调用代码中处理异常

Answer 2

看看你的方法签名：

 public Fraction divide(Fraction other ) throws FractionDivideByZeroException

它说它抛出了异常。main方法无法捕获它，因此编译器会抱怨

在方法中捕获它或声明抛出它，但不能两者兼而有之

我认为你的逻辑有缺陷。你应该永远不要能够创建一个分母为零的分数-你的构造函数应该检查一下

您的divide（）方法应该进行检查，以确保除数的分子不是零。这是得到除零误差的唯一方法

当构造除法返回的新分数时，构造函数应该抛出一个异常

不要在divide（）方法中捕捉它；保留throws子句并删除try/catch。如果它是一个已检查的异常，您的测试用例必须捕获它

以下是我的写作方式：

package fraction;

public class Fraction implements Comparable
{
    private int numerator;
    private int denominator;

    public Fraction()
    {
        this(0);
    }

    public Fraction(int numerator)
    {
        this(numerator,1);
    }

    Fraction(int numerator, int denominator)
    {
        if (denominator == 0)
            throw new IllegalArgumentException("denominator cannot be zero");

        this.numerator = numerator;
        this.denominator = denominator;
        if (this.numerator*this.denominator < 0)
        {
            this.numerator = -Math.abs(this.numerator);
            this.denominator = Math.abs(this.denominator);
        }
        this.normalize();
    }

    public Fraction add(Fraction other)
    {
        return new Fraction(this.numerator*other.denominator+other.numerator*this.denominator, this.denominator*other.denominator);
    }

    public Fraction sub(Fraction other)
    {
        return new Fraction(this.numerator*other.denominator-other.numerator*this.denominator, this.denominator*other.denominator);
    }

    public Fraction mul(Fraction other)
    {
        return new Fraction(this.numerator*other.numerator, this.denominator*other.denominator);
    }

    public Fraction div(Fraction other)
    {
        return new Fraction(this.numerator*other.denominator, this.denominator*other.numerator);
    }

    @Override
    public boolean equals(Object o)
    {
        if (this == o)
        {
            return true;
        }
        if (o == null || getClass() != o.getClass())
        {
            return false;
        }

        Fraction fraction = (Fraction) o;

        if (denominator != fraction.denominator)
        {
            return false;
        }
        if (numerator != fraction.numerator)
        {
            return false;
        }

        return true;
    }

    @Override
    public int hashCode()
    {
        int result = numerator;
        result = 31 * result + denominator;
        return result;
    }

    public int compareTo(Object o)
    {
        Fraction other = (Fraction) o;

        int product1 = this.numerator*other.denominator;
        int product2 = other.numerator*this.denominator;

        return (product1-product2);
    }

    @Override
    public String toString()
    {
        return numerator + "/" + denominator;
    }

    private void normalize()
    {
        int sign = 1;
        if (this.numerator < 0)
        {
            sign = -1;
        }

        int gcd = greatestCommonDivisor(Math.abs(this.numerator), Math.abs(this.denominator));
        this.numerator /= gcd;
        this.denominator /= gcd;
        this.numerator *= sign;
    }

    public static int greatestCommonDivisor(int m, int n)
    {
        int a = Math.max(m, n);
        int b = Math.min(m, n);
        if (a == 0)
            return b;
        if (b == 0)
            return a;
        while (a != b)
        {
            if (b > a)
                b -= a;
            else
                a -= b;
        }
        return b;
    }
}

部分单元测试：

package fraction;

import org.junit.Assert;
import org.junit.Test;

public class FractionTest
{
    @Test
    public void testAdd()
    {
        Fraction x = new Fraction(3, 4);
        Fraction y = new Fraction(5, 8);
        Fraction expected = new Fraction(11, 8);
        Assert.assertEquals(expected, x.add(y));
    }

    @Test
    public void testSub()
    {
        Fraction x = new Fraction(3, 4);
        Fraction y = new Fraction(5, 8);
        Fraction expected = new Fraction(1, 8);
        Assert.assertEquals(expected, x.sub(y));
    }

    @Test
    public void testMul()
    {
        Fraction x = new Fraction(3, 4);
        Fraction y = new Fraction(5, 8);
        Fraction expected = new Fraction(15, 32);
        Assert.assertEquals(expected, x.mul(y));
    }


    @Test
    public void testDiv()
    {
        Fraction x = new Fraction(3, 4);
        Fraction y = new Fraction(5, 8);
        Fraction expected = new Fraction(6, 5);
        Assert.assertEquals(expected, x.div(y));
    }

    @Test
    public void testGreatestCommonDivisor()
    {
        Assert.assertEquals(Fraction.greatestCommonDivisor(48, 180), 12);
        Assert.assertEquals(Fraction.greatestCommonDivisor(40902, 24140), 34);
        Assert.assertEquals(Fraction.greatestCommonDivisor(2, 199), 1);
        Assert.assertEquals(Fraction.greatestCommonDivisor(11, 8), 1);
        Assert.assertEquals(Fraction.greatestCommonDivisor(1, 8), 1);
        Assert.assertEquals(Fraction.greatestCommonDivisor(15, 32), 1);
        Assert.assertEquals(Fraction.greatestCommonDivisor(6, 5), 1);
    }
}

Answer 3

将try/catch块添加到主方法中FractionDevidedByZeroException是一个已检查的异常。你应该用try/catch来包围他们。否则会出现编译错误

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Fraction frac1 = new Fraction(1,2);
    Fraction frac2 = new Fraction(1,3);
    try { 
         Fraction frac3 = frac1.divide(frac2); 
         System.out.println(frac3);
    } catch (FractionDevidedByZeroException e) {
        e.printStackTrace();
    }

}

Answer 4

您声明devide是一个抛出FractionDivideByZeroException的方法
测试函数必须捕获它
或函数不会引发此异常，因此throws FractionDivideByZeroException是多余的

Answer 5

从divide方法中去掉抛出声明。你把它扔出去，然后自己处理

你的FractionTest使用frac1。divide，编译器要求您处理divide方法中声明的异常