addStringPOJO(4) - 정적 메서드로 변경

import io.Input;
import io.Output;

public class Main {
    public static void main(String[] args) {

        
        while (true){
            Input input = new Input();
            Calculate calculate = new Calculate(input.getResult());
            int result = calculate.calculate();
            Output output = new Output(result);
        }
    }

}

package io;

import process.NumberExtract;
import process.AdditionSeparator;
import validation.Validation;
import java.util.List;
import java.util.Scanner;

public class Input {

    private final Scanner scanner;
    private String input ;
    private String[] result;

    public Input(){
        this.scanner = new Scanner(System.in);
        while (true) {
            this.input= scanner.nextLine();
            try {
                Validation.validateInput(input);
                List<String> separatorList = AdditionSeparator.separatorList;
                this.result = NumberExtract.split(input, separatorList);
                break;
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            }
        }
    }

    public String[] getResult(){
        return result;
    }

}

package process;

import validation.CustomSeparator;
import validation.Validation;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class AdditionSeparator {

    public static List<String> separatorList = new ArrayList<>(Arrays.asList(",", ":"));

    public static String extractCustom(String input) {
        int prefixLength = CustomSeparator.CUSTOM_START_WITH.length(); //커스텀 문자열의 시작 문자열이 바뀔 수도 있기 때문에 상수를 가져와서 길이 반환
        int newlineIndex = input.indexOf(CustomSeparator.CUSTOM_NEWLINE); //커스텀 문자열의 끝 문자열이 바뀔 수도 있기 때문에 상수로 가져와, 해당 인덱스 반환
        String customSeparator = input.substring(prefixLength, newlineIndex);
        return customSeparator;
    }

    public static void addCustomSeparator(String customSeparator) {
        Validation.hasDuplicationCustomSeparator(customSeparator);
        separatorList.add(customSeparator);
    }

}

package process;

import validation.CustomSeparator;
import validation.Validation;

import java.util.List;

public class NumberExtract {

    public static String replace(String input, List<String> separatorList) {
        separatorList.add(CustomSeparator.CUSTOM_NEWLINE);
        separatorList.add(CustomSeparator.CUSTOM_START_WITH);
        String replaceString = input;
        for (String separator : separatorList) {
            replaceString = replaceString.replace(separator, Validation.BLANK);
        }
        return replaceString;
    }

    public static String[] split(String input, List<String> separatorList) {
        String replaceString = replace(input, separatorList);
        return replaceString.split(Validation.BLANK);
    }

}

package validation;

public class CustomSeparator {

    public static final String CUSTOM_START_WITH = "//";
    public static final String CUSTOM_NEWLINE = "\\n";

}

package validation;

import process.AdditionSeparator;
import process.NumberExtract;

public class Validation {

    private static String customSeparator;
    public static final String BLANK=" ";
    private static final String NULL="";

    public static void validateInput(String input){
        validateIsBlank(input);
        validateIsMaxLength(input);
        validateIsContinuousSeparator(input);
        if(hasNewLine(input))
        {
            validateCustom(input);
        }
        validateIsSeparatorPresent(input);
    }

    public static void validateCustom(String input){
        customSeparator = AdditionSeparator.extractCustom(input);
        AdditionSeparator.addCustomSeparator(customSeparator);
        validateIsCustomEmpty(customSeparator);
        validateIsCustomNumber(customSeparator);
        AdditionSeparator.separatorList.add(customSeparator);
    }

    public static void validateIsMaxLength(String input){
        if(input.length()>100)throw new IllegalArgumentException(ValidationConstants.MAX_INPUT_LENGTH);
    }

    public static void validateIsBlank(String input){
        if(input.contains(BLANK)){
            throw new IllegalArgumentException(ValidationConstants.INPUT_NOT_BLANK);
        }
    }

    public static boolean hasNewLine(String input){
        if(input.startsWith(CustomSeparator.CUSTOM_START_WITH)){
            if(!input.contains(CustomSeparator.CUSTOM_NEWLINE)){
                throw new IllegalArgumentException(ValidationConstants.CUSTOM_MUST_NEWLINE);
            }
            return true;
        }
        return false;
    }

