Сохраняет ли enum статические значения, и если да, то как мне создать новый экземпляр / сбросить его?

Question

Я написал валидатор строк, чтобы проверить имя пользователя / пароль.Я передаю строку, минимальная необходимая длина.Длина первой строки, которую я передаю, равна 4 (имя пользователя), а второй раз - 8 (пароль).

Затем я сохраняю эти значения в сопутствующем объекте и позволяю моей возвращаемой переменной, Enum со строковым значением,используйте ссылку на переменную минимальной длины из сопутствующего объекта, чтобы указать минимальную длину в строковом сообщении.

Проблема - это первый раз, когда она работает, как предполагалось, и строка записывает 4 как минимальную длину.Однако во второй раз, когда я увеличиваю длину до 8, на выходе все равно будет 4.

Код:

//Calling from somewhere else
 val usernameStrengthResult = StringStrengthValidator.evaluateStrength(registrationUserData.fullName,8)
 val passwordStrengthResult = StringStrengthValidator.evaluateStrength(registrationUserData.password,8)

-------------------------------------------------------------------  
 companion object {                                 

 //--------REQUIREMENTS--------                 
 var REQUIRED_LENGTH = 0                                               

fun evaluateStrength(clientString: String, requiredLength: Int?= null){

  //Setting companion value to the new length limit
  requiredLength?.let { REQUIRED_LENGTH = it } 

  return when {                                                               
     clientString.length < REQUIRED_LENGTH -> StringStrengthReport.TO_SHORT 
    }
}

-------------------------------------------------------------------
//I use REQUIRED_LENGTH to construct a message
enum class StringStrengthReport(val message: String){                                          
    TO_SHORT("is to short. ${StringStrengthValidator.REQUIRED_LENGTH} characters are required")
}

Самое странное то, что при отладке значения значение отображается как 8(второй раз), но строка по-прежнему создается с помощью 4.

Она показывает, что после прочтения значения оно не изменится.У кого-нибудь еще была подобная проблема?

РЕДАКТИРОВАТЬ: Полный код

class StringStrengthValidator {

    companion object {

        //--------REQUIREMENTS--------
        var REQUIRED_LENGTH = 8
        var MAXIMUM_LENGTH = 32
        private var REQUIRE_SPECIAL_CHARACTERS = false
        private var REQUIRE_DIGITS = false
        private var REQUIRE_LOWER_CASE = false
        private var REQUIRE_UPPER_CASE = false

        fun evaluateStrength(clientString: String,
                             requiredLength: Int?= null,
                             maxLength: Int? = null,
                             requireSpecial: Boolean? = null,
                             requireDigits: Boolean?= null,
                             requireLowerCase: Boolean? = null,
                             requireUpperCase:Boolean? =null)
                : StringStrengthReport {

            requiredLength?.let { REQUIRED_LENGTH = it }
            maxLength?.let { MAXIMUM_LENGTH = it }
            requireSpecial?.let { REQUIRE_SPECIAL_CHARACTERS = it }
            requireDigits?.let { REQUIRE_DIGITS = it }
            requireLowerCase?.let { REQUIRE_LOWER_CASE = it }
            requireUpperCase?.let { REQUIRE_UPPER_CASE = it }


            var hasUpper = false
            var hasLower = false
            var hasDigit = false
            var hasSpecial = false

            for (i in 0 until clientString.length) {
                val c = clientString[i]

                when {
                    isSpecialCharacter(hasSpecial, c) -> hasSpecial = true
                    isDigit(hasDigit, c) -> hasDigit = true
                    isUpperCase(hasUpper, c) -> hasUpper = true
                    else -> hasLower = true
                }
            }

           return when {
                clientString.length < REQUIRED_LENGTH -> StringStrengthReport.TO_SHORT
                REQUIRE_LOWER_CASE && !hasLower -> StringStrengthReport.LOWER_CASE_REQUIRED
                REQUIRE_UPPER_CASE && !hasUpper -> StringStrengthReport.UPPER_CASE_REQUIRED
                REQUIRE_DIGITS && !hasDigit -> StringStrengthReport.DIGIT_REQUIRED
                REQUIRE_SPECIAL_CHARACTERS && !hasSpecial -> StringStrengthReport.SPECIAL_CHARACTER_REQUIRED
                clientString.length > MAXIMUM_LENGTH ->StringStrengthReport.MAX_LENGTH_EXCEEDED
                else -> StringStrengthReport.VALID_STRING
            }

        }

        private fun isUpperCase(hasUpper: Boolean, c: Char) =
                !hasUpper && Character.isUpperCase(c)

        private fun isDigit(hasDigit: Boolean, c: Char) = !hasDigit && Character.isDigit(c)

        private fun isSpecialCharacter(hasSpecial: Boolean, c: Char) =
                !hasSpecial && !Character.isLetterOrDigit(c)

        fun validateEmail(email: String):Boolean {
            return android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches()
        }

        fun validateRegisterCredentials(registrationUserData: RegistrationUserData): CredentialStrengthReport {

            val isEmailValid = StringStrengthValidator.validateEmail(registrationUserData.email)
            val usernameStrengthResult = StringStrengthValidator.evaluateStrength(registrationUserData.fullName,8,32)
            val passwordStrengthResult = StringStrengthValidator.evaluateStrength(registrationUserData.password,8,32)

            var reportMessage = ""
            if (!isEmailValid) reportMessage += "Incorrect Email format\n"
            val isUsernameValid = usernameStrengthResult == StringStrengthReport.VALID_STRING
            if (!isUsernameValid) reportMessage += "Username ${usernameStrengthResult.message}\n"
            val isPasswordValid = passwordStrengthResult == StringStrengthReport.VALID_STRING
            if (!isPasswordValid)reportMessage += "Password ${passwordStrengthResult.message}\n"

            return CredentialStrengthReport(isEmailValid, isUsernameValid, isPasswordValid, reportMessage)

        }
    }

}

enum class StringStrengthReport(val message: String){
    TO_SHORT("is to short. ${StringStrengthValidator.REQUIRED_LENGTH} characters are required"),
    LOWER_CASE_REQUIRED("requires at least one lower case character"),
    UPPER_CASE_REQUIRED("requires at least one upper case character"),
    DIGIT_REQUIRED("requires at least one digit"),
    SPECIAL_CHARACTER_REQUIRED("requires at least one special character (i.e !&?#%)"),
    MAX_LENGTH_EXCEEDED("is to long. Maximum length is ${StringStrengthValidator.MAXIMUM_LENGTH} characters"),
    VALID_STRING("is valid")
}

class CredentialStrengthReport(val isEmailValid: Boolean,
                               val isUsernameValid:Boolean,
                               val isPasswordValid: Boolean,
                               val resultMessage: String){

    val isCredentialsValid:Boolean
    get() {return isEmailValid && isUsernameValid && isPasswordValid}
}