Interfaccia in un linguaggio dinamico?

Question

L'interfaccia (o una classe astratta con tutti i metodi astratti) è un'arma potente in un linguaggio tipizzato come C#, JAVA. Permette di utilizzare diversi tipi di derivati ​​in modo uniforme. I modelli di progettazione ci incoraggiano a utilizzare l'interfaccia il più possibile.

Tuttavia, in un linguaggio con dattilografia dinamica, tutti gli oggetti non vengono controllati per il loro tipo in fase di compilazione. Non devono implementare un'interfaccia per essere utilizzati in un modo specifico. Devi solo assicurarti che abbiano determinati metodi (attributi) definiti. Ciò rende l'interfaccia non necessaria, o almeno non così utile come in un linguaggio statico.

Un tipico linguaggio dinamico (ad esempio rubino) ha un'interfaccia? Se lo fa, quali sono i vantaggi di averlo? In caso contrario, stiamo perdendo molti dei bellissimi modelli di progettazione che richiedono un'interfaccia?

Grazie.

Answer 1

Suppongo che non ci sia una risposta unica per tutte le lingue dinamiche. In Python, ad esempio, non ci sono interfacce, ma esiste un'eredità multipla. L'utilizzo di classi simili all'interfaccia è comunque utile:

• Le classi di tipo interfaccia possono fornire l'implementazione predefinita dei metodi;
• Duck-typing è buono, ma in una certa misura; a volte è utile essere in grado di scrivere isinstance(x, SomeType), in particolare quando SomeType contiene molti metodi.

Answer 2

Le interfacce in lingue dinamiche sono utili come documentazione delle API che possono essere verificate automaticamente, ad es. dagli strumenti di sviluppo o asserisce in fase di runtime.

Ad esempio, zope.interface è lo standard di fatto per le interfacce in Python. Progetti come Zope e Twisted che espongono enormi API per il consumo lo trovano utile, ma per quanto ne so non viene utilizzato molto al di fuori di questo tipo di progetti.

Answer 3

In Ruby, che è un linguaggio tipizzato in modo dinamico e consente solo l'ereditarietà singola, è possibile simulare una "interfaccia" tramite mixin, anziché inquinare la classe con i metodi dell'interfaccia.

Le mixine imitano in parte l'ereditarietà multipla, consentendo ad un oggetto di "ereditare" da più fonti, ma senza l'ambiguità e la complessità di avere effettivamente più genitori. C'è solo un vero genitore.

Per implementare un'interfaccia (in senso astratto, non un tipo di interfaccia reale come in lingue con tipizzazione statica) Si definisce un modulo come se fosse un'interfaccia in un linguaggio statico. Quindi lo includi nella classe. Ecco! Hai raccolto il tipo di anatra in quella che è essenzialmente un'interfaccia.

esempio molto semplificato:

module Equippable 
    def weapon 
    "broadsword" 
    end 
end 


class Hero 
    include Equippable 

    def hero_method_1 
    end 

    def hero_method_2 
    end 
end 


class Mount 
    include Equippable 

    def mount_method_1 
    end 
end 


h = Hero.new 
h.weapon # outputs "broadsword" 


m = Mount.new 
m.weapon # outputs "broadsword" 

attrezzabile è l'interfaccia per l'eroe, il Monte, e qualsiasi altra classe o modello che lo include.

(Ovviamente, l'arma sarà molto probabilmente impostata in modo dinamico da un inizializzatore, che è stato semplificato via in questo esempio.)