как правильно разбить данный код на 3 класса?

import java.util.*;
import java.util.Map.Entry;

public class Test {

    public static void main(String[] args) {

        //// Задание 1:
       
        // Создаём список квадратов
        List<Integer> numbers = createRealNumbers(30);
        // Сортируем квадраты на чётные и нечётные
        OddsAndEvensResult sortResult = sortOddsAndEvens(numbers);
       
        // Это результаты задания 1:
        Integer[] odds = sortResult.getOdds().toArray(new Integer[0]);
        Integer[] evens = sortResult.getEvens().toArray(new Integer[0]);
        // -----
       
       
        //// Задание 2:
       
        // Сортируем строку
        LettersSortResult lsortResult = sortLetters("some simple string wis lots ofs as's and sim imount of iiiiis");
       
        // Это результаты задания 2:
        Character[] topLetters = lsortResult.getTops();
        int topLettersCount = lsortResult.getCount();
        // -----
       
        //// Задание 3:

        // Парсим аргументы
        ArgsParseResult parseResult = parseArgs(args);
        Equality eq = parseResult.getEqualityType();
        int equaler = parseResult.getEqualer();

        // Сортируем полученные ранее квадраты
        List<Integer> sorted = sortNumbersByEquality(numbers, eq, equaler);
       
        // Это результат задания 3:
        Integer[] sortedNums = sorted.toArray(new Integer[0]);
        // -----
       
        System.out.println(sorted.size() > 0 ? sorted : "[No match]");
    }
   
    private static List<Integer> createRealNumbers(final int n) {

        List<Integer> numbers = new ArrayList<Integer>(n);
       
        for (int i = 1; i <= n; i++) {
            numbers.add((int) Math.pow(i, 2));
        }
       
        return numbers;
    }

    private static OddsAndEvensResult sortOddsAndEvens(List<Integer> numbers) {

        if (numbers == null) throw new IllegalArgumentException();

        int cap = (numbers.size() / 2) + 1;
        final List<Integer> odds = new ArrayList<Integer>(cap);
        final List<Integer> evens = new ArrayList<Integer>(cap);
       
        for (int i : numbers) {
               
            if (i % 2 == 0) {
                   
                evens.add(i);
            }
            else {
                   
                odds.add(i);
            }
        }
       
        return new OddsAndEvensResult() {
           
            @Override
            public List<Integer> getOdds() {
                return odds;
            }
           
            @Override
            public List<Integer> getEvens() {
                return evens;
            }
        };
    }
   
    private static interface OddsAndEvensResult {
        List<Integer> getOdds();
        List<Integer> getEvens();
    }
   
    private static List<Integer> sortNumbersByEquality(List<Integer> numbers, Equality equality, int equaler) {
       
        List<Integer> list = new ArrayList<Integer>();
        for (int i : numbers) {
           
            if (equality.isEqual(i, equaler)) {
               
                list.add(i);
            }
        }
       
        return list;
    }
   
    private static LettersSortResult sortLetters(String input) {

        Map<Character, Integer> map = new HashMap<Character, Integer>();
        Integer i;
        for (Character c : input.toCharArray()) {
           
            if (!Character.isWhitespace(c)) {
               
                i = map.containsKey(c) ? map.get(c) + 1 : 1;
                map.put(c, i);
            }
        }

        int count = 0;
        List<Character> topLetters = new ArrayList<Character>();
       
        for (Entry<Character, Integer> entry : map.entrySet()) {
           
            int value = entry.getValue();
            if (value > count) {
               
                topLetters.clear();
                topLetters.add(entry.getKey());
                count = value;
            }
            else if (value == count) {
               
                topLetters.add(entry.getKey());
            }
        }
       
        final Character[] tops = topLetters.toArray(new Character[0]);
        final int topsCount = count;
                       
        return new LettersSortResult() {
           
            @Override
            public Character[] getTops() {
                return tops;
            }
           
            @Override
            public int getCount() {
                return topsCount;
            }
        };
    }
   
    private static interface LettersSortResult {
        Character[] getTops();
        int getCount();
    }
   
    enum Equality {
       
        ALL {
            @Override
            boolean isEqual(int num, int equaler) {
                return true;
            }
        },
        LESS {
            @Override
            boolean isEqual(int num, int equaler) {
                return num < equaler;
            }
        },
        LESS_OR_EQUAL {
            @Override
            boolean isEqual(int num, int equaler) {
                return num <= equaler;
            }
        },
        GREAT {
            @Override
            boolean isEqual(int num, int equaler) {
                return num > equaler;
            }
        },
        GREAT_OR_EQUAL {
            @Override
            boolean isEqual(int num, int equaler) {
                return num >= equaler;
            }
        },
        EQUAL {
            @Override
            boolean isEqual(int num, int equaler) {
                return num == equaler;
            }
        };
       
        abstract boolean isEqual(int num, int equaler);
       
        static Equality getByString(String s) {
           
            if (s.length() == 1) {
                char c = s.charAt(0);
                switch (c) {
               
                    case '<': return LESS;
                    case '>': return GREAT;
                    case '=': return EQUAL;
                }
            }
            else if (s.equals("<=")) {
                return LESS_OR_EQUAL;
            }
            else if (s.equals(">=")) {
                return GREAT_OR_EQUAL;
            }
           
            return null;
        }
    }

    private static ArgsParseResult parseArgs(String[] args) {
       
        Equality equality = Equality.ALL;
        int equaler = 0;
       
        argsparse: if (args.length > 0) {

            if (args.length == 2) {
               
                statement: {
               
                    String statement = args[0];
                    if (statement.length() == 1 || statement.length() == 2) {
                       
                        Equality e = Equality.getByString(statement);
                        if (e != null) {
                           
                            equality = e;
                            break statement;
                        }
                    }
                   
                    System.err.println("Wront statement format!\nAll by default:\n");
                    break argsparse;
                }
           
                String number = args[1];
                try {
                       
                    equaler = Integer.parseInt(number);
                       
                } catch (NumberFormatException e) {
                       
                    System.err.println("Wrong number format!\nAll by default:\n");
                    break argsparse;
                }
            }
            else {
               
                System.out.println(
                        "Wrong arguments format!\n" +
                        "Use: <statement> <number>\n" +
                        "Where <statement> is one of: \"<\", \">\", \"<=\", \">=\", \"=\"\n" +
                        "All by default:\n");
            }
        }
       
        final Equality requality = equality;
        final int requaler = equaler;
       
        return new ArgsParseResult() {
           
            @Override
            public Equality getEqualityType() {
                return requality;
            }
           
            @Override
            public int getEqualer() {
                return requaler;
            }
        };
    }
   
    private static interface ArgsParseResult {
        Equality getEqualityType();
        int getEqualer();
    }
}