原创文章，欢迎转载。转载请注明：关东升的博客 继承会发生在子类和父类之间，是一系列类的继承关系。例如：Person是类层次结构中的根类，Student是Person的直接子类，Worker是Person的直接子类。这个继承关系类的具体实现代码如下：class Person { var name: String var age: Int func description() -> String { return "\(name) 年龄是: \(age)" } convenience init () { self.init(name: "Tony") self.age = 18 } convenience init (name: String) { self.init(name: name, age: 18) } init (name: String, age: Int) { self.name = name self.age = age } } class Student: Person { ...继续阅读 (55)

原创文章，欢迎转载。转载请注明：关东升的博客  在类的定义中使用final关键字声明类、属性、方法和下标。final声明的类不能被继承，final声明的属性、方法和下标不能被重写。下面看一个示例：final class Person { //声明为final，说明它是不能被继承的 var name: String final var age: Int //定义的age属性 final func description() -> String { //定义description实例方法 return "\(name) 年龄是: \(age)" } final class func printClass() ->() { //定义printClass静态方法 print( "Person 打印...") } init (name: String, age: Int) { self.name = name self.age = age } } class Student: Person { ...继续阅读 (70)

原创文章，欢迎转载。转载请注明：关东升的博客 下标是一种特殊属性。子类属性重写是重写属性的getter和setter访问器，对下标的重写也是重写下标的getter和setter访问器。下面看一个示例：class DoubleDimensionalArray { let rows: Int, columns: Int var grid: [Int] init(rows: Int, columns: Int) { self.rows = rows self.columns = columns grid = Array(count: rows * columns, repeatedValue: 0) } subscript(row: Int, col: Int) -> Int { //定义下标 get { return grid[(row * columns) + col] } set { grid[(row * columns) + col] = newValue } } //定义下标 ...继续阅读 (88)

原创文章，欢迎转载。转载请注明：关东升的博客  重写实例方法在子类中重写从父类继承来的实例方法和静态方法。先介绍实例方法的重写。下面看一个示例：class Person { var name: String var age: Int func description() -> String { //实例方法 return "\(name) 年龄是: \(age)" } class func printClass() ->() { //静态方法 print( "Person 打印...") } init (name: String, age: Int) { self.name = name self.age = age } } class Student: Person { var school: String convenience init() { self.init(name: "Tony", age: 18, school: "清华大学&quo ...继续阅读 (85)

原创文章，欢迎转载。转载请注明：关东升的博客重写实例属性我们可以在子类中重写从父类继承来的属性，属性有实例属性和静态属性之分，他们在具体实现也是不同的。实例属性的重写一方面可以重写getter和setter访问器，另一方面可以重写属性观察者。计算静态属性需要使用getter和setter访问器，而存储属性不需要。子类在继承父类后，也可以通过getter和setter访问器重写父类的存储属性和计算属性。下面看一个示例：class Person { var name: String //存储属性 var age: Int //存储属性 func description() -> String { return "\(name) 年龄是: \(age)" } init (name: String, age: Int) { self.name = name self.age = age } } class Student: Person { var school: String override var age: ...继续阅读 (70)

原创文章，欢迎转载。转载请注明：关东升的博客Swift中的子类构造函数的来源有两种：自己编写和从父类继承。并不是父类的所有的构造函数都能继承下来，能够从父类继承下来的构造函数是有条件的，如下所示。条件1：如果子类没有定义任何指定构造函数，它将自动继承所有父类的指定构造函数。条件2：如果子类提供了所有父类指定构造函数的实现，无论是通过条件1继承过来的，还是通过自己编写实现的，它都将自动继承所有父类的便利构造函数。下面看示例代码：class Person { var name: String var age: Int func description() -> String { return "\(name) 年龄是: \(age)" } convenience init () { self.init(name: "Tony") self.age = 18 } convenience init (name: String) { self.init(name: name, age: 18) } init (name: String, age: Int ...继续阅读 (67)

原创文章，欢迎转载。转载请注明：关东升的博客  在构造函数中可以使用构造函数代理帮助完成部分构造工作。类构造函数代理分为横向代理和向上代理，横向代理只能在发生在同一类内部，这种构造函数称为便利构造函数。向上代理发生在继承的情况下，在子类构造过程中，要先调用父类构造函数初始化父类的存储属性，这种构造函数称为指定构造函数。 构造函数调用规则Person和Student类示例： class Person { var name: String var age: Int func description() -> String { return "\(name) 年龄是: \(age)" } convenience init () { //便利构造函数 self.init(name: "Tony") self.age = 18 } convenience init (name: String) { //便利构造函数 self.init(name: name, age: 18) } init (name: String, age: I ...继续阅读 (105)

原创文章，欢迎转载。转载请注明：关东升的博客 Swift中的继承只能发生在类上，不能发生在枚举和结构体上。一个类可以继承另一个类的方法、属性、下标等特征，当一个类继承其他类时，继承类叫子类，被继承类叫父类（或超类）。子类继承父类后，可以重写父类的方法、属性、下标等特征。 为了了解继承性，看这样一个场景：一位面向对象的程序员小赵，在编程过程中需要描述和处理个人信息，于是他定义了类Person，如下所示：class Person { var name: String var age: Int func description() -> String { return "\(name) 年龄是: \(age)" } init () { name = "" age = 1 } }一周以后，小赵又遇到了新的需求，需要描述和处理学生信息，于是他又定义了一个新的类Student，如下所示：class Student { var name: String var age: Int var school: String func descriptio ...继续阅读 (85)

原创文章，欢迎转载。转载请注明：关东升的博客与构造过程相反，实例最后释放的时候，需要清除一些资源，这个过程就是析构过程。在析构过程中也会调用一种特殊的方法deinit，称为析构函数。析构函数deinit没有返回值，也没有参数，也不需要参数的小括号，所以不能重载。 下面看看示例代码：class Rectangle { var width: Double var height: Double init(width: Double, height: Double) { self.width = width self.height = height } init(W width: Double,H height: Double) { self.width = width self.height = height } deinit { //定义了析构函数 print("调用析构函数...") self.width = 0.0 self.height = 0.0 ...继续阅读 (88)

原创文章，欢迎转载。转载请注明：关东升的博客 构造函数作为一种特殊方法，也可以重载。Swift中构造函数可以多个，他们参数列表和返回值可以不同，这些构造函数构成重载。示例代码如下：class Rectangle { var width: Double var height: Double init(width: Double, height: Double) { self.width = width self.height = height } init(W width: Double,H height: Double) { self.width = width self.height = height } init(length: Double) { self.width = length self.height = length } init() { self.width = 640.0 self.height = 940.0 } ...继续阅读 (67)

原创文章，欢迎转载。转载请注明：关东升的博客 构造函数的主要作用是初始化实例，其中包括：初始化存储属性和其它的初始化。在Rectangle类或结构体中，如果在构造函数中初始化存储属性width和height后，那么在定义他们时就不需要初始化了。Rectangle类代码如下：class Rectangle { var width: Double var height: Double init() { width = 0.0 height = 0.0 } }如果存储属性在构造函数中没有初始化，在定义的时候也没有初始化，那么就会发生编译错误。构造函数还可以初始化常量存储属性，下面我们看示例代码：class Employee { let no: Int //常量类型属性。曾讲过常量只能在定义的同时赋值，而在构造函数中，常量属性可以不遵守这个规则 var name: String? //存储属性一般在定义的时候初始化。如果不能确定初始值，可以采用可选类型属性 var job: String? //存储属性 var salary: Double var dept ...继续阅读 (53)

Swift 2.0学习笔记（Day 37）——默认构造函数原创文章，欢迎转载。转载请注明：关东升的博客结构体和类的实例在构造过程中会调用一种特殊的init方法，称为构造函数。构造函数没有返回值，可以重载。在多个构造函数重载的情况下，运行环境可以根据它的外部参数名或参数列表调用合适的构造函数。默认构造函数结构体和类在构造过程中会调用一个构造函数，即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数。下面看示例代码：class Rectangle { var width: Double = 0.0 var height: Double = 0.0 } var rect = Rectangle() //创建实例，并调用默认构造函数init() rect.width = 320.0 rect.height = 480.0 print("长方形:\(rect.width) x \(rect.height)") Rectangle()表示调用了某个方法，这个方法就是默认构造函数init()。 事实上，在Rectangle的定义过程中省略了构造函数，相当于如下代码： class Rectangle { var width: Double = 0.0 var height: Double = 0.0 ...继续阅读 (80)

原创文章，欢迎转载。转载请注明：关东升的博客静态方法与静态属性类似，Swift中定义了静态方法，也称为类型方法。静态方法的定义与静态属性类似，枚举和结构体的静态方法使用的关键字是static；类静态方法使用的关键字是class或static，如果使用static定义，则该方法不能在子类中被重写（override）；如果使用class定义，则该方法可以被子类重写。 结构体静态方法看一个结构体静态方法的示例，代码如下：struct Account { var owner: String = "Tony" //声明实例属性账户名 static var interestRate: Double = 0.0668 //声明静态属性利率 static func interestBy(amount: Double) -> Double {//定义静态方法 return interestRate * amount } func messageWith(amount: Double) -> String { //定义实例方法 let interest = Account.in ...继续阅读 (68)

原创文章，欢迎转载。转载请注明：关东升的博客看下面的示例代码是不是使用过：var studentList: String[] = ["张三","李四","王五"] studentList[0] = "诸葛亮" var studentDictionary = [102: "张三",105: "李四", 109: "王五"] studentDictionary[110] = "董六"在访问数组和字典的时候，可以采用下标访问。其中数组的下标是整数类型索引，字典的下标是它的“键”。 下标Swift中的下标相当于Java中的索引属性和C#中的索引器。下标访问的语法格式如下：面向对象类型 类型名 { 其他属性 ... subscript(参数: 参数数据类型) -> 返回值数据类型 { get { return 返回值 } set(新属性值) { ... } } }下标也有类似于计 ...继续阅读 (46)

原创文章，欢迎转载。转载请注明：关东升的博客我先来设计一个类：有一个Account（银行账户）类，假设它有3个属性：amount（账户金额）、interestRate（利率）和owner（账户名）。在这3个属性中，amount和owner会因人而异，不同的账户这些内容是不同的，而所有账户的interestRate都是相同的。amount和owner属性与账户个体有关，称为实例属性。interestRate属性与个体无关，或者说是所有账户个体共享的，这种属性称为静态属性或类型属性。面向对象类型（结构体、枚举和类）都可以定义静态属性，它们的语法格式分别如下所示：struct 结构体名 { //定义结构体, 结构体中可以定义静态存储属性和静态计算属性 static var(或let) 存储属性 = "xxx" ... static var 计算属性名: 属性数据类型 { get { return 计算后属性值 } set (新属性值) { ... } } } enum 枚举名 { //定义枚举，枚举中不可以定义实例存储属性，但可以定义静态存储属性，也可以定义静态计算属性 static var(或let ...继续阅读 (80)

原创文章，欢迎转载。转载请注明：关东升的博客 为了监听属性的变化，Swift提供了属性观察者。属性观察者能够监听存储属性的变化，即便变化前后的值相同，它们也能监听到。属性观察者主要有以下两个：willSet：观察者在修改之前调用。didSet：观察者在修改之后立刻调用。属性观察者的语法格式如下：面向对象类型 类型名 { ... var 存储属性: 属性数据类型 = 初始化值 { willSet(新值) { //定义willSet观察者。“新值”是传递给willSet观察者的参数，它保存了将要替换原来属性的新值 ... } didSet(旧值) { //定义didSet观察者。“旧值”是传递给didSet观察者的参数，它保存了被新属性替换的旧值。 ... } } }属性观察者的语法格式比计算属性要混乱。属性观察者可以在类和结构体中使用，不能在枚举中使用。示例代码如下：class Employee { var no: Int = 0 var name: String = "Tony" ...继续阅读 (84)

原创文章，欢迎转载。转载请注明：关东升的博客  计算属性本身不存储数据，而是从其他存储属性中计算得到数据。 计算属性概念：计算属性提供了一个getter（取值访问器）来获取值，以及一个可选的setter（设置访问器）来间接设置其他属性或变量的值。计算属性的语法格式如下：面向对象类型 类型名 { 存储属性 ...... var 计算属性名: 属性数据类型 { get { return 计算后属性值 } set (新属性值) { ...... } } }定义计算属性比较麻烦，要注意后面的几个大括号的对齐关系。我们先看一个示例：import Foundation class Employee { var no: Int = 0 var firstName: String = "Tony" //存储属性 var lastName: String = "G ...继续阅读 (88)

原创文章，欢迎转载。转载请注明：关东升的博客  Swift中的属性分为存储属性和计算属性，存储属性就是Objective-C中的数据成员，计算属性不存储数据，但可以通过计算其他属性返回数据。存储属性可以存储数据，分为常量属性（用关键字let定义）和变量属性（用关键字var定义）。存储属性概念：我们在前面曾用到过属性，Employee类和Department结构体。它们的类图如下，Employee的部门属性dept与Department之间进行了关联。我们可以在定义存储属性时指定默认值，示例代码如下：class Employee { let no: Int = 0 var name: String = "" var job: String? var salary: Double = 0 var dept: Department? } struct Department { let no: Int = 0 var name: String = "" } let emp = Employee() emp.no = 100 //编译错误 ：修改常量属性，程序会发生编译错误 let dept = Department() dep ...继续阅读 (89)

原创文章，欢迎转载。转载请注明：关东升的博客 类和结构体非常相似，很多情况下没有区别。如果你是设计人员在进行系统设计时候，是将某种类型设计成为类还是结构体？ 类和结构体异同：类和结构体都有如下功能：定义存储属性定义方法定义下标定义构造函数定义扩展实现协议 只有类才有的功能：能够继承另外一个类能够核对运行期对象的类型析构对象释放资源引用计数允许一个实例有多个引用 选择的原则：结构体是值类型，每一个实例没有独一无二的标识，下面两个数组实例本质上没有区别，他们可以互相替换。var studentList1: [String] = ["张三","李四","王五"] var studentList2: [String] = ["张三","李四","王五"]但是我们提到类时候，它是引用类型，每个实例都有独一无二的标识。我们看看下面员工Employee类代码：class Employee { var no = 0 var name = "" var job = "" var salary = 0.0 } var ...继续阅读 (82)

原创文章，欢迎转载。转载请注明：关东升的博客 访问级别：Swift提供了3种不同访问级别，对应的访问修饰符为：public、internal和private。这些访问修饰符可以修饰类、结构体、枚举等面向对象的类型，还可以修饰变量、常量、下标、元组、函数、属性等内容。public。可以访问自己模块中的任何public实体。如果使用import语句引入其他模块，我们可以访问其他模块中的public实体。internal。只能访问自己模块的任何internal实体，不能访问其他模块中的internal实体。internal可以省略，换句话说，默认访问限定是internal。private。只能在当前源文件中使用的实体，称为私有实体。使用private修饰，可以用作隐藏某些功能的实现细节。使用访问修饰符的示例代码如下： public class PublicClass {} internal class InternalClass {} private class PrivateClass {} public var intPublicVariable = 0 let intInternalConstant = 0 private func intPrivateFunction() {}使用最佳访问级别：由于中Swift中访问限定符能够修饰的实体很多 ...继续阅读 (99)

原创文章，欢迎转载。转载请注明：关东升的博客 在使用可选类型和可选链时，多次使用了问号（?）和感叹号（!），但是它们的含义是不同的，下面我来详细说明一下。 1.可选类型中的问号（?）声明这个类型是可选类型，访问这种类型的变量或常量时要使用感叹号（!），下列代码是显示拆包：let result1: Double? = divide(100, 200) print(result1!)    2.可选类型中的感叹号（!）声明这个类型也是可选类型，但是访问这种类型的变量或常量时可以不使用感叹号（!），下列代码是隐式拆包：let result3: Double! = divide(100, 200) print(result3)     3.可选链中的感叹号（!）多个实例具有关联关系，当从一个实例引用另外实例的方法、属性和下标等成员时就会形成引用链，由于这个“链条”某些环节可能有值，也可能没有值，因此需要采用如下方式访问：emp.dept!.comp!.name4.可选链中的问号（?）在可选链中使用感叹号（!）访问时，一旦“链条”某些环节没有值，程序就会发生异常，我们把感叹号（!）改为问号（?），代码如下所示：emp.dept?.comp?.name这样某些环节没有值的时候 ...继续阅读 (133)

原创文章，欢迎转载。转载请注明：关东升的博客 可选类型：我们先看看如下代码：var n1: Int = 10 n1 = nil //编译错误 let str: String = nil //编译错误Int和String类型不能接受nil的，但程序运行过程中有时被复制给nil是在所难免的，Swift为每一种数据类型提供一种可选类型（optional），即在某个数据类型后面加上问号（?）或感叹号（!），修改前文示例代码：var n1: Int? = 10 n1 = nil let str: String! = nilInt?和String!都是原有类型Int和String可选类型，它们可以接受nil。 可选类型值拆包在可选类型的问号（?）或感叹号（!）究竟有什么区别呢？这与可选类型的“拆包”（unwrapping）有关，拆包是将可选类型变成普通类型，如果我们直接打印非空的可选类型值，代码如下：var n1: Int? = 10 print(n1)输出的结果是Optional(10)，而非10。所以试图计算表达式n1+ 100会发生编译错误，代码如下：var n1: Int? = 10 print(n1 + 100) //发生编译错误需要对可选类型值进行“拆包”是必要地。“拆包”分为显示拆包和隐性拆包。使用问号（ ...继续阅读 (72)

Swift2.0学习笔记（Day 26）——可选链 原创文章，欢迎转载。转载请注明：关东升的博客 在Swift程序表达式中会看到问号（?）和感叹号（!），它们代表什么含义呢？这些符号都与可选类型和可选链相关，下面来看看可选链。 可选链：类图：它们之间是典型的关联关系类图。这些类一般都是实体类，实体类是系统中的人、事、物。Employee通过dept属性与Department关联，Department通过comp属性与Company关联。下面看示例代码： class Employee { var no: Int = 0 var name: String = "Tony" var job: String? var salary: Double = 0 var dept: Department = Department() } class Department { var no: Int = 10 var name: String = "SALES" var comp: Company = Company() } class Company { var no: Int = 100 ...继续阅读 (53)

原创文章，欢迎转载。转载请注明：关东升的博客Swift中的类和结构体定义的语法是非常相似的。类使用class关键词定义类，使用struct关键词定义结构体，它们的语法格式如下：class类名{   定义类的成员}struct结构体名{   定义结构体的成员}从语法格式上看，Swift中的类和结构体的定义更类似于Java语法，不需要像C++和Objective-C那样把接口部分和实现部分放到不同的文件中。下面来看一个示例：class Employee { //定义的类 var no: Int = 0 var name: String = "" var job: String? var salary: Double = 0 var dept: Department? } struct Department { //定义的结构体 var no: Int = 0 var name: String = "" }里面定义了一些属性。Employee ...继续阅读 (68)

原创文章，欢迎转载。转载请注明：关东升的博客Swift中的枚举可以定义一组常量、提高程序的可读性；还具有面向对象特性。使用enum关键词声明枚举类型，具体定义放在一对大括号内，枚举的语法格式如下：enum 枚举名{     枚举的定义}“枚举名”是该枚举类型的名称。它首先应该是有效的标识符，其次应该遵守面向对象的命名规范，它由一组成员值和一组相关值组成。成员值枚举的成员值默认情况下不是整数类型，以下代码是声明枚举示例：enum WeekDays { case Monday case Tuesday case Wednesday case Thursday case Friday }在这些成员值前面要加上case关键字，也可以将多个成员值放在同一行，用逗号隔开，如下所示：enum WeekDays { case Monday, Tuesday, Wednesday, Thursday, Friday }下面我们看一个示例，代码如下：var day = WeekDays.Friday day = WeekDays.Wednesday day = .Monday使用枚举成员赋值时候，我们可以采用完整的“枚举类型名.成员值”的形式，也可以省略枚举类型采用“.成员值”的形式。这种省略形式能够访问的前提 ...继续阅读 (65)

原创文章，欢迎转载。转载请注明：关东升的博客 闭包表达式可以作为函数的参数传递，如果闭包表达式很长，就会影响程序的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。下面我们来看一个示例代码：func calculate(opr: String, funN:(Int, Int) -> Int) {　 //最后一个参数funN是(Int,Int)-> Int函数类型，funN可以接收闭包表达式 switch (opr) { case "+" : print("10 + 5 = \(funN(10,5))") default: print("10 - 5 = \(funN(10,5))") } } calculate("+", funN: {(a: Int, b: Int) -> Int in return a + b }) //调用 calculate("+"){(a: Int, b: Int) -> Int in return a + b } //调用，这种形式就是尾随 ...继续阅读 (59)

原创文章，欢迎转载。转载请注明：关东升的博客 我给Swift中的闭包一个定义：闭包是自包含的匿名函数代码块，可以作为表达式、函数参数和函数返回值，闭包表达式的运算结果是一种函数类型。Swift中的闭包类似于Objective-C中的代码块、Java中的匿名内部类。 使用闭包表达式Swift中的闭包表达式很灵活，其标准语法格式如下：{ (参数列表) ->返回值类型in   语句组}其中，参数列表与函数中的参数列表形式一样，返回值类型类似于函数中的返回值类型，但不同的是后面有in关键字。Swift提供了多种闭包简化写法，我来介绍下面几种不同形式： 1、类型推断简化类型推断是Swift的强项，Swift可以根据上下文环境推断出参数类型和返回值类型。以下代码是标准形式的闭包：{(a:Int, b:Int) -> Intin   return a + b}Swift能推断出参数a和b是Int类型，返回值也是Int类型。简化形式如下：{(a, b) in return a + b }{a, b in return a + b } //参数列表括号也可以省略 2、隐藏return关键字在闭包内部语句组只有一条语句，如return a + b等，那么这种语句都是返回语句。前 ...继续阅读 (98)

原创文章，欢迎转载。转载请注明：关东升的博客 返回值3种形式：无返回值、单一返回值和多返回值。 无返回值函数所谓无返回结果，事实上是Void类型，即表示没有数据的类型。无返回值函数的语法格式有如下3种形式：func函数名(参数列表) {   语句组} func函数名(参数列表) ->() {   语句组} func函数名(参数列表) ->Void {   语句组}无返回值函数不需要“return返回值”语句。 多返回值函数两种方式来实现。一种是在函数定义的时候，将函数的多个参数声明为引用类型传递，这样当函数调用结束时，这些参数的值就变化了。另一种是将返回定义为元组类型。介绍元组类型返回多值的实现。看一个示例：func position(dt: Double,speed:(x:Int, y:Int)) -> (x:Int, y:Int) {      letposx:Int = speed.x * Int(dt)    letposy:Int = speed.y * Int(dt)    ...继续阅读 (61)

原创文章，欢迎转载。转载请注明：关东升的博客 参数的传递引用类是引用类型，其他的数据类型如整型、浮点型、布尔型、字符、字符串、元组、集合、枚举和结构体全部是值类型。有的时候就是要将一个值类型参数以引用方式传递，这也是可以实现的，Swift提供的inout关键字就可以实现。看下面的一个示例：func increment(inout value:Double, amount:Double = 1.0) { value += amount } var value : Double = 10.0　 increment(&value) print(value) increment(&value, amount:100.0) print(value)代码increment(&value)是调用函数increment，增长量是默认值，其中&value（在变量前面加&符号，取出value地址）是传递引用方式，它在定义函数时，参数标识与inout是相互对应的。代码increment(&value,amount:100.0)也是调用函数increment，增长量是100.0。上述代码输出结果如下：11.0111.0 欢迎关注关东升新浪微博@tony_关东升。关注智捷课堂微信公共平台，了解最新 ...继续阅读 (91)

原创文章，欢迎转载。转载请注明：关东升的博客 函数的语法格式如下：func函数名(参数列表) ->返回值类型{   语句组   return返回值}关键字是func。多个参数列表之间可以用逗号（,）分隔，也可以没有参数。使用箭头“->”指示返回值类型。返回值有单个值和多个值。如果函数没有返回值，则“->返回值类型”部分可以省略。如果函数有返回值，就需要在函数体最后使用return语句；如果没有返回值，则函数体中可以省略return语句。函数定义示例代码如下：funcrectangleArea(width:Double, height:Double) -> Double {   let area = width * height   return area   } print("320x480的长方形的面积:\(rectangleArea(320, height:480))") 传递参数 介绍几种不同形式的参数。 使用外部参数名为每个参数提供一个可以在函数外部使用的名称，称为外部参数名，修改rectangleArea函数的定义如下：func ...继续阅读 (211)