Swift Bauprozess

Bauverfahren ist eine Instanz einer Klasse, Struktur oder Aufzählungstyp verwenden, um den Herstellungsprozess durchgeführt. Dieser Prozess beinhaltet für jedes Attribut und die Instanz für die Vorbereitung und Durchführung der erforderlichen Initialisierung Aufgaben Anfangswerte.

Swift Konstruktor init () -Methode.

Und Objective-C in verschiedenen Konstruktor, der Konstruktor Swift keinen Wert, ihre Hauptaufgabe zurückkehren muss, um sicherzustellen, dass die neue Instanz vor dem ersten Gebrauch die richtige Initialisierung abgeschlossen ist.

Klasseninstanzen destructor (deinitializer) Speicher Aufräumarbeiten definiert werden kann, bevor Klasseninstanz freigegeben wird.

Die anfängliche Zuordnung des Speichertyp Eigenschaft

Klassen und Strukturen, wenn eine Instanz erstellt wird, muss es entsprechende Anfangswert für alle Speichertyp-Attribute gesetzt.

Bei der Lagerung Eigenschaftszuweisung im Konstruktor, werden ihre Werte direkt und löst keine Eigenschaft Beobachter.

Lagereigenschaftszuweisung Prozess im Konstruktor:

• Erstellen des Anfangswerts.

• In der Attributdefinition gibt die Standardeigenschaftswerte.

• Initialisiert eine Instanz und ruft die init () -Methode.

constructor

Der Konstruktor wird aufgerufen, wenn Sie eine neue Instanz eines bestimmten Typs erstellen. Die einfachste Form ist ähnlich einer Instanz-Methode ohne Parameter auf, das Schlüsselwort init name.

Grammatik

init()
{
    // 实例化后执行的代码
}

Beispiele

Die folgende Struktur definiert die init einen Konstruktor ohne Argumente, und im Inneren des Speichertyp Attribut Länge und Breite der Initialisierung Wert von 6 und 12:

struct rectangle {
    var length: Double
    var breadth: Double
    init() {
        length = 6
        breadth = 12
    }
}
var area = rectangle()
print("矩形面积为 \(area.length*area.breadth)")

Die obige Programmausführung Ausgabe ist:

矩形面积为 72.0

Standardeigenschaftswerte

Wir können die Anfangswerte für die Speichertyp Eigenschaft im Konstruktor festgelegt; auch kann einen Standardwert gesetzt, wenn eine Eigenschaft Erklärung.

Es ermöglicht Ihnen, den Standard-Konstruktor Cleaner verwenden, klarer und kann durch den Standardwert type-Attribut automatisch geschlossen.

Im folgenden Beispiel wollen wir den Standardwert gesetzt, wenn eine Eigenschaft Erklärung:

struct rectangle {
	// 设置默认值
    var length = 6
    var breadth = 12
}
var area = rectangle()
print("矩形的面积为 \(area.length*area.breadth)")

Die obige Programmausführung Ausgabe ist:

矩形面积为 72

Konfigurationsparameter

Sie können den Konstruktor definieren die init () Konstruktor Parameter zur Verfügung gestellt, wie folgt:

struct Rectangle {
    var length: Double
    var breadth: Double
    var area: Double
    
    init(fromLength length: Double, fromBreadth breadth: Double) {
        self.length = length
        self.breadth = breadth
        area = length * breadth
    }
    
    init(fromLeng leng: Double, fromBread bread: Double) {
        self.length = leng
        self.breadth = bread
        area = leng * bread
    }
}

let ar = Rectangle(fromLength: 6, fromBreadth: 12)
print("面积为: \(ar.area)")

let are = Rectangle(fromLeng: 36, fromBread: 12)
print("面积为: \(are.area)")

Die obige Programmausführung Ausgabe ist:

面积为: 72.0
面积为: 432.0

Interne und externe Parameternamen

Funktionen und Methoden mit den gleichen Parametern, Strukturparameter gibt es auch den Namen eines Parameters im Konstruktor für den internen Gebrauch und externen Parameternamen verwendet, wenn ein Konstruktor aufrufen.

Jedoch ist die Konfiguration nicht vor gibt es einen erkennbaren Namen in Klammern wie Funktionen und Methoden. Also den Konstruktor aufrufen, wird der Konstruktor in erster Linie bestimmt durch die Notwendigkeit, die Konstruktorparameter Namen und Typen zu nennen.

