[HackerRank]Java計算體積(Java Calculating Volume)

題目描述

輸入一個整數ch，這個ch整數值所代表的意義如下：

撰寫一個Calculate類別，分別按照上面的要求實作出不同的方法，要將計算結果省略至小數點第3位來輸出。

若輸入的長度小於0，要輸出「java.lang.NumberFormatException: All the values must be positive」。

原題網址

輸入格式

第一行輸入一個整數T，表示測試資料的數量，接下來的T組資料，一開始要先輸入ch值，範圍在1到4之間(包含1和4)，接著依照ch的不同而有以下幾種不一樣的輸入：

a、l、b、h、r的值皆在-100到100之間(包含-100和100)。

輸出格式

計算每組測試資料，輸出四捨五入至小數點後第三位的計算結果。

範例輸入1

範例輸出1

額外解釋1

在這兩組測試資料中，第一組測試資料的ch為1，所以是要計算正方體的體積。接下來輸入的a為4，正方體體積算法為：

第一組測試資料的ch為4，所以是要計算圓柱體的體積，但輸入的圓柱體高度是負數，因此輸出「java.lang.NumberFormatException: All the values must be positive」。

範例輸入2

範例輸出2

解題概念

實作Calculating類別來處理標準輸入串流和實際用來計算體積的物件。實作Volume類別來計算體積。實作Printer類別來處理小數點輸出和輸入負數的輸出。

參考答案

import java.io.IOException;
import java.security.Permission;
import java.util.Scanner;

class Printer {

    public void display(final double volume) throws IOException {
        if (volume > 0) {
            System.out.printf("%.3f%n", volume);
        } else {
            System.out.println("java.lang.NumberFormatException: All the values must be positive");
            throw new IOException();
        }
    }
}

class Volume {

    public double main(final int a) {
        return a * a * a;
    }

    public double main(final int l, final int b, final int h) {
        return l * b * h;
    }

    public double main(final double r) {
        return 2 * Math.PI * r * r * r / 3;
    }

    public double main(final double r, final double h) {
        return Math.PI * r * r * h;
    }
}

class Calculate {

    private static final Scanner sc = new Scanner(System.in);
    private static final Volume v;
    public static final Printer output = new Printer();

    static {
        v = new Volume();
    }

    public static Volume get_Vol() {
        return v;
    }

    public int getINTVal() {
        return sc.nextInt();
    }

    public double getDoubleVal() {
        return sc.nextDouble();
    }
}

public class Solution {

    public static void main(final String[] args) {
        Do_Not_Terminate.forbidExit();
        try {
            final Calculate cal = new Calculate();
            int T = cal.getINTVal();
            while (T-- > 0) {
                double volume = 0.0d;
                final int ch = cal.getINTVal();
                switch (ch) {
                    case 1:
                        final int a = cal.getINTVal();
                        volume = Calculate.get_Vol().main(a);
                        break;
                    case 2: {
                        final int l = cal.getINTVal();
                        final int b = cal.getINTVal();
                        final int h = cal.getINTVal();
                        volume = Calculate.get_Vol().main(l, b, h);
                        break;
                    }
                    case 3: {
                        final double r = cal.getDoubleVal();
                        volume = Calculate.get_Vol().main(r);
                        break;
                    }
                    case 4: {
                        final double r = cal.getDoubleVal();
                        final double h = cal.getDoubleVal();
                        volume = Calculate.get_Vol().main(r, h);
                        break;
                    }
                    default:
                        break;
                }
                cal.output.display(volume);
            }

        } catch (NumberFormatException e) {
            System.out.print(e);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Do_Not_Terminate.ExitTrappedException e) {
            System.out.println("Unsuccessful Termination!!");
        }
    }
}

class Do_Not_Terminate {

    public static class ExitTrappedException extends SecurityException {
    }

    public static void forbidExit() {
        final SecurityManager securityManager = new SecurityManager() {
            @Override
            public void checkPermission(final Permission permission) {
                if (permission.getName().contains("exitVM")) {
                    throw new ExitTrappedException();
                }
            }
        };
        System.setSecurityManager(securityManager);
    }
}