Java - Number To Word Converter

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.DecimalFormat;

public class NumberToWord {

        private static final String[] tensWords = { "", " ten", " twenty",
                        " thirty", " forty", " fifty", " sixty", " seventy", " eighty",
                        " ninety" };

        private static final String[] words = { "", " one", " two", " three",
                        " four", " five", " six", " seven", " eight", " nine", " ten",
                        " eleven", " twelve", " thirteen", " fourteen", " fifteen",
                        " sixteen", " seventeen", " eighteen", " nineteen" };

        /**
         * Convert Number to word which is less than one thousand
         *
         * @param number
         * @return
         */
        private String convertLessThanOneThousand(int number) {

                String thousandWord;

                if (number % 100 < 20) {
                        thousandWord = words[number % 100];
                        number /= 100;
                } else {
                        thousandWord = words[number % 10];
                        number /= 10;
                        thousandWord = tensWords[number % 10] + thousandWord;
                        number /= 10;
                }

                if (number == 0)
                        return thousandWord;

                return words[number] + " hundred" + thousandWord;
        }

        /**
         * Throws exception for negative and not supported input.
         *
         * @param number
         * @return
         * @throws Exception
         */
        private String notSupportedConvertion(long number) throws Exception {
                if (number < 0) {
                        throw new Exception("Negative numbers not supported");
                }

                if (number == 0) {
                        return "zero";
                }

                String snumber = Long.toString(number);
                if (snumber.length() > 13) {
                        throw new Exception(
                                        "Numbers greater than 999 billion are not supported");
                }
                return snumber;
        }

        /**
         * Converts any number to word between 1000 to 999 999 999 999 billions
         * millions
         *
         * @param number
         * @return
         * @throws Exception
         */
        public String convertNumber(int number) throws Exception {
                String snumber = Long.toString(number);

                notSupportedConvertion(number);

                if (number == 0) {
                        return "zero";
                }

                // pad with "0"
                String mask = "000000000000";

                // DecimalFormat converts 50 to 000000000050 based on the given mask
                DecimalFormat df = new DecimalFormat(mask);
                snumber = df.format(number);

                StringBuilder result = new StringBuilder();

                for (DigitOrder digitOrd : DigitOrder.values()) {
                        result.append(getWordForNumber(snumber, digitOrd));
                }

                return result.toString();
        }

        public static void main(String[] args) throws IOException {
                String word = "";
                int number = 0;
                BufferedReader bufferedReader = new BufferedReader(
                                new InputStreamReader(System.in));

                try {
                        System.out.print("Enter a Value: ");
                        word = bufferedReader.readLine();
                        number = Integer.parseInt(word);
                        word = new NumberToWord().convertNumber(number);
                        System.out.println(word);
                } catch (NumberFormatException ex) {
                        System.out.println("Entered value is not a number !");
                } catch (Exception e) {
                        System.out.println("error: " + e.getMessage());
                } finally {
                        if (bufferedReader != null) {
                                bufferedReader.close();
                        }
                }

        }

        public String getWordForNumber(String number, DigitOrder digit) {
                String name;

                String sp = new StringBuilder(number).reverse().substring(
                                digit.position - 3, (digit.position));

                String conv = new StringBuilder(sp).reverse().toString();

                int num = Integer.parseInt(conv);

                switch (num) {
                case 0:
                        name = "";
                        break;
                case 1:
                        if (digit == DigitOrder.HUNDREDTHOUSAND)
                                name = "one " + digit.name;
                        else
                                name = digit.name;
                        break;
                default:
                        if (digit == DigitOrder.THOUSAND)
                                name = convertLessThanOneThousand(num);
                        else
                                name = convertLessThanOneThousand(num) + digit.name;
                }

                return name;
        }

}

enum DigitOrder {
        MILLION(1, 9, "Million"), HUNDREDTHOUSAND(2, 6, "Thousand"), THOUSAND(3, 3,
                        "THOUSAND");

        int order;
        int position;
        String name;

        private DigitOrder(int order, int position, String name) {
                this.order = order;
                this.position = position;
                this.name = name;
        }

}