Swift - 初始化

Swift - 初始化 首页 / Swift入门教程 / Swift - 初始化

创建初始化函数的关键字通过'init()'方法执行， Swift 4初始化程序与Objective-C的不同之处在于它不返回任何值。它的函数是在处理之前检查新创建的初始化。一旦被释放，Swift 4还提供了"deinitialization"过程来执行内存管理操作。

初始化存储属性

存储的属性(Stored Properties)必须在处理之前为其类和结构初始化，存储的属性使用初始化程序来分配和初始化值，从而消除了调用属性观察器的需要。初始化程序用于存储的属性

  • 创建初始值。

  • 要在属性定义中分配默认属性值。

  • 要初始化特定数据类型的，请使用" init()"。

init() {
   //新实例初始化在这里
}

初始化存储示例

struct rectangle {
   var length: Double
   var breadth: Double
   init() {
      length=6
      breadth=12
   }
}

var area=rectangle()
print("area of rectangle is\(area.length*area.breadth)")

运行上述程序时，我们得到以下输出-

area of rectangle is 72.0

在这里，结构"rectangle"使用成员的长度length和宽度breadth初始化为"Double"数据类型， Init()方法用于初始化新创建的成员length和double的值。

设置默认值

Swift 4语言提供了Init()函数来初始化存储的属性值，同样，用户可以在声明类或结构成员时默认情况下初始化属性值，当属性在整个程序中单独具有相同的值时，我们可以在声明部分中单独声明它，而不是在init()中对其进行初始化。

struct rectangle {
   var length=6
   var breadth=12
}

var area=rectangle()
print("area of rectangle is\(area.length*area.breadth)")

运行上述程序时，我们得到以下输出-

area of rectangle is 72

在这里，不是在init()中声明长度和宽度，而是在声明本身中初始化值。

参数初始化

在Swift 4语言中，用户可以使用init()初始化参数，作为初始化程序定义的一部分。

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("area is:\(ar.area)")

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

运行上述程序时，我们得到以下输出-

area is: 72.0
area is: 432.0

本地和外部参数

初始化参数具有与函数和方法参数相似的局部和全局参数名称，局部参数声明用于在初始化主体内进行访问，而外部参数声明用于调用初始化程序。

struct Days {
   let sunday, monday, tuesday: Int
   init(sunday: Int, monday: Int, tuesday: Int) {
      self.sunday=sunday
      self.monday=monday
      self.tuesday=tuesday
   }
   init(daysofaweek: Int) {
      sunday=daysofaweek
      monday=daysofaweek
      tuesday=daysofaweek
   }
}

let week=Days(sunday: 1, monday: 2, tuesday: 3)
print("Days of a Week is:\(week.sunday)")
print("Days of a Week is:\(week.monday)")
print("Days of a Week is:\(week.tuesday)")

let weekdays=Days(daysofaweek: 4)
print("Days of a Week is:\(weekdays.sunday)")
print("Days of a Week is:\(weekdays.monday)")
print("Days of a Week is:\(weekdays.tuesday)")

运行上述程序时，我们得到以下输出-

Days of a Week is: 1
Days of a Week is: 2
Days of a Week is: 3
Days of a Week is: 4
Days of a Week is: 4
Days of a Week is: 4

没有外部参数

当不需要外部名称进行初始化时，下划线" _"用于覆盖默认行为。

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("area is:\(rectarea.length)")

let rearea=Rectangle(370.0)
print("area is:\(rearea.length)")

let recarea=Rectangle(110.0)
print("area is:\(recarea.length)")

运行上述程序时，我们得到以下输出-

area is: 180.0
area is: 370.0
area is: 110.0

可选属性类型

当存储的属性在某些情况下不返回任何值时，将使用"Optional"类型声明该属性，指示该特定类型返回"no value"，当将存储的属性声明为"optional"时，它将在初始化过程中自动将值初始化为" nil"。

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("area is:\(rectarea.length)")

let rearea=Rectangle(370.0)
print("area is:\(rearea.length)")

let recarea=Rectangle(110.0)
print("area is:\(recarea.length)")

运行上述程序时，我们得到以下输出-

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

修改常量属性

初始化还允许用户修改常量属性的值，在初始化期间，类属性允许其类由超类而不是子类进行修改。如在上一个程序中，考虑在主类中将" length"声明为" variable"。下面的程序变量" length"被修改为" constant"变量。

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("area is:\(rectarea.length)")

