TOC

This article is currently in the process of being translated into Italian (~99% done).

Classi:

Interfaces

Nei precedenti capitoli, abbiamo visto le classi astratte. Le interfacce sono molto simili alle classi astratte e hanno in comune il fatto che non non si possono creare istanze. Comunque, le interfacce sono molto più concettuali delle classi astratte, dato che non è permesso nessun corpo all'interno del metodo. Quindi una interfaccia è una sorta di classe astratta ma con solo metodi astratti, e dato che non ci sono metodi con del codice, non c'è bisogno di nessun campo. Le proprietà sono permesse però, come lo sono gli indici e gli eventi. Puoi considerare una interfaccia come un contratto - la classe che la implementa dovrà implementare tutti i metodi e le proprietà. Comunque, la più importante differenza è che, mentre C# non ti permette la multi ereditarietà, dove le classi ereditano più di una classe base, la classe può implementare più di una interfaccia!

Quindi, che sembianze prende il codice? Ecco un esempio abbastanza completo. Guarda, forse provalo tu stesso, e poi continua a leggere per la spiegazione completa:

using System;
using System.Collections.Generic;

namespace Interfaces
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Dog> dogs = new List<Dog>();
            dogs.Add(new Dog("Fido"));
            dogs.Add(new Dog("Bob"));
            dogs.Add(new Dog("Adam"));
            dogs.Sort();
            foreach(Dog dog in dogs)
                Console.WriteLine(dog.Describe());
            Console.ReadKey();
        }
    }

    interface IAnimal
    {
        string Describe();

        string Name
        {
            get;
            set;
        }
    }

    class Dog : IAnimal, IComparable
    {
        private string name;

        public Dog(string name)
        {
            this.Name = name;
        }

        public string Describe()
        {
            return "Hello, I'm a dog and my name is " + this.Name;
        }

        public int CompareTo(object obj)
        {
            if(obj is IAnimal)
                return this.Name.CompareTo((obj as IAnimal).Name);
            return 0;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

Iniziamo dal centro dove dichiariamo l'interfaccia. Come puoi vedere l'unica differenza dalla dichiarazione di classe è la parola chiave usata, interface al posto di class. Inoltre il nome dell'interfaccia è prefisso con la I di interfaccia - è uno standard di programmazione e non un requisito. Si puo chiamare l'interfaccia quando si vuole e dato che si usano così tanto quanto le classi che potresti avere difficoltà a differenziarli il prefisso I ha senso.

Dopodichè dichiariamo il metodo Describe e la proprietà Name che possiede le parole chiavi get e set, rendendola una proprietà di sia lettura che scrittura. Noterai anche la mancanza delle proprietà d'accesso (public, private, protected etc.), questo perchè non sono permesse nelle interfacce essendo public di default.

Subito dopo abbiamo la classe Dog. Vedi che sembra abbia ereditato da un altra classe, con i doppi punti fra il nome della classe e la classe/interfaccia che è sottoclasse/implementata. Tuttavia, in questo caso, due interfacce vengono implementate per la stessa classe semplicemente separate da una virgola. Si possono implementare quante interfacce si vogliono, in questo caso solamente due - l'interfaccia IAnimal e l'interfaccia .NET IComparable interface che si tratta di un interfaccia comunque per classi che possono essere ordinate. Come puoi vedere abbiamo implementato entrambi i metodi e le proprietà dall'interfaccia IAnimal insieme al metodo CompareTo dall'interfaccia IComparable.

Adesso potresti pensare: se dobbiamo fare tutto il lavoro noi stessi, implementando tutti i metodi e le proprietà, perchè prendersene la briga? Un buon motivo lo possiamo vedere in cima al nostro esempio. Per prima cosa aggiungiamo un paio di oggetti Dog alla lista e dopodiche li riordiano. Come fa la lista a sapere come riordinarli? Semplicemente la classe Dog ha il metodo CompareTo che puo dirgli come comparare due oggetti Dog. Come fa la lista a sapere che l'oggetto Dog può farlo e che metodo chiamare per averli comparati? Glie l'abbiamo detto noi, implementando un interfaccia che possiede un metodo CompareTo! Questa è la bellezza delle interfacce.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!