Modularità: uso di interfacce o no?

Question

Da alcuni anni, il buon senso sembra dettare che è meglio per il programma contro le interfacce piuttosto che contro le implementazioni. Per il codice alto livello sembra infatti logico, ad esempio se ho un risolutore complesso nella mia richiesta, sembra meglio avere qualcosa di simile:

ISolver *solver = solverFactory.getSolver();
solver->solve(inputdata);

Piuttosto che

Solver solver;
solver.solve(inputdata);

Nel primo codice è anche più facile deridere il risolutore, e quindi, a unit test.

Ma la mia domanda è: a quale livello, non ha senso più all'interfaccia uso. Per esempio. se ho una classe Numero complesso (o classe String, o qualsiasi altra cosa) nella mia applicazione, quindi scrivere questo:

IComplexNumber *complexNumber = complexNumberFactory.create(1,2);   // 1+2i

Sembra molto più complessa (soprattutto per quanto riguarda le prestazioni) che scrivere:

ComplexNumber complexNumber(1,2);   // 1+2i

Quindi, quali elementi sono importanti per decidere se qualcosa deve essere messo dietro un'interfaccia e quando non dovrebbe essere messo dietro un'interfaccia?

Answer 1

I motivi per passare a un'interfaccia sono quando si rende le cose più semplici e riduce l'accoppiamento. (Questo è quello che è un'interfaccia per).

Motivi di allontanarsi da un'interfaccia sono se rende le cose più complicate o uccide le prestazioni (ma il profilo che per essere sicuri). Direi che la classe IComplexNumber in realtà rende la classe gerarchia più complessa a meno che non si sta introducendo un MockComplexNumber, ma dubito tale classe sarebbe utile ... e sarà probabilmente fare cose fanno più lento, ma mi piacerebbe misura che .

Ma non pensate di aver bisogno di fare tutto in un modo, o che le vostre decisioni sono fissati in pietra. È abbastanza facile da convertire in / da utilizzando un'interfaccia.

Answer 2

Se dividete le vostre classi in "servizio" e le classi "valore", a seconda dei ruoli che svolgono, allora la risposta è semplice. Utilizzare solo interfacce classi di servizio. Nella tua domanda, "risolutore" è un servizio e "numero complesso" è un valore.

classi di valore dovrebbe essere facile da creare utilizzando new () perché accettano solo tipi di base e altre classi di valore nel costruttore. Classi di valore non sono utili per prendere in giro perché è possibile utilizzare la cosa reale.

Può essere utile per classi di servizio finte e si consiglia implementazioni multiple. Il tuo solverFactory potrebbe restituire un naiveSolver, un lookupSolver, un geneticSolver, un mockSolver ecc Qui un'interfaccia è uesful.

Answer 3

Con C ++ non importa in modo da C ++ ha l'ereditarietà multipla e così l'interfaccia è una classe astratta che è possibile aggiungere al Implementazione. Dove ho trovato interfacce più utilizzato è Java e C # che hanno ereditarietà singola e se si wan una classe per implementare diverse cose solo uno può essere una classe astratta gli altri devono essere interfacce