Swift—类型检查与转换-备

继承会发生在子类和父类之间，是一系列类的继承关系。

例如：Person是类层次结构中的根类，Student是Person的直接子类，Worker是Person的直接子类。

这个继承关系类的具体实现代码如下：

 

 
  1. class Person {  
  2.   
  3.     var name: String  
  4.   
  5.     var age: Int  
  6.   
  7.       
  8.   
  9.     func description() -> String {  
  10.   
  11.         return "(name) 年龄是: (age)"  
  12.   
  13.     }  
  14.   
  15.     convenience init () {  
  16.   
  17.         self.init(name: "Tony")  
  18.   
  19.         self.age = 18  
  20.   
  21.     }  
  22.   
  23.     convenience init (name: String) {  
  24.   
  25.         self.init(name: name, age: 18)  
  26.   
  27.     }  
  28.   
  29.     init (name: String, age: Int) {  
  30.   
  31.         self.name = name  
  32.   
  33.         self.age  = age  
  34.   
  35.     }  
  36.   
  37. }  
  38.   
  39.    
  40.   
  41. class Student: Person {  
  42.   
  43.     var school: String  
  44.   
  45.     init (name: String, age: Int, school: String) {  
  46.   
  47.         self.school = school  
  48.   
  49.         super.init(name: name, age: age)  
  50.   
  51.     }  
  52.   
  53. }  
  54.   
  55.    
  56.   
  57. class Worker: Person {  
  58.   
  59.     var factory: String  
  60.   
  61.     init (name: String, age: Int, factory: String) {  
  62.   
  63.         self.factory = factory  
  64.   
  65.         super.init(name: name, age: age)  
  66.   
  67.     }  
  68.   
  69. }  

下面将以此为例，介绍Swift类的类型检查与转换，包括is操作符、as操作符。

 

使用is操作符

is操作符可以判断一个实例是否是某个类的类型。如果实例是目标类型，结果返回true，否则为false。

下面看一个示例：

let student1 = Student(name: "Tom", age: 18,school: "清华大学")//创建Student实例

let student2 = Student(name: "Ben", age: 28,school: "北京大学")//创建Student实例

let student3 = Student(name: "Tony", age: 38,school: "香港大学")//创建Student实例

 

let worker1 = Worker(name: "Tom", age: 18,factory: "钢厂")//创建Worker实例

let worker2 = Worker(name: "Ben", age: 20,factory: "电厂")//创建Worker实例

 

let people = [student1, student2,student3, worker1,worker2]    //实例放入people数组集合中

 

var studentCount = 0

var workerCount = 0

 

for item in people { //使用for in遍历people数组集合

    if item is Worker {   

        ++workerCount

    } else if item is Student {   

        ++studentCount

    }

}

 

print("工人人数：(workerCount) ，学生人数：(studentCount) 。")

我们可以在循环体中进行判断， item is Worker表达式是判断集合中的元素是否是Worker类的实例。

类似地， item is Student表达式是判断集合中的元素是否是Student类的实例。

输出结果如下：

工人人数：2，学生人数：3。

 

使用as操作符

在介绍as操作符之前，先了解一下对象的类型转换，并不是所有的类型都能互相转换。下面先看如下语句：

let p1: Person = Student(name: "Tom", age: 20,school: "清华大学")

let p2: Person = Worker(name: "Tom", age: 18,factory: "钢厂")

let p3: Person = Person(name: "Tom", age: 28)

这里创建了3个实例p1、p2、p3，类型都是Person。p1是Student实例，p2是Worker实例，p3是Person实例。首先，对象类型转换一定发生在继承的前提下，p1和p2都声明为Person类型，而实例是由Person子类型实例化的。

作为这段程序的编写者，我们知道p1本质上是Student实例，但是表面上看是Person类型，编译器也无法推断p1的实例是Person、Student还是Worker。我们可以使用is操作符来判断它是哪一类的实例。然后在转换时可以使用as操作符将其转换为子类类型，即把Person类型的p1转为Student子类类型，这种转换被称为向下转型。这种转换是有风险的，如果p1不是目标类型，转换就会失败。为了不发生异常，我们可以使用as?将其转换为目标类型的可选类型，能够成功则转换，不成功则返回nil。

 

p3与p1和p2有很大的不同，因为p3本质上是Person实例，不能向下转型。

下面看一个示例：

 

 
  1. let student1 = Student(name: "Tom", age: 18, school: "清华大学")  
  2.   
  3. let student2 = Student(name: "Ben", age: 28, school: "北京大学")  
  4.   
  5. let student3 = Student(name: "Tony", age: 38, school: "香港大学")  
  6.   
  7.    
  8.   
  9. let worker1 = Worker(name: "Tom", age: 18, factory: "钢厂")  
  10.   
  11. let worker2 = Worker(name: "Ben", age: 20, factory: "电厂")  
  12.   
  13.    
  14.   
  15. let people = [student1, student2, student3, worker1, worker2]  
  16.   
  17.    
  18.   
  19. for item in people {   
  20.   
  21.       
  22.   
  23.     if let student = item as? Student {     
  24.   
  25.         print("Student school: (Student.school)")   
  26.   
  27.     } else if let worker = item as? Worker {        
  28.   
  29.         print("Worker factory: (Worker.factory)")   
  30.   
  31.     }      
  32.   
  33. }  

 

使用for in遍历people数组集合。在循环体中， letstudent = item as? Student语句使用as?操作符将元素转换为Student类型。如果转换成功，则把元素赋值给Student变量，否则将nil赋值给Student变量，转换成功执行代码。

最后输出结果如下：

Student school: 清华大学

Student school: 北京大学

Student school: 香港大学

Worker factory: 钢厂

Worker factory: 电厂

 

as?操作符是在不确定是否类型转换能够成功情况下使用，如果成功转换结果是可选类型。如果我们能够确保转换一定成功，可以使用as!操作符在转换的同时进行隐式拆包。

示例代码如下：

 
  1. ...  
  2.   
  3. let people = [student1, student2, student3, worker1, worker2]  
  4.   
  5. ...  
  6.   
  7. let stud1 = people[0] as? Student    //people数组的第一个元素  
  8.   
  9. print(stud1)  
  10.   
  11. print(stud1!.name)  
  12.   
  13.    
  14.   
  15. let stud2 = people[1] as! Student    //people数组的第二个元素  
  16.   
  17. print(stud2)  
  18.   
  19. print(stud2.name)  
 
  1.   
 
  1. <span style="font-family:宋体;font-size:14px;">  
  2. </span>  

 

输出结果：

Optional(Student)

Student

代码中people数组的第一个元素，使用as?操作符转换为Student类型，转换成功为Optional(Student)，即Student可选类型。

代码中people数组的第二个元素，使用as!操作符转换为Student类型，转换成功为Student类型实例，而非Student可选类型。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/isItOk/p/5454223.html