Трюк с try ... catch

{
        LoginParameters parameters;
 
        try {
            parameters = LoginParameters.newBuilder()
                    .withEmail(getTextContentFromEditById(R.id.login_edittext_email))
                    .withLogin(getTextContentFromEditById(R.id.login_edittext_login))
                    .withPassword(getTextContentFromEditById(R.id.login_edittext_password))
                    .build();
 
            account.login(parameters);
        } catch (UserInterfaceException e) {
            LOG.error(e, e);
        } catch (RequiredParameterMissingException e) {
            // handle exception
        }
    }
 
    public static String getTextContentFromEditById(final int id) throws UserInterfaceException {
        String content = null;
 
        EditText editText = (EditText) findViewById(id);
 
        if (editText != null) {
            Editable editable = editText.getText();
 
            if (editable != null) {
                content = editText.toString();
            } else {
                throw new UserInterfaceError("Editable for view is misconfigured");
            }
        } else
            throw new UserInterfaceException("View not found with id = " + id);
 
        return content;
    }
}

public class UserInterfaceException extends Exception {
    public UserInterfaceException(String message) {
        super(message);
    }
}

public class UserInterfaceError extends Error {
    public UserInterfaceError(String message) {
        super(message);
    }
}

public class RequiredParameterMissingException extends Exception {
    public RequiredParameterMissingException(String message) {
        super(message);
    }
 
    public RequiredParameterMissingException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class LoginParameters {
    private String email;
    private String login;
    private String password;
 
    private LoginParameters(String email, String login, String password) {
        this.email = email;
        this.login = login;
        this.password = password;
    }
 
    public static Builder newBuilder() {
        return new Builder();
    }
 
    public String getEmail() {
        return email;
    }
 
    public String getLogin() {
        return login;
    }
 
    public String getPassword() {
        return password;
    }
 
    public static final class Builder {
        private Optional<String> email;
        private Optional<String> login;
        private Optional<String> password;
 
        private Builder() {
            this.email = Optional.absent();
            this.login = Optional.absent();
            this.password = Optional.absent();
        }
 
        private boolean isFieldValid(final String field) {
            return true;
        }
 
        private void validatePassword() throws RequiredParameterMissingException {
            if (!password.isPresent())
                throw new RequiredParameterMissingException("Password is missing");
            else if (!isFieldValid(password.get()))
                throw new RequiredParameterMissingException("Invalid password");
        }
 
        private void validateLogin() throws RequiredParameterMissingException {
            if (!login.isPresent())
                throw new RequiredParameterMissingException("Login is missing");
            else if (!isFieldValid(login.get()))
                throw new RequiredParameterMissingException("Invalid login");
        }
 
        private void validateEmail() throws RequiredParameterMissingException {
            if (!email.isPresent())
                throw new RequiredParameterMissingException("E-mail is missing");
            else if (!isFieldValid(email.get()))
                throw new RequiredParameterMissingException("Invalid e-mail");
        }
 
        public Builder withEmail(final String email) {
            this.email = Optional.fromNullable(email);
            return this;
        }
 
        public Builder withLogin(final String login) {
            this.login = Optional.fromNullable(login);
            return this;
        }
 
        public Builder withPassword(final String password) {
            this.password = Optional.fromNullable(password);
            return this;
        }
 
        public LoginParameters build() throws RequiredParameterMissingException {
            validateEmail();
 
            validateLogin();
 
            validatePassword();
 
            return new LoginParameters(email.get(), login.get(), password.get());
        }
    }
}