Wenn Sie keine Argumente angeben, wenn Sie den Konstruktor externen Namen definieren, wird Swift automatisch einen Namen mit dem gleichen externen internen Namen für jeden Parameter des Konstruktors erzeugen.

struct Color {
    let red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    init(white: Double) {
        red   = white
        green = white
        blue  = white
    }
}

// 创建一个新的Color实例，通过三种颜色的外部参数名来传值，并调用构造器
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)

print("red 值为: \(magenta.red)")
print("green 值为: \(magenta.green)")
print("blue 值为: \(magenta.blue)")

// 创建一个新的Color实例，通过三种颜色的外部参数名来传值，并调用构造器
let halfGray = Color(white: 0.5)
print("red 值为: \(halfGray.red)")
print("green 值为: \(halfGray.green)")
print("blue 值为: \(halfGray.blue)")

Die obige Programmausführung Ausgabe ist:

red 值为: 1.0
green 值为: 0.0
blue 值为: 1.0
red 值为: 0.5
green 值为: 0.5
blue 值为: 0.5

Kein externer Parameternamen

Wenn Sie keinen externen Namen für einen Konstruktor Parameter zur Verfügung stellen möchten, können Sie einen Unterstrich _ auf Grund des externen Anzeigenamen beschreiben.

struct Rectangle {
    var length: Double
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    //不提供外部名字
    init(_ area: Double) {
        length = area
    }
}

// 调用不提供外部名字
let rectarea = Rectangle(180.0)
print("面积为: \(rectarea.length)")

// 调用不提供外部名字
let rearea = Rectangle(370.0)
print("面积为: \(rearea.length)")

// 调用不提供外部名字
let recarea = Rectangle(110.0)
print("面积为: \(recarea.length)")

Die obige Programmausführung Ausgabe ist:

面积为: 180.0
面积为: 370.0
面积为: 110.0

Optionale Attribute Typ

Wenn Sie Ihre eigene Art ein logisches Argument enthält leere Speichertyp Attribute zu ermöglichen, müssen Sie es als optionales Typ optional Typ (optional Attributtyp) zu definieren.

Bei der Lagerung Eigenschaft Erklärung optional ist, wird es automatisch zu leeren Null initialisiert werden.

struct Rectangle {
    var length: Double?
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    
    init(_ area: Double) {
        length = area
    }
}

let rectarea = Rectangle(180.0)
print("面积为：\(rectarea.length)")

let rearea = Rectangle(370.0)
print("面积为：\(rearea.length)")

let recarea = Rectangle(110.0)
print("面积为：\(recarea.length)")

Die obige Programmausführung Ausgabe ist:

面积为：Optional(180.0)
面积为：Optional(370.0)
面积为：Optional(110.0)

Ändern Konstanteneigenschaft Bauprozess

Kurz vor dem Ende des Bauprozesses den Wert einer Konstante bestimmen können, können Sie den Wert der konstanten Attribute an einer beliebigen Stelle im Bauprozess ändern.

Für eine Instanz der Klasse, kann seine konstante Attribut nur in seiner Klasse Bauprozess Modifikationen definiert werden, können nicht in einer Unterklasse geändert werden.

Trotz der Länge Eigenschaft ist nun eine Konstante, die wir immer noch seinen Wert im Konstruktor seiner Klasse:

struct Rectangle {
    let length: Double?
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    
    init(_ area: Double) {
        length = area
    }
}

let rectarea = Rectangle(180.0)
print("面积为：\(rectarea.length)")

let rearea = Rectangle(370.0)
print("面积为：\(rearea.length)")

let recarea = Rectangle(110.0)
print("面积为：\(recarea.length)")

Die obige Programmausführung Ausgabe ist:

面积为：Optional(180.0)
面积为：Optional(370.0)
面积为：Optional(110.0)

Der Default-Konstruktor

Der Standardkonstruktor wird einfach alle die Eigenschaftswerte erstellen, werden auf die Standardinstanz gesetzt:

Die folgenden Beispiele, die alle Eigenschaften ShoppingListItem Klasse einen Standardwert hat, und es ist nicht der Vater der Basisklasse, wird sie erhalten automatisch eine Standardwerte für alle Eigenschaften des Standard-Konstruktor festlegen

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()


print("名字为: \(item.name)")
print("数理为: \(item.quantity)")
print("是否付款: \(item.purchased)")

Die obige Programmausführung Ausgabe ist:

名字为: nil
数理为: 1
是否付款: false

Jedes Mitglied der Konstruktor Struktur

