Определить числовые свойства

Я делаю программу о числах. Пользователь введет число и получит его свойства.

Цели программы

  1. Приветствуем пользователей;
  2. Отобразите инструкции;
  3. Попросите запрос;
  4. Если пользователь вводит ноль, завершить программу;
  5. Если числа не натуральные, распечатайте сообщение об ошибке;
  6. Если указано неверное свойство, распечатайте сообщение об ошибке и список доступных свойств;
  7. Для одного числа вычислите и распечатайте свойства числа;
  8. Для двух чисел выведите список чисел с их свойствами;
  9. Для двух чисел и одного свойства выведите только числа с этим свойством;
  10. Для двух чисел и двух свойств выведите числа, которые имеют оба свойства.
  11. Если пользователь указывает взаимоисключающие свойства, прервите запрос и предупредите пользователя.
  12. После обработки запроса продолжайте выполнение с шага 3.

Имена свойств включают четный, нечетный, гудящий, утиный, палиндромный, разрывной, шпионский, квадратный и солнечный.

Код

package numbers;


import java.util.Scanner;


public class Main {
    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        //        write your code here
        Numbers.welcome();
        Numbers.request();
        while (true) {
            System.out.print("Enter a request: ");
            String number = input.nextLine();
            String[] numberArray = number.split(" ");
            if (numberArray.length == 1) {
                if (numberArray[0].equals("0")) {
                    break;
                } else {
                    System.out.println("The first parameter should be a natural number or zero.");
                }
                Numbers.getPropertiesOfNumber(number);
            }
            if (numberArray.length == 2) {
                if (Numbers.isNatural(Long.parseLong(numberArray[0]))) {
                    System.out.println("The first parameter should be a natural number or zero.");
                    continue;
                }
                if (Numbers.isNatural(Long.parseLong(numberArray[1]))) {
                    System.out.println("The second parameter should be a natural number.");
                    continue;
                }
                long num1 = Long.parseLong(numberArray[0]);
                long num2 = Long.parseLong(numberArray[1]);
                for (long i = num1; i < num1 + num2; i++) {
                    Numbers.getPropertiesOfNumberSequence(i);
                    System.out.println();
                }
            }
            if (numberArray.length == 3) {
                if (Numbers.isNatural(Long.parseLong(numberArray[0]))) {
                    System.out.println("The first parameter should be a natural number or zero.");
                    continue;
                }
                if (Numbers.isNatural(Long.parseLong(numberArray[1]))) {
                    System.out.println("The second parameter should be a natural number.");
                    continue;
                }
                String parameter = numberArray[2];
                if (!Numbers.requestList.contains(parameter.toUpperCase())) {
                    StringBuilder errorOutput = new StringBuilder();
                    errorOutput.append("The property [").append(parameter.toUpperCase()).append("] is wrong.");
                    errorOutput.append("nAvailable properties: [").append(Numbers.requestList + "]");
                    System.out.println(errorOutput);
                } else {
                    long num1 = Long.parseLong(numberArray[0]);
                    long num2 = Long.parseLong(numberArray[1]);
                    Numbers.getPropertiesOfNumberWithParameter(num1, num2, parameter);

                }

            }
            if (numberArray.length == 4) {
                if (Numbers.isNatural(Long.parseLong(numberArray[0]))) {
                    System.out.println("The first parameter should be a natural number or zero.");
                    continue;
                }
                if (Numbers.isNatural(Long.parseLong(numberArray[1]))) {
                    System.out.println("The second parameter should be a natural number.");
                } else {
                    long num1 = Long.parseLong(numberArray[0]);
                    long num2 = Long.parseLong(numberArray[1]);
                    String parameter1 = numberArray[2].toLowerCase();
                    String parameter2 = numberArray[3].toLowerCase();
                    Numbers.checkParameters(num1, num2, parameter1, parameter2);
                }
            }

        }
        System.out.println("Goodbye!");
    }


}

class Numbers {
    public final static String requestList = "BUZZ, DUCK, PALINDROMIC, GAPFUL, SPY, SQUARE, SUNNY, EVEN, ODD";

    public static void request() {
        StringBuilder output = new StringBuilder();
        output.append("nSupported requests: ");
        output.append("n- enter a natural number to know its properties;");
        output.append("n- enter two natural numbers to obtain the properties of the list:");
        output.append("n  * the first parameter represents a starting number;");
        output.append("n  * the second parameters show how many consecutive numbers are to be processed;");
        output.append("n- two natural numbers and a properties to search for;");
        output.append("n- separate the parameters with one space;");
        output.append("n- enter 0 to exit.n");
        System.out.println(output);

    }

    public static void welcome() {
        System.out.println("Welcome to Amazing Numbers!");
    }

    public static boolean isNatural(long num) {
        return num <= 0;
    }

