C'è qualche motivo per cui l'inizializzazione lenta non può essere integrata in Java?

Dal momento che sto lavorando su un server senza stato assolutamente non persistente per gli utenti, ogni oggetto relativo all'utente che abbiamo è implementato su ogni richiesta.

Di conseguenza, spesso mi ritrovo a eseguire un'inizializzazione pigra delle proprietà degli oggetti che potrebbero non essere utilizzate.

protected EventDispatcher dispatcher = new EventDispatcher();

Diventa ...

protected EventDispatcher<EventMessage> dispatcher;

public EventDispatcher<EventMessage> getEventDispatcher() {
    if (dispatcher == null) {
        dispatcher = new EventDispatcher<EventMessage>();
    }
    return dispatcher;
}

C'è qualche motivo per cui questo non può essere integrato in Java?

protected lazy EventDispatcher dispatcher = new EventDispatcher();

Come menzionato di seguito nei commenti, mi rendo conto che una lingua potrebbe teoricamente evolversi per includere quasi tutto ciò che desideri. Sto cercando una misura pratica della possibilità. Questo conflitto con altre funzionalità? L'implementazione è abbastanza semplice da funzionare bene con la JVM così com'è? E anche, è una buona idea?

Ecco una risposta di otto pagine alla tua domanda: http://tinlizzie.org/~awarth/papers/fool07.pdf

Se posso provare e sintetizzare grossolanamente i problemi con l'aggiunta di pigrizia, sono i casi d'angolo. Ci sono molti avvertimenti sugli effetti collaterali. Considera, nel tuo esempio, se il costruttore avesse effetti collaterali visibili come urtare un contatore globale o fare I / O ... È difficile ragionare su quando ciò accadrà. O considerare effetti collaterali ancora più brutti sulle eccezioni (vengono lanciati ... quando fai riferimento all'oggetto pigro?)

Passa alla sezione 6 del documento sopra. (E ammira tutta la logica formale del sistema di tipi nelle pagine che salti ...)

Certo, è eminentemente possibile. In effetti, Scala ha già esattamente questa funzione! (Scala è un linguaggio JVM e compila fino al bytecode). Ecco un pezzo di scala fonte:

class Foo {
  lazy val bar = "Hello World"
}

Ed ecco come appare una forma intermedia del codice compilato:

scalac -Xprint:icode Foo.scala

[[syntax trees at end of icode]]// Scala source: Foo.scala
package <empty> {
  class Foo extends java.lang.Object with ScalaObject {
    @volatile protected var bitmap$0: Int = 0;
    lazy private[this] var bar: java.lang.String = _;
    <stable> <accessor> lazy def bar(): java.lang.String = {
      if (Foo.this.bitmap$0.&(1).==(0))
        {
          Foo.this.synchronized({
            if (Foo.this.bitmap$0.&(1).==(0))
              {
                Foo.this.bar = "Hello World";
                Foo.this.bitmap$0 = Foo.this.bitmap$0.|(1);
                ()
              };
            scala.runtime.BoxedUnit.UNIT
          });
          ()
        };
      Foo.this.bar
    };
    def this(): Foo = {
      Foo.super.this();
      ()
    }
  }

}

Penso che prima devi aggiungere proprietà reali al linguaggio Java, piuttosto che fare affidamento sul linguaggio getX / setX. In questo modo potresti semplicemente contrassegnare la proprietà come pigra (e sincronizzata, di sola lettura ecc ...).

Sorta di ciò che viene richiesto qui (Obiettivo-C, ma si applica il concetto).

Naturalmente questo potrebbe essere aggiunto a Java, la parola chiave lazy potrebbe essere implementata come zucchero sintattico. Tuttavia, se verrà implementato dipende dalla visione dei costruttori di compilatori.