Wenn die Struktur aller Speichertyp-Eigenschaften Standardwerte liefern und nicht ihre eigenen Customizer bieten, bekommen sie automatisch jedes Mitglied eines Konstruktor.

Wenn wir an jedes Mitglied des Konstruktor aufrufen, von traditionellen Werten durchführen und die Mitglieder des gleichen Namens Namensattribut Parameter die anfängliche Zuordnung der Elementeigenschaften zu vervollständigen.

Das folgende Beispiel definiert eine Struktur Rechteck, das zwei Attribute Länge und Breite enthält. Swift kann nach der anfänglichen 100,0 dieser beiden Eigenschaften zugeordnet werden, 200,0 ableiten automatisch ihre Zwei.

struct Rectangle {
    var length = 100.0, breadth = 200.0
}
let area = Rectangle(length: 24.0, breadth: 32.0)

print("矩形的面积: \(area.length)")
print("矩形的面积: \(area.breadth)")

Da die beiden Speichereigenschaften haben Standardwerte, Strukturen Rechteck automatisch ein Mitglied jeder Konstruktor init (Breite: Höhe :). Sie können es verwenden, um eine neue Instanz von Rechteck zu erstellen.

Die obige Programmausführung Ausgabe ist:

名字为: nil
矩形的面积: 24.0
矩形的面积: 32.0

Werttyp Konstruktor-Agent

Constructor durch den Aufruf von anderen Konstrukteuren Teil des Bauprozesses Instanz abzuschließen. Dieser Vorgang wird als Strukturmittel genannt, kann es Code-Duplizierung zwischen mehreren Konstrukteuren reduzieren.

Die folgenden Beispiele, Rect-Struktur bezeichnet Bauprozess und die Punktgröße:

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()
    init() {}
    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}


// origin和size属性都使用定义时的默认值Point(x: 0.0, y: 0.0)和Size(width: 0.0, height: 0.0)：
let basicRect = Rect()
print("Size 结构体初始值: \(basicRect.size.width, basicRect.size.height) ")
print("Rect 结构体初始值: \(basicRect.origin.x, basicRect.origin.y) ")

// 将origin和size的参数值赋给对应的存储型属性
let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
    size: Size(width: 5.0, height: 5.0))

print("Size 结构体初始值: \(originRect.size.width, originRect.size.height) ")
print("Rect 结构体初始值: \(originRect.origin.x, originRect.origin.y) ")


//先通过center和size的值计算出origin的坐标。
//然后再调用（或代理给）init(origin:size:)构造器来将新的origin和size值赋值到对应的属性中
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
    size: Size(width: 3.0, height: 3.0))

print("Size 结构体初始值: \(centerRect.size.width, centerRect.size.height) ")
print("Rect 结构体初始值: \(centerRect.origin.x, centerRect.origin.y) ")

Die obige Programmausführung Ausgabe ist:

Size 结构体初始值: (0.0, 0.0) 
Rect 结构体初始值: (0.0, 0.0) 
Size 结构体初始值: (5.0, 5.0) 
Rect 结构体初始值: (2.0, 2.0) 
Size 结构体初始值: (3.0, 3.0) 
Rect 结构体初始值: (2.5, 2.5) 

Constructor Proxy-Regeln

Vererbung und Bauprozess der Klasse

Swift bietet zwei Arten von Klasse Konstruktor, um sicherzustellen, dass alle Instanzen der Klasse-Speichereigenschaften können in den Anfangswerten erhalten werden, was dem Konstrukteur und Convenience-Konstruktor angegeben werden.

Init(parameters) {
    statements
}

convenience init(parameters) {
      statements
}

Gibt die Instanz-Konstruktor

class mainClass {
    var no1 : Int // 局部存储变量
    init(no1 : Int) {
        self.no1 = no1 // 初始化
    }
}
class subClass : mainClass {
    var no2 : Int // 新的子类存储变量
    init(no1 : Int, no2 : Int) {
        self.no2 = no2 // 初始化
        super.init(no1:no1) // 初始化超类
    }
}

let res = mainClass(no1: 10)
let res2 = subClass(no1: 10, no2: 20)

print("res 为: \(res.no1)")
print("res2 为: \(res2.no1)")
print("res2 为: \(res2.no2)")

Die obige Programmausführung Ausgabe ist:

res 为: 10
res 为: 10
res 为: 20

Beispiele für Convenience-Konstruktor

class mainClass {
    var no1 : Int // 局部存储变量
    init(no1 : Int) {
        self.no1 = no1 // 初始化
    }
}