    public static boolean isEven(long num) {
        return num % 2 == 0;
    }

    public static boolean isOdd(long num) {
        return num % 2 != 0;
    }

    public static boolean isBuzzNumber(long num) {
        return num % 7 == 0 || num % 10 == 7;
    }

    public static boolean isDuckNumber(long num) {
        String number = num + "";
        return number.contains("0");
    }

    public static boolean isPalindromicNumber(long num) {
        String number = num + "";
        for (int i = 0; i < number.length() / 2; i++) {
            if (number.charAt(i) != number.charAt(number.length() - i - 1)) {
                return false;
            }
        }
        return true;
    }

    public static boolean isGapfulNumber(long num) {
        String number = num + "";
        if (number.length() > 2) {
            String str = "";
            str += number.charAt(0) + "" + number.charAt(number.length() - 1);
            return Long.parseLong(number) % Long.parseLong(str) == 0;
        }
        return false;
    }

    public static boolean isSpyNumber(long num) {
        String number = num + "";
        int sum = 0;
        int product = 1;
        for (int i = 0; i < number.length(); i++) {
            int temp = Integer.parseInt(number.charAt(i) + "");
            sum += temp;
            product *= temp;
        }
        return sum == product;
    }

    public static boolean isSquareNumber(long num) {
        long sqrt = (long) Math.sqrt(num);
        return sqrt * sqrt == num;
    }

    public static boolean isSunnyNumber(long num) {
        return isSquareNumber(num + 1);
    }

    public static void getPropertiesOfNumber(String number) {
        long num = Long.parseLong(number);
        StringBuilder output = new StringBuilder();
        if (isNatural(num)) {
            System.out.println("The first parameter should be a natural number or zero.");
        } else {
            output.append("Properties of ").append(number);
            output.append("nt   buzz: ").append(isBuzzNumber(num));
            output.append("nt   duck: ").append(isDuckNumber(num));
            output.append("npalindromic: ").append(isPalindromicNumber(num));
            output.append("nt gapful: ").append(isGapfulNumber(num));
            output.append("nttspy: ").append(isSpyNumber(num));
            output.append("nt square: ").append(isSquareNumber(num));
            output.append("nt  sunny: ").append(isSunnyNumber(num));
            output.append("nt   even: ").append(isEven(num));
            output.append("nttodd: ").append(isOdd(num));
            System.out.println(output);
        }
    }

    public static void getPropertiesOfNumberSequence(long i) {
        StringBuilder output = new StringBuilder();
        output.append(i).append(" is");
        if (isBuzzNumber(i)) {
            output.append(" buzz");
        }
        if (isDuckNumber(i)) {
            output.append(" duck");
        }
        if (isPalindromicNumber(i)) {
            output.append(" palindromic");
        }
        if (isGapfulNumber(i)) {
            output.append(" gapful");
        }
        if (isSpyNumber(i)) {
            output.append(" spy");
        }
        if (isSquareNumber(i)) {
            output.append(" square");
        }
        if (isSunnyNumber(i)) {
            output.append(" sunny");
        }
        if (isEven(i)) {
            output.append(" even");
        }
        if (isOdd(i)) {
            output.append(" odd");
        }
        System.out.println(output);
    }