let rearea=Rectangle(370.0)
print("area is:\(rearea.length)")

let recarea=Rectangle(110.0)
print("area is:\(recarea.length)")

运行上述程序时，我们得到以下输出-

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

默认初始化

默认初始化器为其具有默认值的基类或结构的所有声明属性提供一个新。

class defaultexample {
   var studname: String?
   var stmark=98
   var pass=true
}
var result=defaultexample()

print("result is:\(result.studname)")
print("result is:\(result.stmark)")
print("result is:\(result.pass)")

运行以上程序时，我们得到以下输出。 -

无涯教程网

result is: nil
result is: 98
result is: true

上面的程序以类名" defaultexample"定义，默认情况下，三个成员函数被初始化为" studname?"。存储" nil"值，" stmark"为98，" pass"为布尔值" true"。同样，可以在处理类成员类型之前将类中的成员值初始化为默认值。

结构类型初始化

当用户不提供自定义初始化程序时，Swift 4中的Structure类型将自动接收"memberwise initializer"。它的主要函数是使用默认的成员级初始化来初始化新结构，然后将新属性按名称传递给成员级初始化。

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

print("Area of rectangle is:\(area.length)")
print("Area of rectangle is:\(area.breadth)")

运行上述程序时，我们得到以下输出-

Area of rectangle is: 24.0
Area of rectangle is: 32.0

默认情况下，在初始化"length"为" 100.0"和"breadth"为" 200.0"时，将为其成员函数初始化结构。但是在处理变量长度和宽度为24.0和32.0时会覆盖这些值。

值类型初始化

初始化程序委托定义为从其他初始化程序调用初始化程序，它的主要函数是充当可重用性，以避免跨多个初始化程序重复代码。

struct Stmark {
   var mark1=0.0, mark2=0.0
}
struct stdb {
   var m1=0.0, m2=0.0
}

struct block {
   var average=stdb()
   var result=Stmark()
   init() {}
   init(average: stdb, result: Stmark) {
      self.average=average
      self.result=result
   }

   init(avg: stdb, result: Stmark) {
      let tot=avg.m1 - (result.mark1/2)
      let tot1=avg.m2 - (result.mark2/2)
      self.init(average: stdb(m1: tot, m2: tot1), result: result)
   }
}