class subClass : mainClass {
    var no2 : Int
    init(no1 : Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    // 便利方法只需要一个参数
    override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}
let res = mainClass(no1: 20)
let res2 = subClass(no1: 30, no2: 50)

print("res 为: \(res.no1)")
print("res2 为: \(res2.no1)")
print("res2 为: \(res2.no2)")

Die obige Programmausführung Ausgabe ist:

res 为: 20
res2 为: 30
res2 为: 50

Vererbung und Konstruktor Überlastung

Swift Unterklasse erbt nicht den Standard-Konstruktor der übergeordneten Klasse.

Der Konstruktor der übergeordneten Klasse wird nur in dem Fall, Bestimmung und Sicherheit geerbt.

Wenn Sie eine übergeordnete Klasse angegeben Konstruktor überschreiben, müssen Sie eine Überschreibung Modifikator zu schreiben.

class SuperClass {
    var corners = 4
    var description: String {
        return "\(corners) 边"
    }
}
let rectangle = SuperClass()
print("矩形: \(rectangle.description)")

class SubClass: SuperClass {
    override init() {  //重载构造器
        super.init()
        corners = 5
    }
}

let subClass = SubClass()
print("五角型: \(subClass.description)")

Die obige Programmausführung Ausgabe ist:

矩形: 4 边
五角型: 5 边

Gibt die Konstruktor und Bequemlichkeit Konstrukteurs Beispiele

Im folgenden Beispiel wird der Betrieb in den Konstruktor, Konstrukteure angegeben demonstrieren und automatische Konstruktor Vererbung erleichtern.

Es enthält zwei Klassen definiert Mainclass, SubClass Klassenhierarchie, und zeigen, wie ihre Konstrukteure Interaktion.

class MainClass {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    convenience init() {
        self.init(name: "[匿名]")
    }
}
let main = MainClass(name: "w3big")
print("MainClass 名字为: \(main.name)")

let main2 = MainClass()
print("没有对应名字: \(main2.name)")

class SubClass: MainClass {
    var count: Int
    init(name: String, count: Int) {
        self.count = count
        super.init(name: name)
    }
    
    override convenience init(name: String) {
        self.init(name: name, count: 1)
    }
}

let sub = SubClass(name: "w3big")
print("MainClass 名字为: \(sub.name)")

let sub2 = SubClass(name: "w3big", count: 3)
print("count 变量: \(sub2.count)")

Die obige Programmausführung Ausgabe ist:

MainClass 名字为: w3big
没有对应名字: [匿名]
MainClass 名字为: w3big
count 变量: 3

Der Klassenkonstruktor kann fehlschlagen

Wenn eine Klasse, Objekt, eine Struktur oder Aufzählungstyp ist es möglich, sich zu strukturieren, in der Vorgang fehlschlägt, wird das Fehlen einer Konstruktor definieren.

Variable Initialisierung fehlgeschlagen Mögliche Gründe sind:

• Ankommende Falscher Parameterwert.

• Fehlende einige externe Ressourcen erforderlich.

• Es entsprach nicht bestimmte Bedingungen erfüllen.

Um auf den Fall dieser Konfigurationsprozess umgehen kann fehlschlagen.

Sie können in einer Klasse oder Aufzählungstyp Definition der Struktur, fügen Sie ein oder mehrere ausgefallen Konstruktor. Die Syntax ist ein Fragezeichen nach der init Schlüsselwort Jiatian (init?).

Beispiele

Im folgenden Beispiel wird die Definition einer Struktur namens Tier, das die Spezies genannt hat, Attribut Typ String-Konstanten.

Inzwischen definiert die Struktur auch eine mit einem String-Typ-Parameter Art kann Konstruktor fehlschlagen. Der Konstruktor kann fehlschlagen, wird verwendet, um zu überprüfen, ob das Argument auf einen leeren String, einen leeren String übergeben, kann der Konstruktor fehlschlagen, das Scheitern, ein Objekt zu bauen, sonst Erfolg.

struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

//通过该可失败构造器来构建一个Animal的对象，并检查其构建过程是否成功
// someCreature 的类型是 Animal? 而不是 Animal
let someCreature = Animal(species: "长颈鹿")

// 打印 "动物初始化为长颈鹿"
if let giraffe = someCreature {
    print("动物初始化为\(giraffe.species)")
}

Die obige Programmausführung Ausgabe ist:

动物初始化为长颈鹿

Aufzählungstyp Konstruktor kann fehlschlagen

Sie können mit einem oder mehreren Parametern können vom Konstrukteur so konfiguriert werden, scheiterte ein Aufzählungstyp spezifische Enumerationsmember zu bekommen.

Beispiele

Im folgenden Beispiel ist die Definition eines Aufzählungstyp namens TemperatureUnit. Welche enthält drei mögliche Enum Element (Kelvin, Celsius und Fahrenheit) und ein Fehler verwendet werden kann, die Konstruktor Zeichenwerte entsprechenden Enumerationsmember zu finden:

enum TemperatureUnit {
	// 开尔文，摄氏，华氏
    case Kelvin, Celsius, Fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .Kelvin
        case "C":
            self = .Celsius
        case "F":
            self = .Fahrenheit
        default:
            return nil
        }
    }
}