    public static void getPropertiesOfNumberWithParameter(long num1, long num2, String parameter) {
        long i = 1;
        parameter = parameter.toLowerCase();
        while (i <= num2) {
            switch (parameter) {
                case "buzz":
                    if (isBuzzNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "duck":
                    if (isDuckNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "palindromic":
                    if (isPalindromicNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "gapful":
                    if (isGapfulNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "spy":
                    if (isSpyNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "square":
                    if (isSquareNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "sunny":
                    if (isSunnyNumber(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "even":
                    if (isEven(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
                case "odd":
                    if (isOdd(num1)) {
                        getPropertiesOfNumberSequence(num1);
                        i++;
                    }
                    break;
            }
            num1++;
        }


    }

    public static void getSeveralProperties(long num1, long num2, String parameter1, String parameter2) {
        long i = 1;
        parameter1 = parameter1.toLowerCase();
        parameter2 = parameter2.toLowerCase();
        while (i <= num2) {
            switch (parameter1) {
                case "buzz":
                    switch (parameter2) {
                        case "buzz":
                            if (isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isBuzzNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isBuzzNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isBuzzNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isBuzzNumber(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isBuzzNumber(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isBuzzNumber(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isBuzzNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isBuzzNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
                case "duck":
                    switch (parameter2) {
                        case "buzz":
                            if (isBuzzNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isDuckNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isDuckNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isDuckNumber(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isDuckNumber(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isDuckNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isDuckNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
                case "palindromic":
                    switch (parameter2) {
                        case "buzz":
                            if (isPalindromicNumber(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isPalindromicNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isPalindromicNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isPalindromicNumber(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isPalindromicNumber(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isPalindromicNumber(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isPalindromicNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isPalindromicNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
                case "gapful":
                    switch (parameter2) {
                        case "buzz":
                            if (isGapfulNumber(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isGapfulNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isGapfulNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isGapfulNumber(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isGapfulNumber(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isGapfulNumber(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isGapfulNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isGapfulNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
                case "spy":
                    switch (parameter2) {
                        case "buzz":
                            if (isSpyNumber(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isSpyNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isSpyNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isSpyNumber(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isSpyNumber(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isSpyNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isSpyNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
                case "square":
                    switch (parameter2) {
                        case "buzz":
                            if (isSquareNumber(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isSquareNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isSquareNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isSquareNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isSquareNumber(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isSquareNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isSquareNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                    }
                    break;
                case "sunny":
                    switch (parameter2) {
                        case "buzz":
                            if (isSunnyNumber(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isSunnyNumber(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isSunnyNumber(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isSunnyNumber(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isSunnyNumber(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isSunnyNumber(num1) && isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isSunnyNumber(num1) && isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                    }
                    break;
                case "even":
                    switch (parameter2) {
                        case "buzz":
                            if (isEven(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isEven(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isEven(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isEven(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isEven(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isEven(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isEven(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "even":
                            if (isEven(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                    }
                    break;
                case "odd":
                    switch (parameter2) {
                        case "buzz":
                            if (isOdd(num1) && isBuzzNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "duck":
                            if (isOdd(num1) && isDuckNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "palindromic":
                            if (isOdd(num1) && isPalindromicNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "gapful":
                            if (isOdd(num1) && isGapfulNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "spy":
                            if (isOdd(num1) && isSpyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "square":
                            if (isOdd(num1) && isSquareNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "sunny":
                            if (isOdd(num1) && isSunnyNumber(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;
                        case "odd":
                            if (isOdd(num1)) {
                                getPropertiesOfNumberSequence(num1);
                                i++;
                            }
                            break;

                    }
                    break;
            }
            num1++;
        }
    }

    public static void mutuallyExclusiveError(String parameter1, String parameter2) {
        System.out.println("The request contains mutually exclusive properties: [" +
                parameter1.toUpperCase() + ", " + parameter2.toUpperCase() + "]n" +
                "There are no numbers with these properties.");
    }

    public static boolean isMutuallyExclusive(String parameter1, String parameter2) {
        String[] mutualParameters1 = new String[]{"even odd", "spy duck", "sunny square"};
        String[] mutualParameters2 = new String[]{"odd even", "duck spy", "square sunny"};
        String parameter = parameter1 + " " + parameter2;
        for (int i = 0; i < mutualParameters1.length; i++) {
            if (parameter.equals(mutualParameters1[i]) || parameter.equals(mutualParameters2[i])) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkParameter(String parameter) {
        String[] parameters = requestList.split(", ");
        for (String s : parameters) {
            if (parameter.equalsIgnoreCase(s)) {
                return false;
            }
        }
        return true;
    }

    public static void checkParameters(long num1, long num2, String parameter1, String parameter2) {
        if (isMutuallyExclusive(parameter1, parameter2)) {
            mutuallyExclusiveError(parameter1, parameter2);
        } else if (checkParameter(parameter1) && checkParameter(parameter2)) {
            System.out.println("The properties [" + parameter1.toUpperCase() + ","
                    + parameter2.toUpperCase() + "] are wrong.n" +
                    "Available properties: " + "[" + requestList + "]");
        } else if (checkParameter(parameter1)) {
            System.out.println("The property [" + parameter1.toUpperCase() + "] is wrong.n" +
                    "Available properties: [" + requestList + "]");
        } else if (checkParameter(parameter2)) {
            System.out.println("The property [" + parameter2.toUpperCase() + "] is wrong.n" +
                    "Available properties: [" + requestList + "]");
        } else {
            getSeveralProperties(num1, num2, parameter1, parameter2);
        }
    }


}

Этот код работает нормально.

Но мне кажется, что я напортачил с этим кодом. Например, в getSeveralProperties() метод, я использовал switch внутри switch, и мой код стал дублироваться, а не СУХОЙ. И есть еще много примеров. Особенно с методами get … ().

2 ответа
2

Насколько я понимаю, вы новичок, которому не хватает некоторых знаний. Но работа сделана хорошо. Некоторые соображения:

Комментарии

Идеальный код должен использовать имена идентификаторов, чтобы избежать комментариев; у вашего кода есть хорошие имена и один ненужный комментарий в начале. Но, с другой стороны, у вас есть хорошее описание задачи для комментариев. Вы можете разбить его на комментарии, чтобы любой мог найти в коде каждую часть задачи.

Используйте разные классы для разных задач

Ваш Numbers class выполняет 2 вещи: вывод и вычисления. В более крупном проекте вам следует разбить эту функциональность на несколько классов.

Использовать else если ifявляются взаимоисключающими, и switch если вы отметите одно значение

if(numberArray.length == 1)
...
else if(numberArray.length == 2)
...

или даже

switch(numberArray.length)
    case 1:
        ....

requestList должен быть массив

Так что не стоит каждый раз разделять его. Кроме того, константы обычно называются в FULL_UPPER_CASE.

Повернуть whiles с известными границами в fors

long i = 1;
...
while (i <= num2) 
{
    ....
    i++;// in every branch
}

просто

for(long i=1; i<=num2; i++)

Теперь к твоей проблеме

Во-первых, AFAIS, i++ происходит во всех ветвях — поэтому вы можете переместить его, если переключитесь и сделайте один раз, до или после. Во-вторых, я полагаю, вы не знакомы с техникой флагов, картами и ссылками на методы. Тем не менее, вы можете СУШИТЬ код. Представьте, что у вас есть метод Numbers:

public static boolean hasNumberProperty(long number, String property)

так hasNumberProperty(10, 'buzz') позвонит и вернется isBuzzNumber(10). Вы понимаете, в чем дело? Все switchобъединены в один маленький switchвнутри этого hasNumberProperty. Все большие заявления о переключении превращаются в

if(hasNumberProperty(number1, parameter1) and hasNumberProperty(number2, parameter2))
{
    getPropertiesOfNumberSequence(num1);
}
i++;

Еще немного чистки кода

В checkParameters, checkParameter вызывается несколько раз с одинаковыми аргументами. Эта работа избыточна, поэтому я покажу вам очень секретную технику флага:

int parameter1Ok = 0;
if(checkParameter(parameter1))
    parameter1Ok = 1;
/*the same for parameter 2*/
...
if(parameter1Ok==1 and parameter2Ok==1)
...
else if(parameter1Ok)

Флаги (переменные параметр1Ok и параметр2Ok) позволяют сохранить знак некоторого свойства и впоследствии проверить его без пересчета. Логические флаги встречаются гораздо чаще — попробуйте превратить этот код в логические флаги, вы увидите, почему.

    Например, в getSeveralProperties() Метод, я использовал переключатель внутри переключателя, и мой код дублировался, а не СУХИЙ.

    Вы можете исправить это, создав Property интерфейс с реализациями для четного, солнечного и т. д. Тогда, вместо использования вложенных переключателей, вы могли бы просто сказать

    for (long i = 1; i < top; i++) {
        if (Numbers.holdsAll(number, properties)) {
            getPropertiesOfNumberSequence(number);
        }
    }
    

    Я также переименовал num1 к number и num2 к top как более информативный. Я перешел с двух свойств на коллекцию произвольного размера. Это также позволит вам комбинировать одиночный корпус с парным, а также учесть возможность расширения в будущем.

    public static boolean holdsAll(long number, Iterable<Property> properties) {
        foreach (Property property : properties) {
            if (!property.isHeldBy(number)) {
                return false;
            }
        }
    
        return true;
    }
    

    Обратите внимание, что пока я называю это Iterable здесь я бы, вероятно, реализовал его как ArrayList при инициализации. Но единственное, что требуется, это чтобы это была какая-то форма Iterable таким образом foreach работает.

    Реализация будет выглядеть так

    class Even implements Property {
    
        public function isHeldBy(long number) {
            return number % 2 == 0;
        }
    
    }
    

    Некоторое время до звонка getSeveralProperties, вам нужно будет преобразовать строки в свойства, но это будет намного проще и потребуется сделать только один раз. Что-то типа

    public convertParameterToProperty(String parameter) {
        switch (parameter) {
            case "even":
                return new Even();
    

    Очевидно, с футлярами для каждого типа. Или

    private static final Map<String, Property> PROPERTY_DICTIONARY = new HashMap<>();
    
    static {
        PROPERTY_DICTIONARY.put("even", new Even());
    

    (снова записи для каждого типа) с

    public static Property convertParameterToProperty(String parameter) {
        return PROPERTY_DICTIONARY.get(parameter);
    }
    

    Другой альтернативой было бы проделать то же самое с enum где каждое значение определяет свое собственное isHeldBy метод.

    Эти подходы были бы намного СУХЕЕ, чем то, что у вас есть сейчас. Т.е. мое наблюдение за кодом заключается в том, что вы можете заменить вложенные переключатели либо реализациями интерфейса, либо enum СУШИТЬ код.

      Добавить комментарий

      Ваш адрес email не будет опубликован. Обязательные поля помечены *