To make this implementation more flexible, I propose that we create a factory based on the provided enum.

For example, we could have a request authenticator creator interface with implementing classes that create the proper instances:

```java
public interface RequestAuthenticatorCreator {
    RequestAuthenticator create();    
}

public class BasicRequestAuthenticatorCreator implements RequestAuthenticatorCreator {

    public RequestAuthenticator create() {
        // this class should probably be renamed 'BasicRequestAuthenticator'  
        return new BasicAuthenticationRequestAuthenticator(); 
    }
}

public class Sauthc1RequestAuthenticatorCreator implements RequestAuthenticatorCreator {

    public RequestAuthenticator create() {
        return new Sauthc1RequestAuthenticator(); 
    }
}
 
```

Modify the enum to look like this:

```java

public enum AuthenticationScheme {

    BASIC(new BasicRequestAuthenticatorCreator()),
    SAUTHC1(new Sauthc1RequestAuthenticatorCreator());

    private RequestAuthenticatorCreator requestAuthenticatorCreator;
    
    private AuthenticationScheme(RequestAuthenticatorCreator requestAuthenticatorCreator) {
        this.requestAuthenticatorCreator = requestAuthenticatorCreator;
     }

    public RequestAuthenticatorCreator getRequestAuthenticatorCreator() {
        return requestAuthenticatorCreator;
    }

    public RequestAuthenticator create() {
        return getRequestAuthenticatorCreator().create();
    }
}
```

Have a factory to create the request authenticator:

```java
public interface RequestAuthenticatorFactory {
    RequestAuthenticator create(AuthenticationScheme authenticationScheme);
}

public class DefaultRequestAuthenticatorFactory implements RequestAuthenticatorFactory {

    public RequestAuthenticator create(AuthenticationScheme authenticationScheme) {
        return authenticationScheme.create(); 
    }
} 
```

Now from the client class we can instantiate the factory and have it return the proper RequestAuthenticator:

```java
// this is meant to be a property of the client class
private RequestAuthenticatorFactory requestAuthenticatorFactory = new DefaultRequestAuthenticatorFactory(); 

// from the method that creates the instance, we can do:
RequestAuthenticator requestAuthenticator = requestAuthenticatorFactory.create(WHATEVER_AUTH_SCHEME); 
```

This implementation makes adding or removing authentication schemes more flexible and avoids having to use nested _ifs_ or _switches_.

Let me know if you have any questions on this suggestion.