[JAVA] Istanziare classi statiche?

[il_luridone]

Salve a tutti,

ho un pezzo di codice di esempio che non riesco a comprendere perchè fa cose che non credevo possibili con Java.

Il fatto è questo: ho una classe statica BindingManager che ha un metodo statico create() che ritorna un new BindingManager(). Già qui è strano perchè così capisco che sta istanziando una classe statica e qualcosa non mi torna... ma soprattutto il new ha una forma che non avevo mai visto: new BindingManager() { /*... metodi ...*/ };

La parte di codice oscura è quella tra i commenti // ?!?, il resto l'ho postato solo per contesto.

Qualcuno saprebbe dirmi cosa significa o almeno indicarmi un riferimento per cercare sul Java Language Specification?

public static class BindingManager {

    public static BindingManager create() {
        return new BindingManager() {           // ?!?
            public void exitScope() {
                throw new IllegalStateException("exitScope from top level");
            }

            public boolean contains(String identifier) {
                return map.containsKey(identifier);
            }

            public Literal getValue(String identifier) {
                return (Literal) map.get(identifier);
            }
        };          // ?!?
    }

    private BindingManager enclosingScope;

    protected Map map = new HashMap();

    private BindingManager() {
    }

    private BindingManager(BindingManager enclosingScope, Map map) {
        this.enclosingScope = enclosingScope;
        this.map = map;
    }

    public void enterScope() {
        this.enclosingScope = new BindingManager(enclosingScope, map);
        this.map = new HashMap();
    }

    public void exitScope() {
        this.enclosingScope = enclosingScope.enclosingScope;
        this.map = enclosingScope.map;
    }

    public boolean contains(String identifier) {
        return map.containsKey(identifier) ? true : enclosingScope.contains(identifier);
    }

    public void bind(String identifier, Literal value) {
        map.put(identifier, value);
    }

    public Literal getValue(String identifier) {
        Literal value = (Literal) map.get(identifier);
        return (value != null) ? value : enclosingScope.getValue(identifier);
    }
}

[jappilas]

Originariamente inviato da il_luridone

Salve a tutti,

ho un pezzo di codice di esempio che non riesco a comprendere perchè fa cose che non credevo possibili con Java.

Il fatto è questo: ho una classe statica BindingManager che ha un metodo statico create() che ritorna un new BindingManager(). Già qui è strano perchè così capisco che sta istanziando una classe statica e qualcosa non mi torna... ma soprattutto il new ha una forma che non avevo mai visto: new BindingManager() { /*... metodi ...*/ };
...

un membro static è un membro comune a tutte le istanze della classe che lo contiene (anche se non ne sono ancora state istanziate)
una funzione membro static è in effetti un membro della classe in sè piuttosto che un membro di un oggetto istanza di quella classe, quindi può essere invocata anche se non sono stati già creati oggetti di quella classe, e uno delle applicazioni più utili è appunto la loro (o sua, quando l' esecuzione del programma prevede un solo oggetto - ad es nel pattern singleton) creazione
una funzione static però, quando la classe non è ancora stata istanziata, può manipolare variabili membro e chiamare altre funzioni membro, solo se anche questi sono dichiarati static...
tutto, se non ricordo male... devo rivedere in diamonds se come e quando si usano le classi statiche...

[peppedx]

new BindingManager() { /*... metodi ...*/ };

server semplicemente ad istanziare una classe anonima interna che ridefinisce i /* metodi */.

suc ome funzioni una classe statica mi dovrei documentare meglio.

[PGI-Bis]

La forma che ti appare strana è la creazione di un'istanza di una classe internal locale anonima. E' la contrazione di:

public static BindingManager create() {
    class Anomina extends BindingManager() {
        public void exitScope() {
                throw new IllegalStateException("exitScope from top level");
        }

        public boolean contains(String identifier) {
            return map.containsKey(identifier);
        }

        public Literal getValue(String identifier) {
            return (Literal) map.get(identifier);
        }
    };
    return new Anonima();
}

Durante la compilazione la definizione della classe anonima è poi generata in un file class a sè (sono quelli il cui nome inizia con il simbolo del dollaro) che viene collegato alle relative istruzioni.

Quanto al resto, BindingManager è un Tipo annidato. I tipi annidati esistono in un contesto statico e il contesto statico è privo di un "oggetto di riferimento" (che in un contesto non statico è rappresentato da "this"). Mancando la definizione implicita dell'oggetto che possiede i membri è chiaro che non sia possibile accedere ad alcun membro a meno che non si specifichi quale sia l'oggetto che li possieda, preponendo il relativo riferimento.

Circa il significato complessivo di quel codice, è una riduzione del pattern Factory: c'è il momento della produzione, espresso dal metodo (personalmente penso che i metodi statici non siano metodi ma non posso dirlo ) create(), manca la definizione dell'oggetto produttore.

[il_luridone]

Originariamente inviato da PGI-Bis

...

Ti ringrazio