Abstraktní třídy (F#)
Abstraktní třídy jsou třídy ponechejte některých nebo všech členů Neimplementovaný, mohou být dodávána implementací odvozené třídy.
// Abstract class syntax.
[<AbstractClass>]
type [ accessibility-modifier ] abstract-class-name =
[ inherit base-class-or-interface-name ]
[ abstract-member-declarations-and-member-definitions ]
// Abstract member syntax.
abstract member member-name : type-signature
Poznámky
V objektově orientovaném programování abstraktní třída slouží jako základní třída hierarchie a představuje běžné funkce sada typů objektů.Jak napovídá název "abstraktní", abstraktní třídy často neodpovídají přímo na konkrétní subjekty v doméně problém.Však představují co mnoho různých konkrétních subjektů mají společné.
Abstraktní třídy musí mít AbstractClass atributu.Může být implementováno a Neimplementovaný členů.Používání termínu abstraktní při použití třídy je stejný jako v ostatních.NET jazyků; však používání termínu abstraktní je něco jiného v F# z jeho použití v jiných při použití metody (a vlastnosti).NET jazyků.F# při metoda je označena abstract klíčové slovo, to znamená, že člen má položka, známé jako virtuální odeslání patice, ve vnitřní tabulka virtuálních funkcí daného typu.Jinými slovy, metoda je virtuální, ačkoli virtual klíčové slovo není použit v jazyce F#.Klíčové slovo abstract se používá pro virtuální metody bez ohledu na to, zda je metoda implementována.Prohlášení o odeslání virtuální patice je oddělené od definice metody pro odeslání patice.Proto F# ekvivalent prohlášení virtuální metody a definice v jiném.NET jazyk je kombinací deklaraci abstraktní metoda a samostatné definice, buď default klíčové slovo nebo override klíčové slovo.Další informace a příklady naleznete v tématu Metody (F#).
Třída je považován za abstraktní, pouze pokud existuje abstraktní metody, které jsou deklarovány, ale není definována.Proto tříd, které mají abstraktní metody nejsou nutně abstraktní třídy.Pokud třída má undefined abstraktní metody, nepoužívejte AbstractClass atributu.
In the previous syntax, accessibility-modifier can be public, private or internal.Další informace naleznete v tématu Řízení přístupu (F#).
Jako u jiných typů může mít abstraktní třídy základní třídy a jeden nebo více základních rozhraních.Každá základní třídy nebo rozhraní se zobrazí na samostatném řádku s inherit klíčové slovo.
Definice typu abstraktní třídy mohou obsahovat zcela definované členy, ale může také obsahovat abstraktní členy.Syntaxe pro abstraktní členy se zobrazí samostatně v předchozí syntaxe.V této syntaxe type signature člena je seznam, který obsahuje parametr typy objednávky a vratky typů oddělených -> tokeny nebo * tokeny podle potřeby pro curried a tupled parametry.Syntaxe pro abstraktní člena typu podpisy je stejné jako v soubory podpisů a uvedený v editoru kódu Studio Visual technologie IntelliSense.
Příklad
Následující kód ilustruje abstraktní třída Shape, která má dvě třídy odvozené neabstraktním Square a Circle.Příklad ukazuje použití abstraktní třídy, metody a vlastnosti.V příkladu abstraktní třída Shape představuje běžné prvky konkrétních subjektů kruh a čtverec.Běžné funkce všech obrazců (v dvojrozměrném souřadnicovém systému) odebrané ven do Shape třídy: umístění na mřížce, úhel otočení a vlastnosti oblast a obvod.To může být přepsána, s výjimkou pro pozici, chování, které nelze změnit jednotlivé tvary.
Metoda otáčení lze přepsat, v Circle třídy, která je výchozí otočení z důvodu jeho symetrie.Takže v Circle třídy metody otáčení nahrazuje metodu, která nemá žádnou.
// An abstract class that has some methods and properties defined
// and some left abstract.
[<AbstractClass>]
type Shape2D(x0 : float, y0 : float) =
let mutable x, y = x0, y0
let mutable rotAngle = 0.0
// These properties are not declared abstract. They
// cannot be overriden.
member this.CenterX with get() = x and set xval = x <- xval
member this.CenterY with get() = y and set yval = y <- yval
// These properties are abstract, and no default implementation
// is provided. Non-abstract derived classes must implement these.
abstract Area : float with get
abstract Perimeter : float with get
abstract Name : string with get
// This method is not declared abstract. It cannot be
// overriden.
member this.Move dx dy =
x <- x + dx
y <- y + dy
// An abstract method that is given a default implementation
// is equivalent to a virtual method in other .NET languages.
// Rotate changes the internal angle of rotation of the square.
// Angle is assumed to be in degrees.
abstract member Rotate: float -> unit
default this.Rotate(angle) = rotAngle <- rotAngle + angle
type Square(x, y, sideLengthIn) =
inherit Shape2D(x, y)
member this.SideLength = sideLengthIn
override this.Area = this.SideLength * this.SideLength
override this.Perimeter = this.SideLength * 4.
override this.Name = "Square"
type Circle(x, y, radius) =
inherit Shape2D(x, y)
let PI = 3.141592654
member this.Radius = radius
override this.Area = PI * this.Radius * this.Radius
override this.Perimeter = 2. * PI * this.Radius
// Rotating a circle does nothing, so use the wildcard
// character to discard the unused argument and
// evaluate to unit.
override this.Rotate(_) = ()
override this.Name = "Circle"
let square1 = new Square(0.0, 0.0, 10.0)
let circle1 = new Circle(0.0, 0.0, 5.0)
circle1.CenterX <- 1.0
circle1.CenterY <- -2.0
square1.Move -1.0 2.0
square1.Rotate 45.0
circle1.Rotate 45.0
printfn "Perimeter of square with side length %f is %f, %f"
(square1.SideLength) (square1.Area) (square1.Perimeter)
printfn "Circumference of circle with radius %f is %f, %f"
(circle1.Radius) (circle1.Area) (circle1.Perimeter)
let shapeList : list<Shape2D> = [ (square1 :> Shape2D);
(circle1 :> Shape2D) ]
List.iter (fun (elem : Shape2D) ->
printfn "Area of %s: %f" (elem.Name) (elem.Area))
shapeList