let set1=block()
print("student result is:\(set1.average.m1, set1.average.m2)
\(set1.result.mark1, set1.result.mark2)")

let set2=block(average: stdb(m1: 2.0, m2: 2.0),
result: Stmark(mark1: 5.0, mark2: 5.0))
print("student result is:\(set2.average.m1, set2.average.m2)
\(set2.result.mark1, set2.result.mark2)")

let set3=block(avg: stdb(m1: 4.0, m2: 4.0),
result: Stmark(mark1: 3.0, mark2: 3.0))
print("student result is:\(set3.average.m1, set3.average.m2)
\(set3.result.mark1, set3.result.mark2)")

运行上述程序时，我们得到以下输出-

(0.0,0.0) (0.0,0.0)
(2.0,2.0) 5.0,5.0)
(2.5,2.5) (3.0,3.0)

类继承和初始化

指定初始化程序
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 print=subClass(no1: 10, no2: 20)

print("res is:\(res.no1)")
print("res is:\(print.no1)")
print("res is:\(print.no2)")

运行上述程序时，我们得到以下输出-

res is: 10
res is: 10
res is: 20

初始化程序

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 print=subClass(no1: 30, no2: 50)

print("res is:\(res.no1)")
print("res is:\(print.no1)")
print("res is:\(print.no2)")

运行上述程序时，我们得到以下输出-

res is: 20
res is: 30
res is: 50

初始化继承和覆盖

Swift 4默认情况下不允许其子类为其成员类型继承其超类初始化器。

当用户需要在超类中定义初始化器时，用户必须将带有初始化器的子类定义为自定义实现。必须声明" override"关键字。

class sides {
   var corners=4
   var description: String {
      return "\(corners) sides"
   }
}

let rectangle=sides()
print("Rectangle:\(rectangle.description)")

class pentagon: sides {
   override init() {
      super.init()
      corners=5
   }
}

let bicycle=pentagon()
print("Pentagon:\(bicycle.description)")

运行上述程序时，我们得到以下输出-

Rectangle: 4 sides
Pentagon: 5 sides

继承和覆盖

class Planet {
   var name: String
   init(name: String) {
      self.name=name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}

let plName=Planet(name: "Mercury")
print("Planet name is:\(plName.name)")

let noplName=Planet()
print("No Planets like that:\(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)
   }
}

运行上述程序时，我们得到以下输出-

Planet name is: Mercury
No Planets like that: [No Planets]

初始化失败

定义类，结构或枚举值时，如果初始化程序失败，则必须通知用户。

struct studrecord {
   let stname: String
   init?(stname: String) {
      if stname.isEmpty {return nil }
      self.stname=stname
   }
}
let stmark=studrecord(stname: "Swing")

if let name=stmark {
   print("Student name is specified")
}
let blankname=studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

运行上述程序时，我们得到以下输出-

Student name is specified
Student name is left blank

初始化枚举失败

Swift 4语言提供了灵活的函数，使枚举具有失败的初始化器，也可以在初始化值离开枚举方法时通知用户。

enum functions {
   case a, b, c, d
   init?(funct: String) {
      switch funct {
      case "one":
         self=.a
      case "two":
         self=.b
      case "three":
         self=.c
      case "four":
         self=.d
      default:
         return nil
      }
   }
}
let result=functions(funct: "two")

if result != nil {
   print("With In Block Two")
}
let badresult=functions(funct: "five")

if badresult == nil {
   print("Block Does Not Exist")
}

运行上述程序时，我们得到以下输出-

With In Block Two
Block Does Not Exist

初始化类失败

当用枚举和结构声明一个失败的初始化器时，它会在实现中的任何情况下警告初始化失败。但是，只有在将存储的属性设置为初始值之后，类中的可失败初始化器才会警告失败。

链接：https://www.learnfk.comhttps://www.learnfk.com/swift/swift-initialization.html

来源：LearnFk无涯教程网

class studrecord {
   let studname: String!
   init?(studname: String) {
      self.studname=studname
      if studname.isEmpty { return nil }
   }
}

if let stname=studrecord(studname: "初始化失败") {
   print("Module is\(stname.studname)")
}

运行上述程序时，我们得到以下输出-

Module is Optional("初始化失败")

初始化覆盖失败

像初始化一样，用户也可以在子类中重写超类失败的初始化，超类可失败的初始化也可以在子类不可失败的初始化中被覆盖。

class Planet {
   var name: String
   
   init(name: String) {
      self.name=name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}
let plName=Planet(name: "Mercury")
print("Planet name is:\(plName.name)")

let noplName=Planet()
print("No Planets like that:\(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)
   }
}

运行上述程序时，我们得到以下输出-

Planet name is: Mercury
No Planets like that: [No Planets]

初始化init!失败

Swift 4提供了" init?"定义可选失败的初始化程序。

struct studrecord {
let stname: String

   init!(stname: String) {
      if stname.isEmpty {return nil }
      self.stname=stname
   }
}
let stmark=studrecord(stname: "Swing")

if let name=stmark {
   print("Student name is specified")
}

let blankname=studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

运行上述程序时，我们得到以下输出-

Student name is specified
Student name is left blank

要声明initialize'required'关键字的每个子类，都需要在init()函数之前定义。

class classA {
   required init() {
      var a=10
      print(a)
   }
}

class classB: classA {
   required init() {
      var b=30
      print(b)
   }
}

let res=classA()
let print=classB()

运行上述程序时，我们得到以下输出-

10
30
10

祝学习愉快！(内容编辑有误？请选中要编辑内容 -> 右键 -> 修改 -> 提交！)

技术教程推荐

玩转webpack -〔程柳锋〕

即时消息技术剖析与实战 -〔袁武林〕

苏杰的产品创新课 -〔苏杰〕

移动端自动化测试实战 -〔思寒〕

SRE实战手册 -〔赵成〕

手把手教你玩音乐 -〔邓柯〕

程序员的个人财富课 -〔王喆〕

攻克视频技术 -〔李江〕

Midjourney入门实践课 -〔Jovi〕

好记忆不如烂笔头。留下您的足迹吧 :)
休闲君评测 |  TOOLFK工具网 |  chrome插件网 |  古诗文网 |  良许Linux教程网 |  Python之禅 |  红色石头 |  豪评测 |  入党申请书 | 

© 2020 Hi LearnFk 意见反馈 免责声明 关于我们 桂ICP备11002319号-3 友链&广告位+QQ: 1963612630