Come fare riferimento a un oggetto con due interfacce? [duplicare]

Naviga le tue risposte
-2

Supponiamo di avere due interfacce I e J implementate da Test class. Ora ho bisogno di un oggetto di classe Test a cui fanno riferimento le interfacce I e J. Posso farlo con singleton design pattern. Ma il problema è che a volte non ho bisogno di un singolo oggetto nel programma. Quindi c'è anche un altro approccio che ho conosciuto. 

I i = new Test();
i.doSomeThing();
J j = (J) i;
j.print();

La mia domanda, c'è un modo migliore per farlo? ... UPDATE ... 

public interface I {
void doSomeThing();
}

public interface J {
void print();
}

public class Test implements I, J{
private int a;

@Override
public void doSomeThing() {
    a += 10;
}

@Override
public void print() {
    System.out.println(this.a);
}
}

... UPDATE ... 

public class Main {
    public static void main(String[] args) {
    I i = new Test();
    foo(i);
    J j = (J) i;
    ffoo(j);
}
/**
* This method has business with only the doSomething method that  
* implement the Test class. This method has not nothing with the print
* method that is in the Test class. So it would be well that only pass 
* the I interface to the foo method. 
*/
public static void foo(I i) {
    i.doSomeThing();
}

public static void ffoo(J j) {
    j.print();
}
}
    
posta Muztaba Hasanat 26.07.2015 - 18:36
fonte

2 risposte

2

Perché non questo? 

public class Main {

    public static void main(String[] args) {
        Test i = new Test();
        foo(i);
        ffoo(i);
    }

    public static void foo(I i) {
        i.doSomeThing();
    }

    public static void ffoo(J j) {
        j.print();
    }
}

Sembra che, nel contesto del tuo codice, hai bisogno di un'istanza Test .

Non è necessario eseguire il cast di Test in I o J . Lascia che il polimorfismo faccia la sua magia per te.

    
risposta data 26.07.2015 - 18:45
fonte
0

L'ho fatto in molti modi. L'approccio che hai preso è efficace, anche se spesso trovo che il mio codice sia più leggibile se uso alcuni caratteri extra sul nome della variabile per aiutare a identificare che c'è un oggetto, e mi sto semplicemente connettendo a due facce di esso: 

I myTestObject_i = new Test(); // creates a test, casts it to I
J myTestObject_j = (J)myTestObject_i;
myTestObject_i.doSomething();
myTestObject_j.print();

È prolisso, ma ho scoperto che nel mio ambiente valeva la pena.

Un altro approccio con cui stiamo lavorando è utilizzare un modello di facciata. Nel nostro caso, usando C ++ e molti altri, stiamo ottenendo un sacco di autogenerazione. Tuttavia, in un pizzico, puoi scriverne uno manualmente 

class IJFacade : implements I, implements J
{
    public IJFacade(BaseClass obj)
    {
       mObj = obj;
       mI = (I) obj;
       mJ = (J) obj;
       // error checking
    }

    public BaseClass getUnderlyingObject  { return mObj;      }
    public void doSomething()             { mI.doSomething(); }
    public void print()                   { mJ.print();       }

    private BaseClass mObj;
    private I mI;
    private J mJ;
}

Test testObject = new Test();
IJFacade ij = new IJFacade(testObject); // wrap the object to expose functions
ij.doSomething();
ij.print();

L'approccio migliore dipende in realtà dalla tua applicazione, quindi incoraggio a sperimentare.

    
risposta data 26.07.2015 - 19:26
fonte

Leggi altre domande sui tag

Come progettare il database per mantenere l'elenco dei membri speciali tra tutti i membri? [chiuso] Errore nel recupero delle e-mail in Delphi (POP3) [chiuso]