The paradigm of 
```java
MollomClientBuilder.create()
    .withPublicKey()
    .withPrivateKey()
    .build()
```
is called "fluent interfaces" and pretty standard when you have a class with a lot of required and optional parameters. Otherwise you have two options:
1) Long constructor with a bunch of orderloading for the optional paramters and avoiding the user from having to do MollomClient("publicKey", "privateKey", null, null, null, null, null, null)
```java
public MollomClient(String publicKey, String privateKey) { this(publicKey, privateKey, ....); }
public MollomClient(String publicKey, String privateKey, String endPoint, String clientName, String platformName, ...) { ... }
```
2) Empty constructor with setters. The problem with this is that there can exist a state where there is a MollomClient object where the publicKey and privateKey properties are not set. The user will not know this until he runs the code and gets a 400 error back from the server.
```java
MollomClient client = new MollomClient();
client.setPublicKey("public-key");
client.setPrivateKey("private-key");
client.setClientName("MollomJava");
```

The current implementation prevents you from having excessive amounts of overloaded constructors. (Constructors with many String parameters also gets extremely confusing and is very error prone). 
It also adds validation layer as well. When the user calls MollomClientBuilder.create(), it returns a MollomClientBuilder object, not a MollomClient object. The only way to get a MollomClient object to do actual work, .build() must be called, and if all of the mandatory parameters are not set, an MollomConfigurationException is thrown, telling the user exactly what property he forgot to set. 
The MollomClientBuilder also performs authentication checks with the Mollom server prior to creating the MollomClient object. All of this boils down to one single guarantee: if you have a MollomClient object, you are guaranteed to successfully make API calls. 

As for:
```java
MollomClient client = new MollomClient({
  publicKey: "public-key",
  privateKey: "private-key",
  platformName: "...",
  clientName: "MollomJava",
  endpoint: "dev.mollom.com",
});
```
This type of syntax with named parameters doesn't exist in java. You can hack that kind of syntax with
```java
new MollomClient(new HashMap<String, Integer>(){{
put("publicKey", "public-key");
put("privateKey", "private-key");
...
}});
```
or
```java
new MollomClient({
        {"publicKey", "public-key"},
        {"privateKey", "private-key"}
    });
```
but that's probably not what you're looking for. Not only does it look really ugly, it is also very non-java standard.