Come implementare solo una parte di un'interfaccia

se non controlli l'interfaccia J, sei bloccato.

puoi, per chiarezza, implementare la tua interfaccia subJ e interfaccia J, e usare subJ nel tuo codice per chiarire che i metodi extra nell'interfaccia J non sono richiesti, ma io non Penso che ti guadagni davvero molto

se possibile, implementa l'intera interfaccia J completamente

se possibile, contatta il proprietario dell'interfaccia J e chiedigli di modificarlo per adattarlo meglio ai tuoi scopi

L'intero punto di implementazione di un'interfaccia è di fornire un contratto aziendale tra il chiamante e il chiamato che non cambia mai mentre i dettagli di implementazione possono variare.

Implementando l'interfaccia J stai dicendo al mondo esterno cosa puoi fare.

Se non hai bisogno di metà di ciò che fa J, allora l'interfaccia dovrebbe essere veramente suddivisa in quanto non è così piccola come potrebbe essere, oppure devi lanciare NotImplementedException sui metodi e le proprietà che non ti servono . Tuttavia, questa non è la soluzione migliore in quanto confonde le aspettative delle persone su ciò che il tuo codice può fare.

Se la tua classe consumer A non richiede tutta l'interfaccia J, allora ti suggerirei di creare una nuova interfaccia (chiamala K), che descriva esaustivamente tutto ciò che richiede.

Questo fornisce un chiaro segnale a chiunque usi la classe A su quale sia la loro parte del contratto. In tal modo migliorare le possibilità di riutilizzo. Se qualcuno ha bisogno di fornire un oggetto che implementa un'interfaccia ampia e complessa, per fare qualcosa di relativamente semplice, probabilmente finirà per scrivere qualunque classe A faccia da sé.

Per consentire alla classe A di consumare oggetti che implementano solo l'interfaccia J, è possibile fornire una classe wrapper che implementa l'interfaccia K e passa qualsiasi chiamata appropriata a un membro di interfaccia J.

Anche se sono d'accordo con le risposte esistenti che dicono che è necessario implementare completamente J (con eccezioni per i metodi non implementati) o non farlo affatto, una possibile soluzione è la seguente:

• Crea un'interfaccia più piccola K che è un sottoinsieme di J e implementa i metodi richiesti.
• Crea un wrapper per A che accetta oggetti che implementano J e K.
• Nel caso di un passato in J, è sufficiente inserirlo nell'istanza di A.
• Nel caso di un passaggio in K, istanziare un'implementazione anonima di J, collegare solo i metodi da K a J che ci sono. Passa il risultato all'istanza di A.

Si noti che questa è una soluzione piuttosto brutta, dal momento che richiede un wrapper che accetta più cose che sono essenzialmente la stessa cosa. Ma realizza quanto segue:

• Nessuna modifica a J o A
• Nessuna implementazione "esposta" di J incompleta.

Se il tuo linguaggio OO non consente l'istanza di un'interfaccia anonima, puoi creare un'implementazione fittizia dell'interfaccia e creare un'istanza di questo.

Quanto tempo impiegherebbe a implementare l'intera interfaccia?

Se ti ci vorrà molto tempo, questo indica un problema di progettazione, e ti consiglierei (come ha fatto Steven A. prima di me) di contattare il proprietario e vedere se può essere modificato in futuro.

Usi l'interfaccia nel tuo codice, indipendentemente dalla libreria dell'interfaccia?

Come suggerito da Steven A., puoi usare la tua interfaccia come vorresti vederla nel tuo codice. Questo almeno mantiene pulito il codice inhouse. Puoi anche inviarlo al proprietario come l'interfaccia che ti aspetteresti di trovare. Forse è d'accordo con te, o forse può spiegarti perché l'interfaccia non deve essere divisa.

La tua implementazione avrebbe mai avuto bisogno dei membri inutilizzati dell'interfaccia?

Nel caso in cui ci si possa aspettare che non vengano mai chiamati perché "non sono supportati", preferisco usare NotSupportedException . Ciò fornisce una chiara indicazione che non supporterai mai questa interfaccia, piuttosto che non l'hai implementata.

Implementa ciò che ti serve e genera un'eccezione NoImplementedException sugli altri.

Questa è una questione di utilizzo. Se non utilizzi l'interfaccia o sai che il tuo codice non utilizzerà l'interfaccia, non investire tempo in questo, poiché non è necessario investire tempo in codice ridondante.

Lavora per il compito da svolgere e mantieni una buona traccia per gli altri da seguire se vogliono utilizzare l'interfaccia.

Molte interfacce in Java non sono completamente implementate.

Questo è l'aproach delle Apache per le cose: link