2013-08-12 18 views
6

Se nella mia classe personalizzata sono presenti 2 costruttori e uno di loro prende un argomento in più e fa tutto il primo ma con una sola riga di codice aggiuntiva (e questa linea aggiuntiva utilizza il argomento extra), come gestirlo al meglio senza dover duplicare tutto il codice nel primo costruttore?Come gestire 2 costruttori quasi identici

codice di esempio

public myConstuctor(int number, int number2){ 

    int result = (number + number2); 
    int result2 = (number2 - number1) 

    //Etc 
    //Etc 
    //Etc 
    //Etc 

} 

public myConstructor(int number1, int number2, int number 3){ 

    int result = (number + number2); 
    int result2 = (number2 - number1) 

    //Etc 
    //Etc 
    //Etc 
    //Etc 

    int result3 = (result + result2 + number3) 


} 
+0

No, non è la stessa domanda, non sto specificatamente chiedendo come chiamare un costruttore da un altro, sto chiedendo come affrontare il problema di ridurre il codice duplicato, indipendentemente dalla risposta più popolare possibilmente essendo di fare proprio questo (chiama un costruttore dall'altra) – Zippy

+0

"Sto chiedendo come affrontare il problema di ridurre il codice duplicato", hai scelto come corretta non la risposta corretta .. è meglio mettere la logica in il costruttore con più parametri – nachokk

+0

@nachokk, Se creo un oggetto che richiede solo 1 argomento, quindi non ha bisogno di codice nel costruttore a 2 argomenti, quindi la maggior parte della mia logica (tutta la logica comune) è nel costruttore con gli argomenti * least *, quando ho bisogno di creare un oggetto che passa 2 argomenti, allora tutta la logica nel costruttore originale di 1 argomento dovrà ancora essere eseguita poiché è comune a tutti gli oggetti di questo tipo, ma avranno anche bisogno del codice aggiuntivo nel costruttore di 2 argomenti, rimando al costruttore di 1 argomento ed eseguo il codice comune, quindi eseguo il codice aggiuntivo nell'altro. Sembra perfettamente logico? – Zippy

risposta

14

Si può fare il secondo costruttore chiamata la prima:

public MyClass(int number1, int number2, int number3) { 
    this(number1, number2); 
+0

mmm non so perché 5 upvotes, la risposta @bas è corretta – nachokk

+0

Perfetto. implementato e funzionante alla grande :-) – Zippy

+1

@nachokk: Entrambe le risposte sono corrette. Generalmente preferisco avere costruttori con meno argomenti che chiamano quelli con argomenti più grandi. Il caso dell'op è presentato in un modo che suggerisce che un simile ordine potrebbe non essere possibile, quindi SLaks ha preso la strada sicura e ha presentato una risposta che corrispondeva più strettamente al codice dell'OP. Se non è possibile il valore predefinito per number3, la risposta di bas non è un'opzione (a meno che non si aggiunga un valore sentinella o si effettui numero3 nullable). Alcune persone sostengono che l'approccio di SLaks è più pulito, dal momento che rende molti piccoli costruttori piuttosto che uno gigante). – Brian

13

È possibile chiamare l'altro costruttore e mettere tutta la tua logica lì.

public myConstructor(int number, int number2){ 
    this(number, number2, 0); 
} 

public myConstructor(int number1, int number2, int number3){ 

    int result = (number + number2); 
    int result2 = (number2 - number1) 

    //Etc 
    //Etc 
    //Etc 
    //Etc 

    int result3 = (result + result2 + number3) 


} 
+0

Cosa succede se number3 moltiplica un valore? Dì "result2 * = number3'? – Math

+0

A seconda della struttura dei costruttori, la risposta di SLaks potrebbe essere migliore. Questo approccio significa che l'utente avrebbe potuto chiamare 'myConstructor' con 3 argomenti, ma invece un argomento predefinito è usato per number3. @Math nel tuo caso la chiamata predefinita potrebbe essere 'this (number, number2, 1);' – bas

+2

Ho appena detto che penso che la tua soluzione dipenda da cosa fa il costruttore, e la risposta di Slaks mi sembra che copra tutte le possibilità .. Non che il tuo sia sbagliato, ma dipenderà da ciò che fa il costruttore. – Math

6

È possibile anche utilizzare un builder, se gli argomenti diventano troppi da gestire:

MyClass obj = Myclass.set1(number1).setN2(number2).setN3(number3).build(); 

build() può chiamare i costruttori ingombranti.

+0

Un approccio migliore di +1 rispetto all'utilizzo di 2 costruttori –

+0

Questo è il modello di progettazione Builder ed è il modo corretto di utilizzare. – BVMR

+0

Grazie per questo @rocketboy, è interessante. Ho solo un massimo di 2 argomenti nella mia classe effettiva (costruttore di 1 argomento e costruttore di 2 argomenti) quindi userò la risposta SLacks, ma grazie, cercherò di approfondire questo! – Zippy

0

Basta usare il primo metodo di costruzione all'interno del secondo metodo di costruzione e successivamente ... aggiungere semplicemente la nuova riga necessaria nel metodo Secondo costruttore.

public ClassName(arg1, arg2){ 
    //etc 
} 


public ClassName(arg1,arg2,arg3){ 
this(arg1,arg2); 
//new line of code to deal with arg3; 
} 

E questo è :) un sacco di tempo risparmiato.

+1

Non puoi avere costruttori con nomi diversi _n. Devono corrispondere al nome della classe. – jlordo

+0

Wow seriamente wow XD –

+0

'CLASSNAME' non sta seguendo le best practice sulle regole di denominazione. Dovrebbe essere 'ClassName' – Math

Problemi correlati