Il reference this

[andbin]

E' quindi plausibile pensare ad uno standard come proposto qui sotto?

Non è uno standard ma un "pattern", un modo di sfruttare i costruttori quando ci sono svariati parametri opzionali.
Ed ha un nome: nel suo libro "Effective Java, 2nd Edition" Joshua Bloch lo chiama il "telescoping constructor pattern" (traducibile in: "costruttori telescopici") in cui ogni costruttore "allunga" di un parametro in più (il "telescopico" è in questo senso, appunto).

E come l'hai scritto tu comunque è, tra l'altro, nel peggiore dei modi. Generalmente quando si usa questo pattern, l'assegnamento ai campi si fa solo nel costruttore più completo (quello con tutti i parametri) e gli altri costruttori fanno solo invocazioni this( .. ) invocando il costruttore con un parametro in più passandogli un valore predefinito (o passando più/tutti gli altri valori predefiniti).

Ma come dice Joshua Bloch, nel Item 2 "Consider a builder when faced with many constructor parameters":

In short, the telescoping constructor pattern works, but it is hard to write client code when there are many parameters, and harder still to read it.

Quindi "funziona", è ok. Ma è meno leggibile e non bisogna esagerare con il numero di parametri opzionali.

E poi:

A second alternative when you are faced with many constructor parameters is the JavaBeans pattern

Ma questo chiaramente ha altri svantaggi: a) richiede che l'oggetto sia "mutabile" (non si può fare se deve essere immutabile) e b) lo stato dell'oggetto non è subito ben definito, poiché richiede più setter da invocare e quindi ci possono essere errori dovuti ad un cattivo uso, anche solo per svista del programmatore.

Come ultima/ulteriore alternativa:

Luckily, there is a third alternative that combines the safety of the telescoping constructor pattern with the readability of the JavaBeans pattern. It is a form of the Builder pattern

Questo è assolutamente valido, specialmente se l'oggetto deve essere immutabile. Ma richiede più codice per implementare il Builder (che tipicamente è una public nested class interna alla classe da gestire).

[Vettel]

E come l'hai scritto tu comunque è, tra l'altro, nel peggiore dei modi. Generalmente quando si usa questo pattern, l'assegnamento ai campi si fa solo nel costruttore più completo (quello con tutti i parametri) e gli altri costruttori fanno solo invocazioni this( .. ) invocando il costruttore con un parametro in più passandogli un valore predefinito (o passando più/tutti gli altri valori predefiniti).

Quindi nel mio esempio come diventerebbe il codice se scritto da un purista? (non capisco come si possa assegnare i campi solo nel più completo nel caso in cui non si arriva ad esso)

Al di là del "purismo" del codice che rispetto e mi affascina perchè sbiadisce la linea di confine con l'arte, tornando "terra terra" è tutta qui la funzione del this ? Non ha in java altre funzioni, corretto?

[andbin]

non capisco come si possa assegnare i campi solo nel più completo nel caso in cui non si arriva ad esso

Ovviamente si deve arrivare al costruttore più completo!

public class Prova {
    private String a;
    private String b;
    private String c;
    private String d;

    public Prova(String a) {
        this(a, "");
    }

    public Prova(String a, String b) {
        this(a, b, "");
    }

    public Prova(String a, String b, String c) {
        this(a, b, c, "");
    }

    public Prova(String a, String b, String c, String d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    // altro .....
}

Come vedi, i primi 3 costruttori arrivano sempre (direttamente o indirettamente) al costruttore completo, l'ultimo.

In alternativa, per evitare di incatenare insieme più invocazioni this(), si può far arrivare direttamente al costruttore completo:

public class Prova {
    private String a;
    private String b;
    private String c;
    private String d;

    public Prova(String a) {
        this(a, "", "", "");
    }

    public Prova(String a, String b) {
        this(a, b, "", "");
    }

    public Prova(String a, String b, String c) {
        this(a, b, c, "");
    }

    public Prova(String a, String b, String c, String d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    // altro .....
}

Nota la differenza dei primi due costruttori. E queste due forme, comunque, sono un po' più "pulite" della tua versione.

[Vettel]

Grande andbin!