Swift学习进阶
文章目录
- 1.print(str)
- 2.浮点型取余
- 3.Swift中的数据类型
- 4.Swift中的for循环
- 5. break语句
- 6.Set集合
- 7.函数
- 7.1 .Swift 函数参数
- 7.2. Swift函数返回值
- 7.3. Swift函数类型
- 8.运算符重载
- 9.类型嵌套
- 10.类和结构体的异同。
- 11.属性与下标。
- 11.方法。
- 12.重写
- 13.类检查与转换（is、as、as!、as?、AnyObject、Any）
- 14.扩展(extension)
1.print(str)
- print函数能够将表达式的结果输出到控制台，类似C的printf函数和OC的NSLog函数。
- print函数定义：
public func print(_ items: Any..., //任意个数，任何类型的参数它们将输出到控制台
separator: String = default,//输出多个参数之间的分隔符
terminator: String = default)//输出字符串之后的结束符号
参数separator、terminator都可以省略，separator只有字输出数据大于1时才有意义。
- 示例：
print("a","b","c","d","e", separator: "|", terminator: "-")
打印结果为a|b|c|d|e-,用|将打印的字母分开，用-来结束打印。
- 自定义打印日志：
//自定义log p28
func hjLog(mes:Any){
print("file:\(#file) column:\(#column) line:\(#line) \(mes)")
}
由于Swift中不能定义宏，只能定义一个打印日志的方法，上面方法打印文件路径，行数，及要打印的内容，可以方便的定位到打印的位置。
2.浮点型取余
- Swift中允许浮点型取余，但是在Swift3之后取余运算符
%不能应用于浮点数运算，需要使用public func truncatingRemainder(dividingBy other: Double) -> Double方法来计算浮点型取余。
var c = 19.22
//浮点型取余
let d = c.truncatingRemainder(dividingBy: 6.1)
3.Swift中的数据类型
- 根据这些类型在赋值或给函数传递时的方式，可分为
值类型和引用类型。值类型就是创建一个副本，把副本赋值或传递过去，这样在函数的调用过程中不会影响原始数据；引用类型就是把数据本身的引用（即指针）赋值或传递过去在函数的调用过程中会影响原始数据。 - Swift中整型、浮点型、布尔型、字符型、字符串、元组、集合、枚举。结构体值类型，而类属于引用类型。如Swift中
String是值类型、NSString是引用类型。 - 整型、浮点型、布尔型、字符型、字符串、元组、集合等类型本质上都是结构体类型，结构体有构造函数，通过构造函数创建并初始化实例。
- 用于判断的几种方式：
==比较基本类型的值是否相等===比较对象类型,是不是同一个对象is判断某个实例是否为某种类型as强制类型转换
4.Swift中的for循环
- Swift3之后C语言风格的for语句不再使用， Swift3之后for语句只能与in关键字结合使用。
- 示例1：只需要知道连续区间的值（只需要循环变量）
//打印1到9平方的值
for i in 1..<10{
print("\(i)x\(i)=\(i*i)")
}
- 示例2：只需要连续获取集合元素的值（不需要循环变量）
//打印集合元素
let nums = [1,2,3,4,5,6,7,8,9]
for item in nums {
print(item)
}
- 示例3：既需要集合元素的值，又需要脚标（需要循环变量），可以使用结合的
enumerated()方法
let nums = [1,2,3,4,5,6,7,8,9]
for(index,item) in nums.enumerated(){
print("\(index):\(item)")
}
- Swift中的区间分为两种，全闭合区间
...和左闭右开区间..<。
5. break语句
- break语句可用于循环语句结构，（Swift中的循环语句有while、repeat-while、for ），作用是强制退出循环结构，不执行循环结构中的剩余语句。由于Swift的选择switch默认会添加break，所以一般不需要收到添加break，但添加上也不会出问题。
for i in 1...10{
print("\(i)x\(i)=\(i*i)")
if i == 5{
break;
}
}
- break可以配合标签使用
label1: for x in 0..<5 {
label2: for y in (1...5).reversed(){
if x == y {
break label1
}
print("(x,y)=(\(x),\(y))")
}
}
默认情况下break只会跳出最近的内循环，而示例中条件成立时直接跳出循环，给外循环添加了一个标签label1，然后break后面指定这个标签，当条件成立就跳出该标签的外循环。reversed()是反向变量区间。
6.Set集合
- Swift集合有
数组、字典、Set集合。数组是一组有序的由相同类型元素构成的集合;字典由两部分组成，一个键集合，一个值集合，键集合不能有重复元素，而值集合可以重复，键值成对出现；Set集合是由一串无序的，不能重复的相同类型元素构成的集合。 - 与OC任何对象类型不同，三种集合都强调是元素的类型一致，但这里的类型指的是泛型。如果想包含任何类型可指定为
Any。
//正规声明
var arr : Array<Any> = [1,2,"3",1.22]
print(arr[1])
//简写声明
let dic:[AnyHashable : Any] = [1:2,2:3,"3":4,4:"5"]
//字典的key和value都为任何类型，有可能是可选类型，获取元素值时要解包
print(dic[1]!)
let set:Set<String> = ["1","12","123"]
print(set.first!)
- Array和Dictionary有简写的声明，而Set集合没有简写的声明。因为Set和Array唯一的区别是无序且不重复（当不考虑叙述而且没有重复的元素时，二者可互相替换），如果简写了就无法区分是Set还是Array了。
- 三种集合强调的点不同， Array强调有序；Set强调不重复（无序）；字典强调key唯一（不能重复），通过key取值，也是无序的。
- Set的一般操作：
let set:Set<String> = ["1","123","12","12","1234"]
print("第一个元素\(set.first!)")
print("元素个数\(set.count)")
var set2:Set<String> = ["1234","1","123","12"]
if set == set2{
print("set等于set2")
}
//插入一个元素
set2.insert("插入")
//删除某个元素
let item = "1"
set2.remove(item)
print(set2)
//删除一个元素,这里并不是第一个元素,而是随机的
set2.removeFirst()
print(set2)
//判断是否包含某个元素
if set.contains("1234"){
print("set有该元素")
}
结果可以看出Set的first方法获取的并不一定是第一个元素，而是随机的。多个重复的元素在Set中只算一个，从count可以看出。
- Set集合遍历
for item in set{
print(item)
}
for (index,item) in set.enumerated(){
print("\(index+1):\(item)")
}
注意：Set的enumerated()方法可以取出Set的索引和元素， (index,item)是元组类型。这里的index是循环遍量，可以表示循环次数，而不是元素的序号脚标。
- Set集合间的运算，首先了解一下几个概念（A,B是两个Set集合）：
- 交集：属于A且属于B的元素集合
- 并集：属于A或属于B的元素集合
- 异或集合：A与B的并集元素集合去掉A与B的交集集合中的元素后剩下元素的集合
- 差集：属于A而不属于B的元素集合称A与B的差集。（A与B的并集去掉B中所有元素后的集合）
- 子集：B中所有元素都A的元素，那么久称B是A的子集。但是Set集合运算过程中不涉及Set子集概念。
let A:Set<String> = ["a","b","c","d"]
let B:Set<String> = ["c","d","e","f"]
print("A与B的交集 = \(A.intersection(B))")
print("A与B的并集 = \(A.union(B))")
print("A与B异或集合 = \(A.symmetricDifference(B))")
let C = A.subtracting(B)
print("A与B差集 = \(C)")
if C.isSubset(of: A){
print("C是A的子集")
}
7.函数
7.1 .Swift 函数参数
- Swift中的函数参数很灵活，具体体现在传递参数有多种形式。
- 我们可以为每个参数提供标签，为调用者说明参数的含义，这些变迁命名应该唯一，并且有意义：
func rectangleArea(W width:Double,H height:Double) ->Double{
return width*height
}
print(rectangleArea(W: 10.0, H: 10.0))
W,H就是参数标签,外部调用时会提示使用。
- 如果定义函数没有声明标签，原则上也是可以的
func rectangleArea2(width:Double,height:Double) ->Double{
return width*height
}
print(rectangleArea2(width: 10.0, height: 10.0))
- 省略参数标签，在Swift3以后，调用函数时要求指定所有参数的标签，除非函数定义是使用下划线
_关键字声明的标签。
func rectangleArea3(_ width:Double,_ height:Double) ->Double{
return width*height
}
print(rectangleArea3(10,10))
- 给参数设默认值，当调用时可以忽略该参数,调用时如果没传值就取默认值,如果赋值了就会覆盖掉默认值
func test(a:Int = 10,b:Int) -> Int{
return a+b
}
print(test(b: 20)) //30
print(test(a: 1, b: 2)) //3
- 可变参数:参数个数可以变化,调用时可以接受不确定数量的参数,这些参数具有相同的类型,有点像传入了一个数组
func sum(nums:Int...)->Int{
var total = 0
for num in nums{
total += num
}
return total
}
print(sum(nums: 1,2,3))
print(sum(nums: 1,2,3,4,5,6,8))
sum函数是用来求多个整型的函数,参数nums:Int…是Int类型的可变参数,在函数体重nums被认为是一个Double类型的数组
- 类型参数的引用传递:除了类是引用类型,其他如整型…都是值类型,但有时候我们想在函数内部改变函数外面参数的值,这样就需要将值类型参数以引用类型方式传递。
func increment(value: inout Double,auto:Double = 1.0){
value += auto
}
var value:Double = 10.0
print(value)
increment(value: &value)
print(value) //11.0
参数value是需要增长的数值，它被设计为inout类型，inout修饰的参数称为输入输出参数，value必须是变量不能是let修饰的常量。
7.2. Swift函数返回值
- 函数返回值分为无返回值和有返回值，无返回值其类型是void，可以省略不写；有返回值又分为单个返回值，和多个返回值，单个返回值就是返回一种类型，多个返回值可以返回多个类型，将这些不同类型的返回值放到元组中返回就可以了。
7.3. Swift函数类型
- 每个函数都有一个类型，使用函数类型与使用其他数据类型一样，可以声明变量或常量，也可以作为其他函数参数或返回值使用。
- 用函数类型声明常量或变量
func rectangleArea(width: Double,height:Double) -> Double {
return width * height
}
let rectangleArea1: (Double,Double)->Double = rectangleArea(width:height:)
print(rectangleArea1(10,10)) //100.0
var rectangleArea2: (Double,Double)->Double = rectangleArea(width:height:)
rectangleArea2(20,20)
rectangleArea2 = rectangleArea(width:height:)
print(rectangleArea2(30,30)) //900.0
- 用函数类型作为函数返回类型使用
//计算矩形面积
func rectangleArea(width: Double,height:Double) -> Double {
return width * height
}
//计算三角形面积
func triangleArea(width: Double,height:Double) -> Double {
return width * height/2.0
}
//作为函数返回类型使用
func getArea(type:String) -> (Double,Double)->Double {
var returnFunc: (Double,Double)->Double
switch type {
case "矩形":
returnFunc = rectangleArea
default://三角形
returnFunc = triangleArea
}
return returnFunc
}
let rectangleFunc = getArea(type: "矩形")
print("矩形面积:\(rectangleFunc(20,20))") //矩形面积:400.0
let triangleFunc = getArea(type: "三角形")
print("三角形面积:\(triangleFunc(20,20))") //三角形面积:200.0
getArea返回值类型为函数类型，常量rectangleFunc和triangleFunc只是接收了getArea函数的返回值，是将计算矩形面积和三角形面积的函数真正声明了，rectangleFunc(20,20)和triangleFunc(20,20)才是对计算面积的函数的真正调用。总之就是getArea函数调用是为了声明rectangleArea和triangleArea,返回的函数常量或变量的调用才是真正用于计算面积的，
- 用函数类型做为函数参数类型使用
//计算矩形面积
func rectangleArea(width: Double,height:Double) -> Double {
return width * height
}
//计算三角形面积
func triangleArea(width: Double,height:Double) -> Double {
return width * height/2.0
}
//作为参数类型使用
func getAreabByFunc(funcName:(Double,Double)->Double,a:Double,b:Double)->Double {
let area = funcName(a,b) //对传进来函数参数的真正调用
return area;
}
print("矩形面积:\(getAreabByFunc(funcName: rectangleArea, a: 10, b: 10))") //矩形面积:100.0
print("三角形面积:\(getAreabByFunc(funcName: triangleFunc, a: 10, b: 10))") //三角形面积:50.0
getAreabByFunc调用值只需要将函数名传进来就可以，传进来的函数参数直接在里面调用。
7.4. Swift嵌套函数
- 将函数定义在另外的函数体重，称为
嵌套函数。
//嵌套函数
func calculate(opr:String) -> (Int,Int) -> Int {
//定义加函数
func add(a:Int,b:Int) -> Int{
return a + b
}
//定义减函数
func sub(a:Int,b:Int) -> Int{
return a - b
}
var result: (Int,Int) -> Int
switch opr {
case "+":
result = add
case "-":
result = sub
default:
result = add
}
return result
}
let addfunc = calculate(opr: "+") // 声明加函数
print("5+5 = \(addfunc(5,5))") //5+5 = 10
let subfunc = calculate(opr: "-")// 声明减函数
print("5-5 = \(subfunc(5,5))")//5-5 = 0
嵌套函数的作用域在外函数体内，但我们可以定义外函数的返回值类型为嵌套函数类型，从而将嵌套函数出啊递给外函数，被其调用者调用。
8.运算符重载
- Swift中除了class类型是引用类型，其他整型，浮点型，数组，结构体等都是值类型，对于引用类型通常用
===和!===来判断是不是同一个对象；对于值类型通常用==和!=来判断两个值是否相等。 - 示例：自定义一个机构体，判断两个实例是否相等。
struct Student {
var name = ""
var no = 0
var age = 0
}
var stu1 = Student()
stu1.name = "张三"
stu1.no = 1
stu1.age = 18
var stu2 = Student()
stu2.name = "张三"
stu2.no = 1
stu2.age = 18
if stu1 == stu2{
print("是同一个学生")
}else{
print("不是同一个学生")
}
可以发现在运行时报错了，报错说明为==不能用于两个Student结构体实例操作。说了stu1和stu2不能用于比较。我们需要在这些类型中重载==和!=运算符号。即定义相等规则。
struct Student {
var name = ""
var no = 0
var age = 0
}
//定义重载==号运算符符
func == (lsh:Student,rhs:Student) -> Bool {
return lsh.name == rhs.name && lsh.no == rhs.no && lsh.age == rhs.age
}
//定义重载!=号运算符符
func != (lsh:Student,rhs:Student) -> Bool {
return (lsh.name != rhs.name || lsh.no != rhs.no || lsh.age != rhs.age)
}
var stu1 = Student()
stu1.name = "张三"
stu1.no = 1
stu1.age = 18
var stu2 = Student()
stu2.name = "张三"
stu2.no = 1
stu2.age = 18
if stu1 == stu2{
print("是同一个学生")
}else{
print("不是同一个学生")
}
9.类型嵌套
- Swift中的类、结构体和枚举可以进行嵌套。优点是支持访问它外部的成员（包括方法、属性和其他嵌套类型），嵌套可以有多个层次。
class Employee {
var name = ""
var no = 0
var job = ""
var day = WeekDays.Friday
var dept = Department()
struct Department {
var no = 10
var name = "Sales"
}
enum WeekDays{
case Monday,Tuesday,Wednesday,Thursday,Friday
struct Day {
static var mes = "Today is ..."
}
}
}
let emplo = Employee()
print(emplo.day)
print(emplo.dept.name)
print(Employee.WeekDays.Day.mes)
10.类和结构体的异同。
- 相同点：
- 定义存储属性；
- 定义方法；
- 定义下标；
- 定义构造函数；
- 定义扩展；
- 实现协议
- 不同点：（只有类才有的功能）
- 能够继承另外一个类；
- 能够核对运行时对象的类型；
- 析构对象释放资源；
- 引用计数允许一个实例有多个引用。
- 选择的原则：结构体是值类型，每一个实例没有独一无二的标识，而类是引用类型，每一个实例都是独一无二的标识。
class Employee{ //员工类
var no = ""
var name = ""
var dept: Department?
}
struct Department{//部门结构体
var no = ""
var name = ""
}
上面示例可以看出，由于员工的编号都是独一无二，每个员工是独立的个体，所以员工可以声明成类Employee；如果具有相同部门标号和部门名称，我们就认为是它们是相同的部门，所以就可以把部门设计为机构体Department。
11.属性与下标。
- Swift中的属性分为
存储属性和计算属性。存储属性就是oc中的数据成员，计算属性不存储数据，但可以通过计算其他属性返回数据。
class Employee{
let no = 0
var firstName = "Tony"
var lastName = "Guan"
lazy var dept: Department = Department() //延迟存储属性
var fullName: String{ //计算属性
get{
return firstName + "." + lastName
}
set(newFullName){
let names = newFullName.components(separatedBy: ".")
firstName = names.first!
lastName = names.last!
}
// set{
// let names = newValue.components(separatedBy: ".")
// firstName = names.first!
// lastName = names.last!
// }
}
}
struct Department{
var no = ""
var name = ""
}
let emp = Employee()
//emp.no = 10;编译会报错 ，常量属性不允许被修改。
print(emp.fullName)
emp.fullName = "Jack.Ma"
print(emp.fullName)
let dept = Department()
上面类Employee中的no、firstName、lastName、dept都是存储属性，fullName是计算属性，其中dept是延迟存储属性。
- 延迟存储属性：存储属性前面加上lazy关键字声明，就是延迟存储属性，只在第一次访问时加载，如果不访问就不会创建，这样可以减少内存占用，注意存储属性没有延迟加载一说，添加到存储属性前面会报错的。
- 计算属性：计算属性本身不存储数据，而是从其他属性计算得到数据。计算属性提供一个Getter(取值访问器)来获取值，以及一个
可选的(可以不实现set方法)Settter(设置访问器)来间接设置其他属性或变量的值，语法如下。
面向对象的类型（class、struct、enum） 类型名{
存储属性
var 计算属性名： 属性数据类型{
get{
return 计算后的语句值
}
set（新属性值）{
语句组
}
}
}
其中新属性值是要赋值给属性值的，当然也可以不写，Swift提供了一个默认的变量newValue去接收新传入的值。上面set(newFullName)可以省略如下：
set{
let names = newValue.components(separatedBy: ".")
firstName = names.first!
lastName = names.last!
}
- 只读计算属性：计算属性只有Getter访问器，没有Setter访问器，只能取值而不能赋值。（只读存储属性就是let修饰的存储属性）
class Employee{
let no = 0
var firstName = "Tony"
var lastName = "Guan"
lazy var dept: Department = Department()
var fullName: String{
get{
return firstName + "." + lastName
}
}
}
let emp = Employee()
//emp.no = 10;
print(emp.fullName)
// emp.fullName = "Jack.Ma" //不能赋值
fullName就是只读计算属性，不能给其赋值,结构体，枚举的计算属性也是类似，这里不再赘述。只读属性可以简化去掉get关键字和括号，上面只读属性可以简化为：
var fullName: String {
return firstName + "." + lastName
}
- 存储属性观察者：Swift的属性观察者有两个，willSet：观察者在修改之前调用，didSet观察者在修改之后调用 语法格式如下。
面向对象类型(class/struct) 类型名{
...
var 存储属性值: 属性数据类型 = 初始值{
willSet(新值){
...
}
didSet(旧值){
...
}
}
}
示例
class Employee1{
let no = 0
var name = "Tony"{
willSet(newName){
print("员工新名字:\(newName)")
}
didSet(oldName){
print("员工旧名字:\(oldName)")
}
}
}
struct Department1{
var no = 1{
willSet{
print("部门新编号:\(newValue)")
}
didSet{
print("部门旧编号:\(oldValue)")
}
}
var name = "移动开发部"
}
let emp1 = Employee1()
emp1.name = "Jack"
//结构体是值类型,必须用声明为变量才能修改其属性
var dept1 = Department1()
dept1.no = 10
Employee1类中给name存储属性添加了观察者， willSet(newName)中的newName是要传进来的新值，didSet(oldName)中的oldName是新值传进来之前的旧值；参数的声明可以省略。Department1结构体中的no就省略了观察者参数，Swift提供了对应默认参数，新值默认是newValue,旧值默认是oldValue。这里需要说明下枚举只有计算属性没有存储属性，所以枚举不支持属性观察者。
- 静态属性：在属性前面加static关键字，类中也可以加class关键字，这样的属性称为静态属性。类，结构体，枚举都可以定义静态属性（也包括静态存储属性和静态计算属性）。这里需要注意的是
枚举中没有实例存储属性但是可以有静态存储属性。
struct Account {
var amount = 0.0 //账户金额
var ower = "" //账户名
static let monthRate = 0.00688 //月利率
static var yearRate : Double{ //计算存储属性不能用let修饰,及不能是常量
return monthRate * 12
}
var owerInterest:Double{ //年利息
return Account.yearRate * amount
}
}
//访问静态属性
print(Account.yearRate)
var account = Account()
//访问实例属性
account.amount = 100000.0
print(account.owerInterest)
class Account {
var amount = 0.0 //账户金额
var ower = "" //账户名
static let monthRate = 0.00688 //月利率
class var yearRate : Double{ //class换成static子类就不能重写该属性
return monthRate * 12
}
var owerInterest:Double{ //年利息
return Account.yearRate * amount
}
static var test:Int = 10{ //静态属性也支持添加属性监听者
willSet{
print(newValue)
}
didSet{
print(oldValue)
}
}
}
//访问静态属性
print(Account.yearRate)
var account = Account()
//访问实例属性
account.amount = 100000.0
print(account.owerInterest)
class Account2:Account{
override class var yearRate : Double{ //class换成static子类就不能重写该属性
return monthRate * 12 * 1.1
}
}
这里枚举与结构体类似不再举例，类中static修饰的属性为类的静态属性，class修饰的属性称为类的类属性,区别是类的类属性可以被子类重写，但是class不能修饰存储属性，static却可以。
- 实例属性和静态属性总结
1. 类、结构体,枚举都支持静态存储属性、静态计算属性，实例计算属性；但是只有类和结构体支持实例存储属性，枚举不支持实例存储属性。
2. 基于第一条可知只有类和结构体支持添加属性观察者（因为只有存储属性才能添加属性观察者）
3. 延迟属性只能是延迟存储属性
4. 计算属性必须是var声明的
5. let修饰的存储属性，前可以加static称为静态存储属性，不能加class
6. class修饰的属性可以被重写，但static修饰的属性不允许被重写。
7. class只能修饰计算属性。
- 下标：Swift中，我们可以定义一些集合类型，，它们可以回有一些集合类型的存储属性，这些属性可通过下标访问，其如法格式如下。
面向对象类型(class/struct/enum) 类型名{
...
subscript (参数:参数数据类型)->返回值类型{
get{
return 返回值
}
set(新属性值){
...
}
}
}
Swift中没有提供二维数组，但是我们可以通过下标自定义一个二维数组。
struct DoubleDimensionalArray {
let rows:Int,colums:Int
var grid: [Int]
init(rows:Int,colums:Int) {
self.rows = rows //行数
self.colums = colums //列数
grid = Array(repeating: 0, count: rows * colums) //初始化数组都为0
}
subscript(row:Int,col:Int) -> Int{
get{
return grid[row * colums + col] //返回对应的脚标取出二维数组的值
}
set{
grid[row * colums + col] = newValue //通过脚标给二维数组赋值
}
}
}
//初始化一个10行10列的二维数组
var arr = DoubleDimensionalArray(rows: 10, colums: 10)
for i in 0..<10 {
for j in 0..<10{
arr[i,j] = i*j //通过脚标给二维数组赋值为脚标之和
}
}
for i in 0..<10 {
for j in 0..<10{
print("\t \(arr[i,j])",terminator: " ") //通过脚标获取二维数组中的值
}
print("\n")
}
11.方法。
- Swift中,方法是在类,结构体,枚举中定义的函数,分为实例方法和静态方法.
- 方法和函数的区别:方法是在在类,结构体,枚举内部定义的.方法调用前面要有主体,而函数就不需要.
- 我们在枚举和结构体方法掐面添加关键字mutatting,将方法声明为可以变方法,可变方法能够修改
值类型变量属性,但不能修改值类型常量属性.也就说不可变方法值类型属性是都不能访问的，但引用类型的属性是可以访问的。- static修饰的方法为静态方法,当然类中class修饰的方法类方法.与计算属性类似,实例方法中既可以访问实例属性和方法又可以访问静态属性和方法,但是静态方法不能访问实例属性和实例方法,只能访问静态属性和方法.
- class修饰的方法能被重写,static修饰的方法不能被重写.
12.重写
- 一个类继承另一个类的属性,方法,下标等特征后,子类可以重写（
override）这些特征。 - 重写实例属性：实例属性重写一方面可以Getter和Setter访问器，另一方面可以重写属性观察者。
class Person {
var name: String
var age: Int
init(name:String,age:Int) {
self.name = name
self.age = age
}
}
class Student: Person {
var school: String
override var age:Int {
get{
return super.age
}
set{
super.age = newValue<8?8:newValue
}
}
}
从属性重写来看，子类本身并不存储数据，数据存储在父类的存储属性中，子类将其变成了计算属性并重写。
注意：一个属性重写了Getter和Setter访问器后就不能重写观察者。另外常量属性和只读计算属性也都不能重写属性观察者。
- 重写静态属性:
class Account{
class var staticProp:Double{
return 0.0668 * 1000000
}
}
class TermAccount: Account {
override static var staticProp:Double{
return 0.0700*1000000
}
}
Account的静态属性staticProp只能用class修饰，因为要在子类TermAccount重写该静态属性，所以该属性能被继承才行，而TermAccount可以用class也可以用static修饰，因为没有子类继承TermAccount的staticProp属性。
- 重写实例静态方法：
class Person {
var name: String
var age: Int
init(name:String,age:Int) {
self.name = name
self.age = age
}
func description() -> String {
return "\(name)的年龄为:\(age)"
}
}
class Student: Person {
var school: String
override var age:Int {
get{
return super.age
}
set{
super.age = newValue
}
}
override init(name:String,age:Int) {
self.school = "清华大学"
super.init(name: name, age: age)
}
override func description() -> String {
return "\(name)的年龄为:\(age),所在学校为\(school)"
}
}
静态方法重写与实例方法重写类似，在方法名钱加上override关键字即可，但是只有class修饰的静态方法才能被被继承被重写，static修饰的静态方法不能被重写。
- 下标重写：对下标重写也是重写Getter和Setter访问器，类似于属性，这里不再举例。
- final关键字：final关键字可以声明类、属性、方法、和下标。final关键字可以声明类不能被继承，声明的属性、方法和下标不能被重写。
13.类检查与转换（is、as、as!、as?、AnyObject、Any）
- 使用is进行类型检查：
is操作符可以判断一个实例是否是某个类的类型。(只要是该类型以及该类型的父类以及父类的父类类型，返回都为true，类似于oc的isKindOfClass方法)
//Student继承于Person
let stu = Student(name: "马云", age: 18)
if stu is Student{
print("马云18岁是一个学生")
}
if stu is Person{
print("马云18岁是一个人")
}
- 使用as、as!、as?进行类型转换：
- as操作符：用于向上转型（子类转换成父类），因为向上转型很少进行，所以代码中很少能够看到使用as操作符(通常都是向下转型：父类转出子类)。
- as!操作符: 在类型转换过程中对可选值进行拆包，转换结果是费可选类型。将费可选类型转换为非可选类型，将可选类型转换为非可选类型。
- as?操作符: 在类型转换过程中不进行裁包，转换结果是可选类型。将非可选类型转换为可选类型，将可选类型转换为可选类型。
//Student,Worker类都继承于People
let stu1 = Student(name: "李彦宏", age: 35, school: "北京大学")
let stu2 = Student(name: "马化腾", age: 45, school: "深圳大学")
let stu3 = Student(name: "马云", age: 55, school: "杭州师范大学")
let wk1 = Worker(name: "李开复", age: 56, factory: "微软")
let wk2 = Worker(name: "张小龙", age: 46, factory: "腾讯")
let people = [stu1,stu2,stu3,wk1,wk2]
for p in people{
if let stu = p as? Student{ //这里在是先转换为可选类型,并且在转换成功后进行了可选绑定(因为都有值就解包了)
print("Student \(stu.name),年龄:\(stu.age),毕业于:\(stu.school)")
}else if let wk = p as? Worker{
print("Worker \(wk.name),年龄:\(wk.age),工作于:\(wk.factory)")
}
}
let stu4 = people[0]as? Student //这里是直接赋值为可选类型
print("--------")
print(stu4 as Any)
print(stu4?.name as Any) //可选类型安全访问其属性的写法
print(stu4!.name)
- 使用
AnyObject和Any类型：Swift提供了两种类型来表示不确定类型（任意类型），AnyObject表示任何类（class）的类型;Any则表示任何类型,包括Int、Double、Array、struct等基本数据类型，也包括AnyObject类型。也就是说AnyObject是Any的子集。 - 在OC与Swift混合编程时，OC的id类型和Swift的AnyObject类型可以互换，但是两者有本质区别。id类型是泛性，可以代表任何指针类型，编译时编译器不检查id类型，是动态的。AnyObject是实实在在表示类的类型，编译时会检查AnyObject类型。
- 原则上若能使用集体的数据类型，则尽量不要使用AnyObject类型,更要少考虑使用Any类型。从集合中取出这些实例时也要尽可能的将AnyObject类型和Any类型转换为特定类型，然后再进行接下来的操作。
14.扩展(extension)
- Swift中可以使用一种扩展机制，在原始类型（类、机构体、枚举）的基础上添加新功能。扩展是一种轻量级的继承机制。
- Swift中扩展机制可以在原始类型中添加新功能包括：
- 实例计算属性和静态计算属性
- 实例方法和静态方法
- 构造函数（结构体中可以扩展构造函数；类中只能扩展便利构造函数，不能扩展指定构造函数和析构函数，指定构造函数和析构函数只能在原始类中提供）
- 下标