Compartilhar via


Herança (F#)

Herança é usada para o modelo de "é-um" relação de formação de subtipos, na programação orientada a objeto.

Especificando as relações de herança

Especifique as relações de herança usando a 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 uma classe no máximo em base direta. Se você não especificar 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 usuários da classe derivada, como se fossem membros diretos da classe derivada.

Qualquer permitem ligações e os 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 nas classes derivadas e refere-se para a 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 idiomas. Para declarar um novo membro virtual, use o abstract palavra-chave. Para fazer isso independentemente, por exemplo, se você fornecer 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 de 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 argumento de 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 da 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 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 de variados de modelo de objetos diferentes 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 uniões discriminadas, consulte Uniões discriminadas (F#).

Consulte também

Referência

Expressões de objeto (F#)

Outros recursos

Referência de linguagem do F#

Histórico de alterações

Date

History

Motivo

Setembro de 2010

Adicionadas informações e exemplo de código para o uso de vários construtores de classe base.

Aprimoramento de informações.