Devo definire le interfacce nelle lingue Duck Typed?

Question

Sto per scrivere la mia prima applicazione in una lingua con dattilografia (Groovy).

Se dovessi scrivere la stessa domanda in una lingua tipizzato statica allora avrei bisogno di definire alcune interfacce. Ovviamente a causa della digitazione di anatra in Groovy non sono effettivamente necessari. Al momento sto pensando che potrebbe aver senso definirli comunque come documentazione dei metodi che devono essere implementati nei vari oggetti. Mi manca il punto?

Answer 1

Ho letto su questo di recente qui su SO (e non riesco a trovare il link in questo momento, ma è una di quelle "perché sono linguaggi dinamici bene?" I messaggi, e una grande risposta da parte S. Lott con molti commenti), e la risposta è:

Si potrebbe. Specialmente in Groovy, puoi definire interfacce in Java o Groovy e implementarle. Tuttavia, con la tipizzazione delle anatre (che consente Groovy ma consente anche tipi espliciti) molte persone direbbero "perché preoccuparsi?" La fonte è la sua documentazione, l'interfaccia è nella fonte, "usa la fonte" ecc.

Personalmente, questo mi fa impazzire: adoro i controlli in fase di compilazione (o davvero, dev-time) che Java fornisce io, ma questo è un altro dibattito. Se stai usando Groovy, è perché vuoi scrivere quel codice brillantemente conciso e chiaro che deriva dalla tipizzazione delle anatre. In tal caso, le interfacce devono essere evitate tranne ove necessario.

Dove sono necessari? Tra parti di un programma e nell'API pubblica per un programma (sebbene possano essere anche classi astratte). Altrimenti, direi che dovresti cercare di evitarli nelle lingue con dattilografia. Questo ti obbliga a scrivere i documenti sulle classi, o scrivere codice che sia così chiaro che è la stessa cosa.

Penso che questa sia una pratica terribile, TUTTAVIA questo fa parte del cambio di paradigma verso linguaggi dinamici.E penso che se si evita di separare l'interfaccia dall'implementazione abbastanza, capirai il "perché" dietro di esso. Ancora non lo faccio, anche se ha molto a che fare con il non ripetere il codice (mantenendo DRY).

Edit: avuto qualche chiarezza lontano dal computer :) Uno dei principali motivi di non separare l'interfaccia dall'implementazione è così che ci si allontana da una dipendenza da tipi. Nella scrittura delle anatre, come sai, non mi interessa se si tratta di un implementatore dell'interfaccia Vehicle (ad esempio). Mi interessa solo se ha un metodo go con 2 parametri. Quindi più lavori con le interfacce, più scrivi Java in Groovy ("puoi scrivere Fortran in qualsiasi lingua"). Questo dovrebbe essere evitato, in quanto le nuove lingue ti aprono a nuove cose.

Answer 2

Definire un'interfaccia è un tipo di documentazione in codice. Con un'interfaccia dichiari esplicitamente ciò che si aspetta dalla classe per soddisfare le proprie esigenze.

PS: Groovy non è la mia lingua, quindi io in realtà non lo so se è possibile definire le interfacce là affatto.

Answer 3

Non ho familiarità con groove, ma in generale, no, non c'è bisogno di definire le interfacce in lingue debolmente tipizzato.

1. Si sarebbe ripeterti, se è necessario modificare una firma metodi, allora avete bisogno di farlo in due luoghi, non uno.

2. Sebbene le interfacce possano essere utilizzate come documentazione, in un linguaggio a caratteri generici, la maggior parte dei codificatori non si aspetta un'interfaccia e pertanto non andranno alla ricerca di un'interfaccia se hanno bisogno di documentazione.

3. lingue più dinamici hanno una buona di IDE disponibile per loro, con il completamento metodo, che diminuisce ulteriormente la necessità di un'interfaccia separata.

4. I metodi possono essere legati e non legati a linguaggi dinamici. Pertanto, è possibile, e probabilmente lo farà, finire con oggetti che non aderiscono all'interfaccia. Avere un'interfaccia separata potrebbe confondere le persone che leggono il tuo codice.

Answer 4

In alcuni casi sì. Ho un esempio in cui sto creando una classe Groovy che viene iniettata in una classe Java da Spring. Ho creato un'interfaccia utilizza farmaci generici in questo modo:

//interface injected to a java class 
public interface SomeInterface { 
    <T> T getSomething(int version, Long id); 
} 

Poi l'attuazione Groovy è simile al seguente:

//Groovy impelentation 
class SomeInterfaceImpl implements SomeInterface { 
    def getSomething(int version, Long id) { 
     //use duck typing to create similar objects based on version 
    } 
} 

Il mio esempio è che sto usando JAXB e XJC per creare gli oggetti da uno schema XML e utilizzandoli in un servizio web riposante di Jersey. Sto facendo il versioning del servizio web e le modifiche sono sufficienti per la versione, ma c'è ancora molto codice che può essere riutilizzato. L'utilizzo delle interfacce si è rivelato problematico, quindi ho usato Groovy e ho spostato tutta la logica simile alla classe Groovy sopra citata con la digitazione anatra. Gli oggetti sono per lo più gli stessi con alcune modifiche, quindi la digitazione anatra con un'interfaccia da iniettare nella classe Java funziona perfettamente.