Perché usiamo l’interfaccia? È solo per la standardizzazione?

Perché usiamo l’interfaccia?

È solo per la standardizzazione?

Scopi delle interfacce

  • creare un software liberamente accoppiato
  • supportare la progettazione per contratto (un implementatore deve fornire l’intera interfaccia)
  • consentire il software collegabile
  • consentire a oggetti diversi di interagire facilmente
  • hide i dettagli di implementazione delle classi l’uno dall’altro
  • facilitare il riutilizzo del software

Analogia 1 : Proprio come lo space shuttle statunitense, la navicella spaziale russa Soyuz e la cinese Shenzhou 5 possono tutti attraccare alla Stazione Spaziale Internazionale, perché implementano la stessa interfaccia di docking. (Questo è solo un esempio – non so se è vero nella vita reale, ma sospendiamo l’incredulità per un esempio)

Analogy 2 : come puoi colbind vari monitor di computer al tuo computer di casa. Puoi colbind un televisore a parete, un vecchio CRT (tipo spessa), uno schermo piatto da 20 “o una macchina braille per i non vedenti per” vedere “al tatto. C’è compatibilità tra questi vari / diversi dispositivi e il tuo computer perché sono tutti d’accordo sugli standard di interfaccia.

Dettagli delle interfacce C # – Con le interfacce C # / OOP si sta facendo lo stesso genere di cose, ma nel mondo invisibile / virtuale.

Hai ragione riguardo la standardizzazione , ma anche flessibilità , scalabilità , estensibilità , manutenibilità , riutilizzabilità , testabilità e potenza .

(Più usi le interfacce software più queste “parole d’ordine” saranno comprese e consideri sempre le interfacce nel mondo reale perché ci hanno fatto egualmente bene).

Un’interfaccia è usata per descrivere cosa può fare una cosa implementata. Quindi hai la possibilità di trattare diversi oggetti che implementano la stessa interfaccia di un tipo di questa interfaccia.

Per esempio:

 public interface IMyInterface{ public void DoFirst(); public int DoSecond(); } public class A : IMyInterface{ //class has to implement DoFirst and DoSecond public void DoFirst(){ Console.WriteLine("Blubb1"); } public int DoSecond(){ Console.WriteLine("Blubb2"); return 2; } } public class B : IMyInterface{ //class has to implement DoFirst and DoSecond public void DoFirst(){ Console.WriteLine("Blibb1"); } public int DoSecond(){ Console.WriteLine("Blibb2"); return 4; } } 

Le classi implementano l’interfaccia in diversi modi. Ma puoi usarli come IMyInterface. Per esempio:

 public static void DoMethodsInInterface(IMyInterface inter){ inter.DoFirst(); inter.DoSecond(); } public static void main(){ DoMethodsInInterface(new A()); DoMethodsInInterface(new B()); //Or use it in a List List interlist = new List(); interlist.Add(new A()); interlist.Add(new B()); foreach(IMyInterface inter in interlist){ inter.DoFirst(); } } 

Spero che questo chiarisca perché le interfacce sono utili.

È per l’interfaccia :), in modo da poter interfacciare tra cose, è utile quando hai

  • implementazioni multiple della stessa roba
  • quando applichi un’interfaccia a più classi diverse perché hai bisogno di una sorta di convenzione che queste classi siano in grado di fare alcune cose o avere qualche funzionalità

La ragione principale per cui le interfacce sono usate in linguaggi come C # / Java è perché tali linguaggi non supportano l’ereditarietà multipla (di class) (vedi Qual è il problema esatto con l’ereditarietà multipla? ).

Ma l’implementazione multipla (interfaccia) è permessa permettendo alle classi di essere usate in modi diversi.

Ecco la vista di alto livello …

Le interfacce svolgono un ruolo importante nel concetto di hide le informazioni .

Fondamentalmente ti aiutano a hide i dettagli di implementazione della tua class in modo che una class chiamante non abbia alcuna dipendenza da tale implementazione. Pertanto, utilizzando le interfacce è ansible modificare l’implementazione senza modificare la class chiamante. Questo a sua volta limita la complessità del codice e ne facilita la manutenzione a lungo termine.

Quando ho iniziato a capire le interfacce mi sono state spiegate come “un contratto che fornisce una descrizione della tua class”. Non sono sicuro che questo ti aiuterà ma se pensi ad un’interfaccia per un’auto potresti dire che guida , si rompe e gira . Quindi, finché mi arriva dal punto A al punto B, non ho davvero bisogno di sapere come sono implementate queste funzioni.

Le interfacce sono piuttosto scomode. Supportano la progettazione per contratto semplicemente credendo che lo stesso nome e l’interfaccia implementata significano lo stesso comportamento. Funziona solo grazie alla documentazione dell’API, deve essere controllato dall’uomo. Ciò rende le interfacce troppo deboli. Un modo per aggirare quello potrebbe essere le specifiche formali. D’altro canto, le interfacce sono troppo forti, troppo rigide. Non è ansible evolvere interfacce che spesso ostacolano il riutilizzo. Questo è risolto dai protocolli – meccanismo in linguaggi dinamici, che inviano messaggi (metodi di chiamata) e quando tale messaggio non è supportato dal ricevitore, viene richiamata la richiamata standard. Avere protocolli concreti con vincoli sarebbe meglio imho.

Pensa al remoting …

C’è un client e un server coinvolti qui. Diciamo che sono fisicamente separati da internet. Il client sta chiamando un metodo la cui esecuzione effettiva avviene sul server. Dal punto di vista del cliente, il client non sa nulla sull’object nel server che esegue l’esecuzione. Tuttavia sa quale metodo chiamare. Perché mentre costruisci il programma client, siamo solo esposti a un’interfaccia (o contratto). Non siamo esposti all’intero object che sta effettivamente vivendo sul server. Prova a fare alcune app demo in .net remoting, e vedrai il resto. Buona programmazione

Perché usiamo le interfacce?

Alcuni linguaggi implementano chiamate al metodo polimorfico usando vtables e scarta la maggior parte delle informazioni sul tipo, rendendo difficile non definire le interfacce.

Quindi a volte utilizziamo semplicemente le interfacce perché il linguaggio design lo richiede.

Iniziando con un’interfaccia, è ansible implementare un proxy , consentendo così il caricamento lento o l’esecuzione di alcune verifiche quando si chiamano i metodi di un’implementazione concreta.

L’interfaccia separa il tipo di dati dalla logica di implementazione.

L’interfaccia fornisce il prototipo modale che contiene solo la dichiarazione di funzionalità di un comportamento specifico.

e se vuoi implementare questo comportamento in class, allora devi implementare questa interfaccia in class, allora la class ha questa funzionalità comportamentale o può avere un comportamento multiplo.

perché la class può implementare più interfacce.

Se qualcun altro è come me e impara con l’esempio e facendo, piuttosto che solo una spiegazione, ecco un codice ….

Ho trovato questa implementazione di una rete neurale in C #, incluso il download del progetto, che utilizza le interfacce in modo elegante e utile:

http://www.c-sharpcorner.com/UploadFile/rmcochran/AI_OOP_NeuralNet06192006090112AM/AI_OOP_NeuralNet.aspx

Di seguito sono riportati i principali motivi per l’utilizzo delle interfacce

  1. Estensibilità
  2. Nascondere l’implementazione
  3. Accesso all’object tramite interfacce
  4. Accoppiamento lasco.

si prega di visitare questo link per conoscere le interfacce con esempio di codice scaricabile