Interfaces (F#)
Interfaces especificar conjuntos de membros relacionados que implementam a outras classes.
// Interface declaration:
[ attributes ]
type interface-name =
[ interface ]
[ inherit base-interface-name ...]
abstract member1 : [ argument-types1 -> ] return-type1
abstract member2 : [ argument-types2 -> ] return-type2
...
[ end ]
// Implementing, inside a class type definition:
interface interface-name with
member self-identifier.member1 argument-list = method-body1
member self-identifier.member2 argument-list = method-body2
// Implementing, by using an object expression:
[ attributes ]
let class-name (argument-list) =
{ new interface-name with
member self-identifier.member1 argument-list = method-body1
member self-identifier.member2 argument-list = method-body2
[ base-interface-definitions ]
}
member-list
Comentários
Declarações de interface são semelhantes às declarações de classe, exceto que não há membros são implementados. Em vez disso, todos os membros são abstratos, conforme indicado pela palavra-chave abstract. Você não fornecer um corpo de método para métodos abstratos. No entanto, você pode fornecer uma implementação padrão, incluindo também uma definição de separado do membro como um método em conjunto com o default palavra-chave. Fazer isso é equivalente à criação de um método virtual na classe base em outros.NET idiomas. Um método virtual pode ser substituído nas classes que implementam a interface.
Há duas maneiras de implementar interfaces: usando expressões de objeto e usando tipos de classe. Em ambos os casos, a expressão de tipo ou objeto de classe fornece corpos de métodos abstratos da interface. Implementações são específicas para cada tipo que implementa a interface. Portanto, a métodos de interface em diferentes tipos podem ser diferentes entre si.
As palavras-chave interface e end, que marca o início e no final da definição, são opcionais, quando você usa uma sintaxe simples. Se você não usar essas palavras-chave, o compilador tenta deduzir se o tipo é uma classe ou uma interface, analisando as construções que você usar. Se você define um membro ou usa outra sintaxe de classe, o tipo é interpretado como uma classe.
A.NET, estilo de codificação é começar a todas as interfaces com uma letra maiúscula I.
Implementar Interfaces usando os tipos de classe
Você pode implementar uma ou mais interfaces em um tipo de classe usando o interface palavra-chave, o nome da interface e o with palavra-chave, seguido as definições de membro de interface, conforme mostrado no código a seguir.
type IPrintable =
abstract member Print : unit -> unit
type SomeClass1(x: int, y: float) =
interface IPrintable with
member this.Print() = printfn "%d %f" x y
Implementações de interface são herdadas, portanto, quaisquer classes derivadas não precisarão reimplementá-los.
Chamar os métodos de Interface
Os métodos de interface podem ser chamados apenas por meio da interface, e não através de qualquer objeto do tipo que implementa a interface. Assim, você pode ter de elevação para o tipo de interface usando o :> operador ou a upcast o operador para chamar esses métodos.
Para chamar o método de interface quando você tem um objeto do tipo SomeClass, você deve elevação do objeto para o tipo de interface, conforme mostrado no código a seguir.
let x1 = new SomeClass1(1, 2.0)
(x1 :> IPrintable).Print()
Uma alternativa é declarar um método no objeto que upcasts e chama o método de interface, como no exemplo a seguir.
type SomeClass2(x: int, y: float) =
member this.Print() = (this :> IPrintable).Print()
interface IPrintable with
member this.Print() = printfn "%d %f" x y
let x2 = new SomeClass2(1, 2.0)
x2.Print()
Implementar Interfaces usando expressões de objeto
Expressões de objeto fornecem uma forma abreviada para implementar uma interface. Eles são úteis quando você não precisa criar um tipo nomeado e quiser somente que um objeto que suporta os métodos de interface, sem quaisquer métodos adicionais. Uma expressão de objeto é ilustrada no código a seguir.
let makePrintable(x: int, y: float) =
{ new IPrintable with
member this.Print() = printfn "%d %f" x y }
let x3 = makePrintable(1, 2.0)
x3.Print()
Herança da interface
Interfaces podem herdar de uma ou mais interfaces de base.
type Interface1 =
abstract member Method1 : int -> int
type Interface2 =
abstract member Method2 : int -> int
type Interface3 =
inherit Interface1
inherit Interface2
abstract member Method3 : int -> int
type MyClass() =
interface Interface3 with
member this.Method1(n) = 2 * n
member this.Method2(n) = n + 100
member this.Method3(n) = n / 10
Consulte também
Referência
Outros recursos
Histórico de alterações
Date |
History |
Motivo |
|---|---|---|
Substitua por data de alteração. |
Adicionadas informações sobre herança da interface. |
Aprimoramento de informações. |