Mantenere riferimento al nuovo oggetto passato in super costruttore

Question

C'è un buon modo per mantenere un riferimento a un oggetto creato in un costruttore che deve essere passato al super costruttore di una classe estesa (diverso da quello che lo rende accessibile dalla super classe o passarlo nel costruttore come parametro)?

Vorrei chiarire con un esempio. Prendete questa classe (che non posso modificare e che non mi dà l'accesso a foo):

class TestA { 
    TestA(Object foo) {} 
} 

Ora, vorrei estende questa classe come segue:

class TestB extends TestA { 
    Object myCopyOfFoo; 

    TestB() { 
     super(new Object()); 
    } 
} 

C'è un buon modo per memorizzare il creato new Object() in myCopyOfFoo?

Nessuno di questi tre idee funzionano:

TestB() { 
    myCopyOfFoo = new Object(); 
    super(myCopyOfFoo); 
} 

(Errore: chiamata al costruttore deve essere la prima istruzione in un costruttore)

TestB() { 
    super(myCopyOfFoo = new Object()); 
} 

(Errore: non può fare riferimento a un myCopyOfFoo campo di istanza invocando esplicitamente un costruttore)

TestB() { 
    super(makeFoo()); 
} 

Object makeFoo() { 
    myCopyOfFoo = new Object(); 
    return myCopyOfFoo; 
} 

(Errore: impossibile fare riferimento a un Metodo nstance mentre invocando esplicitamente un costruttore)

Credo che avrei potuto fare quanto segue, ma non è né thread-safe né elegante:

static Object tempFoo; 

TestB() { 
    super(tempFoo = new Object()); 
    myCopyOfFoo = tempFoo; 
} 

Qualcuno ha un'idea migliore per me? E perché mai le mie prime due idee non sono legittime?

Answer 1

ne dite:

class TestB extends TestA { 
    Object myCopyOfFoo; 

    // I assume you actually wanted this to take a parameter called foo? 
    // I've left it as per the question... 
    TestB() { 
     this(new Object()); 
    } 

    private TestB(Object copy) { 
     super(copy); 
     myCopyOfFoo = copy; 
    } 
} 

Come il secondo costruttore è privato, si può essere chiamato solo all'interno della stessa classe (o di una classe di inclusione) in modo che solo bisogno di fare in modo che tutto ciò chiamando il secondo costruttore ha fatto una copia appropriata, come fa il primo costruttore.

EDIT: Se il vostro vero situazione è che si sta prendendo una copia di un parametro esistente, allora questo dovrebbe funzionare ...

class ClassB extends ClassA { 
    private final Foo copyOfInput; 

    ClassB(Foo input) { 
     super(input = input.clone()); 
     copyOfInput = input; 
    } 
} 

E 'abbastanza brutto però :(

Answer 2

Cosa qui di seguito:

class TestB extends TestA { 
    Object myCopyOfFoo = new Object(); 

    TestB() { 
     super(myCopyOfFoo); 
    } 
} 

l'oggetto viene inizializzato solo quando si crea un nuovo oggetto TestB, quindi in sostanza questo farà quello yo vuoi?

Answer 3

Un'altra opzione:

public class TestB extends TestA { 

    Object myCopyOfFoo; 

    private TestB(Object foo) { 
     super(foo); 
     myCopyOfFoo = foo; 
    } 

    public static TestB createInstance() { 
     Object foo = new Object(); 
     return new TestB(foo); 
    } 

}