Herança (F#)
Herança é usada para modelar a relação "é-um", ou a formação de subtipos, na programação orientada a objeto.
Especificando as relações de herança
Você especifica as relações de herança, usando o inherit palavra-chave em uma declaração de classe. A forma básica de sintática é mostrada no exemplo a seguir.
type MyDerived(...) =
inherit MyBase(...)
Uma classe pode ter no máximo uma direta base classe de. Se você não especifica uma classe base, usando o inherit palavra-chave, a classe implicitamente herda de Object.
Membros herdados
Se uma classe herda de outra classe, os métodos e os membros da classe base estão disponíveis para os usuários da classe derivada, como se fossem membros diretos da classe derivada.
Qualquer permitem ligações e parâmetros do construtor são particulares a uma classe e, portanto, não podem ser acessados a partir de classes derivadas.
A palavra-chave base está disponível em classes derivadas e refere-se à instância da classe base. Ele é usado como o self-identifier.
Métodos virtuais e as substituições
Métodos virtuais (e propriedades) funcionam um pouco diferente em F# em relação aos outros.NET diferentes. Para declarar um novo membro virtual, que você use o abstract palavra-chave. Para fazer isso independentemente, por exemplo, se você fornece uma implementação padrão para esse método. Assim, uma definição completa de um método virtual na classe base segue este padrão:
abstract member method-name : type
default self-identifier.method-name argument-list = method-body
E, em uma classe derivada, uma substituição desse método virtual segue este padrão:
override self-identifier.method-name argument-list = method-body
Se você omitir a implementação padrão da classe base, a classe base torna-se uma classe abstrata.
O exemplo de código a seguir ilustra a declaração de um novo método virtual function1 em uma classe base e como substituí-la em uma classe derivada.
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
Construtores e herança
O construtor da classe base deve ser chamado na classe derivada. Os argumentos para o construtor de classe base aparecem na lista de argumentos na inherit cláusula. Os valores que são usados devem ser determinados dos argumentos fornecidos para o construtor de classe derivada.
O código a seguir mostra uma classe base e uma classe derivada, onde a classe derivada chama o construtor de classe base na cláusula herdar:
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
No caso de vários construtores, o código a seguir pode ser usado. A primeira linha dos construtores de classe derivada é o inherit cláusula e os campos aparecem como campos explícitos que são declarados com a val palavra-chave. Para obter mais informações, consulte campos explícito: O val palavra-chave.
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")
Alternativas para a herança
Em casos onde uma pequena modificação de um tipo é necessária, considere o uso de uma expressão de objeto como uma alternativa para a herança. O exemplo a seguir ilustra o uso de uma expressão de objeto como uma alternativa para criar um novo tipo derivado:
open System
let object1 = { new Object() with
override this.ToString() = "This overrides object.ToString()"
}
printfn "%s" (object1.ToString())
Para obter mais informações sobre expressões de objeto, consulte Expressões de objeto (F#).
Quando você estiver criando hierarquias de objeto, considere o uso de uma união discriminada em vez da herança. Uniões discriminadas podem, também, o comportamento do modelo variado de diferentes objetos que compartilham um tipo comum de geral. Uma união discriminada única pode muitas vezes eliminar a necessidade de um número de classes derivadas que são pequenas variações uns dos outros. Para obter informações sobre as uniões discriminadas, consulte Uniões discriminadas (F#).