Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Ereditarietà (C#)

L'ereditarietà viene utilizzata per modellare la relazione di tipo "è", o definizione di sottotipo, nella programmazione orientata a oggetti.

È possibile specificare relazioni di ereditarietà utilizzando la parola chiave inherit in una dichiarazione di classe. Nell'esempio seguente viene illustrata la forma sintattica di base.

type MyDerived(...) =
   inherit MyBase(...)

Una classe può disporre al massimo di una classe di base diretta. Se non si specifica una classe di base utilizzando la parola chiave inherit, la classe eredita in modo implicito da Object.

Se una classe eredita da un'altra classe, i metodi e i membri della classe di base sono disponibili per gli utenti della classe derivata come se fossero membri diretti della classe derivata.

Le associazioni let e i parametri dei costruttori sono privati di una classe e, pertanto, non è possibile accedervi dalle classi derivate.

La parola chiave base è disponibile nelle classi derivate e fa riferimento all'istanza della classe di base. Il suo utilizzo è analogo a quello dell'autoidentificatore.

I metodi (e le proprietà) virtuali in F# funzionano in modo in parte diverso rispetto agli altri linguaggi .NET. Per dichiarare un nuovo membro virtuale, si utilizza la parola chiave abstract. Questa modalità viene utilizzata indipendentemente dal fatto che venga fornita un'implementazione predefinita per il metodo. Una definizione completa di un metodo virtuale in una classe di base segue pertanto questo modello:

abstract member method-name : type

default self-identifier.method-nameargument-list = method-body

In una classe derivata un override di un metodo virtuale segue invece questo modello:

override self-identifier.method-nameargument-list = method-body

Se si omette l'implementazione predefinita nella classe di base, la classe di base diventa una classe astratta.

Nell'esempio di codice seguente viene illustrata la dichiarazione di un nuovo metodo virtuale function1 in una classe di base e viene indicato come eseguire l'override del metodo in una classe derivata.


type MyClassBase1() =
   let mutable z = 0
   abstract member function1 : int -> int
   default u.function1(a : int) = z <- z + a; z

type MyClassDerived1() =
   inherit MyClassBase1()
   override u.function1(a: int) = a + 1


Il costruttore per la classe di base deve essere chiamato nella classe derivata. Gli argomenti per il costruttore della classe di base sono visualizzati nell'elenco di argomenti nella clausola inherit. I valori utilizzati devono essere determinati dagli argomenti forniti al costruttore della classe derivata.

Nel codice seguente vengono illustrate una classe di base e una classe derivata, dove la classe derivata chiama il costruttore della classe di base nella clausola inherit:


type MyClassBase2(x: int) =
   let mutable z = x * x
   do for i in 1..z do printf "%d " i


type MyClassDerived2(y: int) =
   inherit MyClassBase2(y * 2)
   do for i in 1..y do printf "%d " i


Nel caso di più costruttori, è possibile utilizzare il codice seguente. La prima riga dei costruttori della classe derivata è la clausola inherit e i campi appaiono come campi espliciti dichiarati con la parola chiave val. Per ulteriori informazioni, vedere Campi espliciti: parola chiave val.

type BaseClass =
    val string1 : string
    new (str) = { string1 = str }
    new () = { string1 = "" }

type DerivedClass =
    inherit BaseClass
    val string2 : string
    new (str1, str2) = { inherit BaseClass(str1); string2 = str2 }
    new (str2) = { inherit BaseClass(); string2 = str2 }

let obj1 = DerivedClass("A", "B")
let obj2 = DerivedClass("A")

Nei casi in cui è necessaria una modifica minore di un tipo, considerare l'utilizzo di un'espressione di oggetto in alternativa all'ereditarietà. Nell'esempio seguente viene illustrato l'utilizzo di un'espressione di oggetto come alternativa alla creazione di un nuovo tipo derivato:


open System

let object1 = { new Object() with
      override this.ToString() = "This overrides object.ToString()"
      }

printfn "%s" (object1.ToString())


Per ulteriori informazioni sulle espressioni di oggetto, vedere Espressioni di oggetto (F#).

Quando si creano gerarchie di oggetti, considerare l'utilizzo di un'unione discriminata anziché dell'ereditarietà. Le unioni discriminate consentono inoltre di modellare vari comportamenti di oggetti differenti che condividono un tipo complessivo comune. Una singola unione discriminata consente spesso di eliminare la necessità di numerose classi derivate che costituiscono variazioni minori una dell'altra. Per informazioni sulle unioni discriminate, vedere Unioni discriminate (F#).

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft