Konstruktory (F#)
Toto téma popisuje, jak definovat a slouží k vytvoření a inicializace objektů třídy a struktura konstruktory.
Stavební objekty třídy
Objekty třídy typů mají konstruktory.Existují dva druhy konstruktory.Jeden je primární konstruktoru, jehož parametry se zobrazí v závorkách pouze po názvu typu.Určit další konstruktory, volitelné pomocí new klíčové slovo.Další konstruktory musí volat konstruktor primární.
Obsahuje primární konstruktoru let a do vazby, které se zobrazí na začátku definice třídy.A let prohlašuje vazba pole private a metody třídy; do vazba spustí kód.Další informace o let vazby konstruktory tříd, viz Vazby let ve třídách (F#).Další informace o do vazby konstruktory, viz Vazby do ve třídách (F#).
Bez ohledu na to, zda chcete volat konstruktor je primární konstruktor nebo další konstruktoru, můžete vytvořit pomocí objektů new výrazu s nebo bez nepovinné new klíčové slovo.Inicializovat objekty spolu s argumenty konstruktoru, buď výpis argumenty v pořadí a odděleny čárkami a uzavřeny v závorkách, nebo pomocí hodnoty a pojmenované argumenty v závorkách.Můžete také nastavit vlastnosti objektu při konstrukci objektu pomocí názvů vlastností a přiřazení hodnot, stejně jako pomocí pojmenované argumenty konstruktoru.
Následující kód znázorňuje třídu, která má konstruktor a různé způsoby vytváření objektů.
// This class has a primary constructor that takes three arguments
// and an additional constructor that calls the primary constructor.
type MyClass(x0, y0, z0) =
let mutable x = x0
let mutable y = y0
let mutable z = z0
do
printfn "Initialized object that has coordinates (%d, %d, %d)" x y z
member this.X with get() = x and set(value) = x <- value
member this.Y with get() = y and set(value) = y <- value
member this.Z with get() = z and set(value) = z <- value
new() = MyClass(0, 0, 0)
// Create by using the new keyword.
let myObject1 = new MyClass(1, 2, 3)
// Create without using the new keyword.
let myObject2 = MyClass(4, 5, 6)
// Create by using named arguments.
let myObject3 = MyClass(x0 = 7, y0 = 8, z0 = 9)
// Create by using the additional constructor.
let myObject4 = MyClass()
Výstup je takto.
Initialized object that has coordinates (1, 2, 3)
Initialized object that has coordinates (4, 5, 6)
Initialized object that has coordinates (7, 8, 9)
Initialized object that has coordinates (0, 0, 0)
Stavebních konstrukcí
Konstrukce podle pravidla tříd.Proto máte primární konstruktor a může poskytnout další konstruktory pomocí new.Existuje však důležitý rozdíl mezi strukturami a tříd: struktur může mít výchozí konstruktor (tj bez argumentů), i když je definován žádný primární konstruktor.Výchozí konstruktor inicializuje všechna pole na výchozí hodnotu pro daný typ, obvykle nula nebo ekvivalentní.Žádné konstruktory definující struktury musí mít alespoň jeden argument, aby nedošlo ke konfliktu s výchozí konstruktor.
Také struktury mají často polí, které jsou vytvořeny pomocí val klíčové slovo; Tato pole můžete mít také třídy.Struktury a tříd, které mají definovány pomocí polí val klíčové slovo můžete také inicializovat v další konstruktory pomocí záznamu výrazy, jak je znázorněno v následujícím kódu.
type MyStruct =
struct
val X : int
val Y : int
val Z : int
new(x, y, z) = { X = x; Y = y; Z = z }
end
let myStructure1 = new MyStruct(1, 2, 3)
Další informace naleznete v tématu Explicitní pole: Klíčové slovo val (F#).
Vykonávající vedlejší účinky v konstruktory
Primární konstruktor ve třídě mohou spouštět kód v do vazby.Však co když máte spustit kód v další konstruktoru, aniž by do vazby?Chcete-li to provést, použijte then klíčové slovo.
// Executing side effects in the primary constructor and
// additional constructors.
type Person(nameIn : string, idIn : int) =
let mutable name = nameIn
let mutable id = idIn
do printfn "Created a person object."
member this.Name with get() = name and set(v) = name <- v
member this.ID with get() = id and set(v) = id <- v
new() =
Person("Invalid Name", -1)
then
printfn "Created an invalid person object."
let person1 = new Person("Humberto Acevedo", 123458734)
let person2 = new Person()
Vedlejší účinky primární konstruktor stále spuštěn.Výstup je tedy takto.
Created a person object.
Created a person object.
Created an invalid person object.
Vlastní identifikátory v konstruktory
Ostatní členové zadáte název pro aktuální objekt v definici každého člena.Můžete také vložit vlastní identifikátor na prvním řádku definice třídy pomocí as klíčové slovo bezprostředně následující parametry konstruktoru.Následující příklad ukazuje tato syntaxe.
type MyClass1(x) as this =
// This use of the self identifier produces a warning - avoid.
let x1 = this.X
// This use of the self identifier is acceptable.
do printfn "Initializing object with X =%d" this.X
member this.X = x
V další konstruktory můžete také definovat vlastní identifikátor vložením as klauzule doprava po parametry konstruktoru.Následující příklad ukazuje tato syntaxe.
type MyClass2(x : int) =
member this.X = x
new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X
Mohou nastat potíže při pokusu použít objekt před je plně definována.Proto používá vlastní identifikátor může způsobit Kompilátor generuje varování a vložit další kontroly s cílem zajistit, aby že členové objektu nejsou přístupné před objekt je inicializován.Používejte pouze vlastní identifikátor v do vazby primární konstruktor nebo po then klíčové slovo v další konstruktory.
Název identifikátoru self nemá být this.Může být libovolný platný identifikátor.
Přiřazení hodnoty k vlastnosti při inicializaci
Připojením seznam přiřazení formuláře můžete přiřadit hodnoty k vlastnosti objektu třídy v kódu inicializace property = value k seznamu argumentů pro konstruktor.To je ukázáno v následujícím příkladu kódu.
type Account() =
let mutable balance = 0.0
let mutable number = 0
let mutable firstName = ""
let mutable lastName = ""
member this.AccountNumber
with get() = number
and set(value) = number <- value
member this.FirstName
with get() = firstName
and set(value) = firstName <- value
member this.LastName
with get() = lastName
and set(value) = lastName <- value
member this.Balance
with get() = balance
and set(value) = balance <- value
member this.Deposit(amount: float) = this.Balance <- this.Balance + amount
member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount
let account1 = new Account(AccountNumber=8782108,
FirstName="Darren", LastName="Parker",
Balance=1543.33)
Následující verze předcházející kód ukazuje kombinaci běžné argumenty, volitelné argumenty a nastavení vlastností ve volání konstruktoru jeden.
type Account(accountNumber : int, ?first: string, ?last: string, ?bal : float) =
let mutable balance = defaultArg bal 0.0
let mutable number = accountNumber
let mutable firstName = defaultArg first ""
let mutable lastName = defaultArg last ""
member this.AccountNumber
with get() = number
and set(value) = number <- value
member this.FirstName
with get() = firstName
and set(value) = firstName <- value
member this.LastName
with get() = lastName
and set(value) = lastName <- value
member this.Balance
with get() = balance
and set(value) = balance <- value
member this.Deposit(amount: float) = this.Balance <- this.Balance + amount
member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount
let account1 = new Account(8782108, bal = 543.33,
FirstName="Raman", LastName="Iyer")
Statické konstruktory nebo typ konstruktory
Navíc při určování kód pro vytváření objektů statické let a do tvořit v typech třídy, které před používá typ nejprve provést inicializaci na úrovni typ vazby.Další informace naleznete v tématu Vazby let ve třídách (F#) a Vazby do ve třídách (F#).