小菜鸟日记之java简单计算器（封装，异常处理练习）

小菜鸟日记1——记录一下最近写的代码
题目要求：
编写一个2个操作数1个运算符的四则运算器，前台文本框直接输入数字，后台判断并计算，符号统一“+、-、*、/”
处理异常：
输入的字符不是正数或加减乘除
除数=0
结果出现负数和小数（分数）
——————————-——————————————
我第一次提交的代码：

package com.company;
import java.util.Scanner;
public class Calculator {
    public static void main(String[] args) {
        String condition=" ";
        Calculator calculator = new Calculator();
        do{
            Scanner scanner = new Scanner(System.in);
            try{
                System.out.print("请输入第一个数：");
                double x = scanner.nextDouble();
                System.out.print("请输入第二个数：");
                double y = scanner.nextDouble();
                if (x<0||y<=0) {
//                    制造异常
                    String WrongNumber=null;
                    WrongNumber="~~";
                }
            //    当x，y为非正数时抛出异常，提示请输入正确的数据
                System.out.print("请输入运算符：");
                String s = scanner.next();
                char z = s.charAt(0);
//                用z检验并表示运算符
                calculator.calculate(x, y, z);
            }catch(Exception e){
                System.out.println("请输入正确的数据！");
            }
            System.out.print("是否继续？1：继续，其他键：结束");
            condition = scanner.next();
        }while(condition.equals("1"));
//        当输入为yes时才进入下一次循环
    }
    public void calculate(double x, double y, char z) {
         double sum = 0;
//         用来表示计算结果
        if(z=='+'){
            sum= x+y;
        } else if(z=='-'){
          sum= x-y;
        } else if(z=='*'){
           sum=x*y;
        } else if(z=='/') {
            sum = x / y;
        }
        else{
//            非有效字符，制造抛出
            int []flat= new int[2];
            flat[2]=1;
        }
        if (sum-(new Double(sum).intValue())==0) {
            System.out.println(new Double(sum).intValue());
//            这里我的想法是把double转化为int判断小数点后是否为0进而判断整数
            }
        else {
//            结果不是整数，制造一个数组越界的异常抛出
            int []flat= new int[2];
            flat[2]=1;
        }
    }
}

被学长残忍的驳回了。。。。
问题：
米有将异常对象进行封装，Exception将异常通吃了，只有泛泛的一句提示语
然后是dowhile结构，当出现异常之后直接退出了不符合要求
于是我宵衣旰食，昼夜不眠地修改我的代码！

public class Calculator {
    public Calculator() {
    }

    public static void main(String[] args) {
        Scanner a = new Scanner(System.in);
        System.out.println("请输入需要计算的数及运算符号");
        boolean flag = true;
        while(true) {
            while(flag) {
                System.out.println("请输入第一个数字，以回车结束");
                String one_1 = a.next();
                double one = (double)Integer.parseInt(one_1);
                System.out.println("请输入运算符，以回车结束");
                String symbol = a.next();
                System.out.println("请输入第二个数字，以回车结束");
                String two_1 = a.next();
                double two = (double)Integer.parseInt(two_1);
                Abnormal abnormal = new Abnormal();
                double output = 0.0D;
                try {
                    abnormal.input1(one, two);
                } catch (InputException var22) {
                    System.out.println("输入的两个数不是正数");
                    var22.printStackTrace();
                }

                try {
                    abnormal.input2(symbol);
                } catch (InputException var21) {
                    System.out.println("输入的运算符号不正确");
                    var21.printStackTrace();
                }
                try {
                    abnormal.input3(two, symbol);
                } catch (InputException var20) {
                    System.out.println("除数为零，请重新输入");
                    var20.printStackTrace();
                }
                byte var14 = -1;
                switch(symbol.hashCode()) {
                case 42:
                    if (symbol.equals("*")) {
                        var14 = 2;
                    }
                    break;
                case 43:
                    if (symbol.equals("+")) {
                        var14 = 0;
                    }
                case 44:
                case 46:
                default:
                    break;
                case 45:
                    if (symbol.equals("-")) {
                        var14 = 1;
                    }
                    break;
                case 47:
                    if (symbol.equals("/")) {
                        var14 = 3;
                    }
                }
                switch(var14) {
                case 0:
                    Addition addition = new Addition();
                    addition.calculate(one, two);
                    output = addition.output;
                    break;
                case 1:
                    Subtraction subtraction = new Subtraction();
                    subtraction.calculate(one, two);
                    output = subtraction.output;
                    break;
                case 2:
                    Multiplication multiplication = new Multiplication();
                    multiplication.calculate(one, two);
                    output = multiplication.output;
                    break;
                case 3:
                    Division division = new Division();
                    division.calculate(one, two);
                    output = division.output;
                }
                try {
                    abnormal.output(output);
                } catch (OutputException var19) {
                    System.out.println("输出的结果有小数或者是负数");
                    var19.printStackTrace();
                }
                boolean flag_1 = true;
                while(flag_1) {
                    System.out.println("****是否继续计算（是/否：1/0）****");
                    int n = a.nextInt();
                    if (n == 1) {
                        flag = true;
                        break;
                    }
                    if (n == 0) {
                        System.out.println("****谢谢您的计算****");
                        flag = false;
                        break;
                    }
                    System.out.println("****输入的信息不正确****");
                }
            }
            return;
        }
    }
}

然后是对异常对象的封装：

public class Abnormal {
    public Abnormal() {
    }

    public void input1(double one, double two) throws InputException {
        if (one < 0.0D || two < 0.0D) {
            throw new InputException();
        }
    }

    public void input2(String symbol) throws InputException {
        if (!symbol.equals("+") && !symbol.equals("-") && !symbol.equals("*") && !symbol.equals("/")) {
            throw new InputException();
        }
    }

    public void input3(double two, String symbol) throws InputException {
        if (two == 0.0D && symbol.equals("/")) {
            throw new InputException();
        }
    }

    public void output(double result) throws OutputException {
        if (result - (double)((int)result) != 0.0D || result < 0.0D) {
            throw new OutputException();
        }
    }
}

要问我的代码为什么一下子高大上了这么多，还不是因为无数次WrongAnswer。。。。