类
在 Swift 中类是建立灵活的构建块。类似于常量，变量和函数，用户可以定义的类的属性和方法。Swift给我们提供了声明类，而无需用户创建接口和实现文件的功能。Swift 允许我们创建类作为单个文件和外部接口，将默认在类一次初始化来创建。
使用类的好处：
- 继承获得一个类的属性到其他类
- 类型转换使用户能够在运行时检查类的类型
- 初始化器需要处理释放内存资源
- 引用计数允许类实例有一个以上的参考
类和结构的共同特征：
- 属性被定义为存储值
- 下标被定义为提供访问值
- 方法被初始化来改善功能
- 初始状态是由初始化函数定义
- 功能被扩大，超出默认值
- 确认协议功能标准
语法
Class classname {
Definition 1
Definition 2
---
Definition N
}
定义类
class student{
var studname: String
var mark: Int
var mark2: Int
}
创建一个实例的语法：
let studrecord = student()
示例
class MarksStruct {
var mark: Int
init(mark: Int) {
self.mark = mark
}
}
class studentMarks {
var mark = 300
}
let marks = studentMarks()
println("Mark is \(marks.mark)")
当我们使用 playground 运行上面的程序，我们得到以下结果
|
1
|
Mark is 300 |
访问类属性作为引用类型
类属性可使用 '.' 语法来访问。属性名称由 "." 分离在实例名后。
class MarksStruct {
var mark: Int
init(mark: Int) {
self.mark = mark
}
}
class studentMarks {
var mark1 = 300
var mark2 = 400
var mark3 = 900
}
let marks = studentMarks()
println("Mark1 is \(marks.mark1)")
println("Mark2 is \(marks.mark2)")
println("Mark3 is \(marks.mark3)")
当我们使用 playground 运行上面的程序，得到以下结果
|
1
2
3
|
Mark1 is 300Mark2 is 400Mark3 is 900 |
类标识符
在 Swift 引用多个常量和变量指向的单个实例。要了解常量和变量指向一个特定的类实例标识操作符的使用。 类实例总是通过引用传递。在类NSString，NSArray 和 NSDictionary 实例始终分配作为参考传递到现有的实例，而不是使用一个副本。
class SampleClass: Equatable {
let myProperty: String
init(s: String) {
myProperty = s
}
}
func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {
return lhs.myProperty == rhs.myProperty
}
let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")
spClass1 === spClass2 // false
println("\(spClass1)")
spClass1 !== spClass2 // true
println("\(spClass2)")
当我们使用 playground 运行上面的程序，得到以下结果
|
1
2
|
main.SampleClassmain.SampleClass |
结构体
Swift 提供了利用构造作为结构的灵活的构建块。 通过利用这些结构的一次可以定义构建体的方法和属性。
这不同于 C 和 Objective C 编程：
结构不用要求实现文件和接口。
结构体使我们能够创建一个文件并自动扩展其接口到其它块。
在结构体中的变量值被复制并传递在后续的代码，通过返回的旧值的副本使得这些值不能被改变。
语法
Structures are defined with a 'Struct' Keyword.
struct nameStruct {
Definition 1
Definition 2
---
Definition N
}
结构体的定义
考虑例如，假设要访问包含三个科目记录标记的学生并找出三个科目的总和。在这里，markStruct用于初始化的结构有三个标记，数据类型为 'Int'。
struct MarkStruct{
var mark1: Int
var mark2: Int
var mark3: Int
}
访问结构体及属性
结构的成员是由它的结构名访问。 结构体的实例中由 'let' 关键字进行初始化。
struct studentMarks {
var mark1 = 100
var mark2 = 200
var mark3 = 300
}
let marks = studentMarks()
println("Mark1 is \(marks.mark1)")
println("Mark2 is \(marks.mark2)")
println("Mark3 is \(marks.mark3)")
当我们使用 playground 运行上面的程序，得到以下结果：
|
1
2
3
|
Mark1 is 100Mark2 is 200Mark3 is 300 |
学生成绩需要访问结构名“studentMarks”。结构成员被初始化为 mark1, mark2, mark3 的整数类型值。然后，结构体 studentMarks()传递给 'marks' 使用 'let' 关键字。 'marks' 将包含结构成员的值。现在通过 '.' 访问结构的初始名称的值，并打印它。
struct MarksStruct {
var mark: Int
init(mark: Int) {
self.mark = mark
}
}
var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct // aStruct and bStruct are two structs with the same value!
bStruct.mark = 97
println(aStruct.mark) // 98
println(bStruct.mark) // 97
当我们使用 playground 运行上面的程序，得到以下结果：
|
1
2
|
9897 |
结构体最佳使用方式
Swift 语言提供功能来定义的结构体作为自定义数据类型，用于构建功能块。 结构体的实例的值传递给定义块来进一步的操作。
需要有结构：
封装简单的数据值
使用“值”而不是“引用”复制封装数据到它的相关联属性
结构体为 “复制” 和 “引用”
在 swift 中结构体是通过其成员的值，而不是它的引用。
struct markStruct{
var mark1: Int
var mark2: Int
var mark3: Int
init(mark1: Int, mark2: Int, mark3: Int){
self.mark1 = mark1
self.mark2 = mark2
self.mark3 = mark3
}
}
var marks = markStruct(mark1: 98, mark2: 96, mark3:100)
println(marks.mark1)
println(marks.mark2)
println(marks.mark3)
当我们使用 playground 运行上面的程序，得到以下结果：
|
1
2
3
|
9896100 |
另外一个实例
struct markStruct{
var mark1: Int
var mark2: Int
var mark3: Int
init(mark1: Int, mark2: Int, mark3: Int){
self.mark1 = mark1
self.mark2 = mark2
self.mark3 = mark3
}
}
var fail = markStruct(mark1: 34, mark2: 42, mark3: 13)
println(fail.mark1)
println(fail.mark2)
println(fail.mark3)
当我们使用 playground 运行上面的程序，得到以下结果：
|
1
2
3
|
344213 |
结构体 “markStruct” 需要它的成员首先定义：mark1, mark2 和 mark3. 现在，成员类的变量初始化容纳整数值。之后结构成员的副本使用 “self” 关键字创建。当结构成员的副本创建结构体块，其参数标记传递给 'marks' 变量，它现在将保存学生的分数。那么标记打印为 98, 96, 100。 下一步对于相同的结构成员的另一个实例命名为 'fail' 用于指向不同的标记相同结构体的成员。那么标记现在打印为 34, 42, 13. 这清楚地说明了结构会有成员变量的副本，传入成员到它们即将推出的功能块。