let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
    print("这是一个已定义的温度单位，所以初始化成功。")
}

let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit == nil {
    print("这不是一个已定义的温度单位，所以初始化失败。")
}

Die obige Programmausführung Ausgabe ist:

这是一个已定义的温度单位，所以初始化成功。
这不是一个已定义的温度单位，所以初始化失败。

Der Klassenkonstruktor kann fehlschlagen

Werttypen (wie Strukturen oder Aufzählungstyp) können Konstruktor fehlschlagen, wann und wo der Bau ohne Einschränkung dieses Verhalten fehl auslösen.

Allerdings kann die Klasse Konstruktor fehlschlagen und der Agent der Konstruktor unter allen Klassen nur nennen kann in allen Klasseneigenschaften aufgetreten sind nach der Zündung Ausfallverhalten initialisiert.

Beispiele

Durch beispielsweise die Definition einer Klasse namens StudRecord weil Gestüts Eigenschaft ist eine Konstante, so einmal StudRecord Klassenkonstruktors Erfolg muss Gestüts Eigenschaft einen Nicht-Null-Wert haben.

class StudRecord {
    let studname: String!
    init?(studname: String) {
        self.studname = studname
        if studname.isEmpty { return nil }
    }
}
if let stname = StudRecord(studname: "失败构造器") {
    print("模块为 \(stname.studname)")
}

Die obige Programmausführung Ausgabe ist:

模块为 失败构造器

kann einen Konstruktor Abdeckung scheitern

Wie andere Konstrukteure, wie, können Sie auch die Basisklasse außer Kraft setzen Konstruktor kann mit der Unterklasse Konstruktor nicht fehlschlagen kann.

Sie können auch durch eine Basisklassenkonstruktor außer Kraft setzen kann mit dem Ausfall von Nicht-Konstruktor Unterklasse scheitern.

Sie können einen nicht ausgefallenen Konstruktor einen Konstruktor Abdeckung kann scheitern, aber wiederum ist es nicht funktioniert.

Ein nicht-failed Konstruktor kann nie einen Agenten rufen kann Konstruktor fehlschlagen.

Beispiele

Das folgende Beispiel beschreibt einen Ausfall und Nicht-Ausfall Constructor:

class Planet {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    convenience init() {
        self.init(name: "[No Planets]")
    }
}
let plName = Planet(name: "Mercury")
print("行星的名字是: \(plName.name)")

let noplName = Planet()
print("没有这个名字的行星: \(noplName.name)")

class planets: Planet {
    var count: Int
    
    init(name: String, count: Int) {
        self.count = count
        super.init(name: name)
    }
    
    override convenience init(name: String) {
        self.init(name: name, count: 1)
    }
}

Die obige Programmausführung Ausgabe ist:

行星的名字是: Mercury
没有这个名字的行星: [No Planets]

Kann nicht Konstruktor init!

Im Allgemeinen, fügen wir ein Fragezeichen hinter dem Schlüsselwort init Weg (init?) Fehlschlagen kann einen Konstruktor zu definieren, aber Sie können auch die init verwenden, indem ein Ausrufezeichen nach dem Weg Hinzufügen eines ausgefallenen Konstruktor zu definieren (init!) . Beispiele sind wie folgt:

struct StudRecord {
    let stname: String
    
    init!(stname: String) {
        if stname.isEmpty {return nil }
        self.stname = stname
    }
}

let stmark = StudRecord(stname: "w3big")
if let name = stmark {
    print("指定了学生名")
}

let blankname = StudRecord(stname: "")
if blankname == nil {
    print("学生名为空")
}

Die obige Programmausführung Ausgabe ist:

指定了学生名
学生名为空