    public static void validateIsCustomEmpty(String customSeparator){
        if(customSeparator.isEmpty()){
            throw new IllegalArgumentException(ValidationConstants.CUSTOM_NOT_EMPTY);
        }
    }

    public static void validateIsCustomNumber(String customSeparator){
        for(char custom : customSeparator.toCharArray()){
            if(Character.isDigit(custom)){
                throw new IllegalArgumentException(ValidationConstants.CUSTOM_NOT_NUMBER);
            }
        }
    }

    //구분자가 연속으로 들어갔는지 검증
    public static void validateIsContinuousSeparator(String input) {
        int count = 0;
        int i;
        if (hasNewLine(input)) {
            int newlineIndex = input.indexOf(CustomSeparator.CUSTOM_NEWLINE);   //커스텀 문자열의 끝 문자열이 바뀔 수도 있기 때문에 상수로 가져와, 해당 인덱스 반환
            int newLineLength = CustomSeparator.CUSTOM_NEWLINE.length();        //커스텀 문자열의 길이 반환하여 커스텀 문자를 제외한 수식을 String으로 반환
            String customContainInput = input.substring(newlineIndex+newLineLength);
            for (i = 0; i < customContainInput.length(); i++) {
                char currentChar = customContainInput.charAt(i);
                if (!Character.isDigit(currentChar)) {
                    count++;
                    if (count == 2) {
                        throw new IllegalArgumentException(ValidationConstants.CONTINUOUS_SEPARATOR);
                    }
                } else {
                    count = 0;
                }
            }
        } else {
            for (i = 0; i < input.length(); i++) {
                char currentChar = input.charAt(i);
                if (!Character.isDigit(currentChar)) {
                    count++;
                    if (count == 2) {
                        throw new IllegalArgumentException(ValidationConstants.CONTINUOUS_SEPARATOR);
                    }
                } else {
                    count = 0;
                }
            }
        }
    }

    public static void hasDuplicationCustomSeparator(String customSeparator){
        if(AdditionSeparator.separatorList.contains(customSeparator)){
            throw new IllegalArgumentException(ValidationConstants.DUPLICATE_CUSTOM_SEPARATOR);
        }
    }

    //구분자 리스트에 있는 구분자인지 검정
    public static void validateIsSeparatorPresent(String input){
        String[] isSeparator = NumberExtract.split(input,AdditionSeparator.separatorList);
        if(input != NULL){
            try {
                for(String number : isSeparator){
                    if(number != NULL)Integer.parseInt(number);
                }
            }catch (NumberFormatException e){
                throw new IllegalArgumentException(ValidationConstants.SEPARATOR_NOT_FOUND);
            }
        }
    }

}

package validation;

public class ValidationConstants {

    public static final String INPUT_NOT_BLANK="입력 문자열에 공백이 존재하면 안 됩니다.";
    public static final String CUSTOM_MUST_NEWLINE="Custom Separator 에는 개행문자가 포함되어야 합니다.";
    public static final String CUSTOM_NOT_EMPTY = "Custom Separator 는 비어져 있으면 안 됩니다.";
    public static final String CUSTOM_NOT_NUMBER="Custom Separator 에는 숫자가 될 수 없습니다.";
    public static final String MAX_INPUT_LENGTH="입력 문자열의 최대 길이 100을 초과했습니다.";
    public static final String CONTINUOUS_SEPARATOR = "입력 문자열에 연속된 구분자가 존재하면 안 됩니다.";
    public static final String DUPLICATE_CUSTOM_SEPARATOR = "중복된 커스텀이 존재합니다.";
    public static final String SEPARATOR_NOT_FOUND = "존재하지 않는 구분자입니다.";

}

public class Calculate {

    private final String[] numberExtract;

    public Calculate(String[] numberExtract) {
        this.numberExtract=numberExtract;
    }

    public int calculate(){
        int sum = 0;
        for(String integer : numberExtract){
            if(!integer.isEmpty()){
                sum += Integer.parseInt(integer);
            }
        }
        return sum;
    }

}

이렇게 리팩토링 했는데... 싱글톤 패턴을 공부해보라고 한다.. ㅠㅠ