Conserver la référence à un nouvel objet passé dans le super constructeur

Question

Existe-t-il un bon moyen de conserver une référence à un objet créé dans un constructeur qui doit être passé au super constructeur d'une classe étendue (autre que de le rendre accessible depuis le super classe ou en le passant dans le constructeur en tant que paramètre)? Laissez-moi clarifier avec un exemple.

Prenez cette classe (que je ne peux pas modifier et qui ne me donne pas accès à foo):

class TestA { 
    TestA(Object foo) {} 
} 

Maintenant, je voudrais cette classe étend comme suit:

class TestB extends TestA { 
    Object myCopyOfFoo; 

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

est-il un bon moyen de stocker le new Object() créé dans myCopyOfFoo?

Ni l'un de ces trois idées de travail:

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

(erreur: appel constructeur doit être la première instruction dans un constructeur)

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

(erreur: ne peut pas se référer à un champ d'instance myCopyOfFoo tout en invoquant explicitement un constructeur)

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

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

(Erreur: ne peut pas faire référence à un i méthode de nstance en invoquant explicitement un constructeur)

Je suppose que je pouvais faire ce qui suit, mais il est ni thread-safe, ni élégant:

static Object tempFoo; 

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

Quelqu'un at-il une meilleure idée pour moi? Et pourquoi diable mes deux premières idées ne sont-elles pas légitimes?

Answer 1

Que diriez-vous:

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; 
    } 
} 

En tant que deuxième constructeur est privé, il ne peut être appelée dans la même classe (ou une classe englobante) de sorte que vous devez juste vous assurer que tout appelant le second constructeur a fait une copie appropriée, comme le fait le premier constructeur.

EDIT: Si votre situation réelle est que vous prenez une copie d'un paramètre existant, cela fonctionnerait ...

class ClassB extends ClassA { 
    private final Foo copyOfInput; 

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

Il est assez laid si :(

Answer 2

Qu'est-ce que sur les points suivants:

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

    TestB() { 
     super(myCopyOfFoo); 
    } 
} 

l'objet ne sera initialisés lors de la création d'un nouveau TestB d'objet, donc, en substance ceci fera ce que yo tu veux?

Answer 3

Une autre option:

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); 
    } 

}