感想

在学习了swift之后，做了一次阶段测试，但是结果很不理想，在答题的过程中感觉自己的思维非常乱，对于所学的知识点在没有提示的时候完全想不起来，更别说加以运用实现了。有些知识点不是不知道，但在实际编码过程中就想不到，而且在思维方面，我的思维方式是有些问题的，不清楚在下一步要干什么，没有清晰的操作思路。总之，就是自己太缺乏独立思考的方式了，以后就加强这方面的练习，就像老师所说的要尽可能多的敲代码，运用多种方式去做各种编程案例。对于各种知识点要加深理解，搞透彻，最重要的还是要多运用。

题目一

设计一个员工类（Employee）和一个部门类（Department），
员工有编号、姓名、性别、电话和所属部门五个属性，
其中联系方式和所属部门是可空类型(Optional)，
员工有工作和休息的行为，具体的实现自由发挥不作限制；
部门有编号、名称、所有员工、部门人数三个属性，
其中所有员工是一个数组，部门人数是一个计算属性，
部门有添加员工和移除员工的行为。
由于两个类之间存在双向关联，
请采用适当的方式解决循环引用的问题来避免内存泄漏。
请自行编写main.swift文件中的代码来测试你设计的类。

1.Employee.swift(员工类)

import Foundation
 // 枚举：性别
enum Gender {
    case Male
    case Female
}

// 定义了一个员工类
class Employee {
    var id: Int        // 编号
    var name: String      // 姓名
    var gender: Gender    // 性别
    var tel: String?      // 电话（可空类型）
    // 在这儿建立了双向关联，需要添加weak来 破除循环引用
    weak var dept: Department?   // 所属部门（可空类型）
    
    init(id: Int, name: String, gender: Gender) {
        self.id = id
        self.name = name
        self.gender = gender
    }
    
    // 行为1: 工作
    func work() {
        print("工号为\(id)的\(name)正在工作.")
    }
    
    // 行为2: 休息
    func haveRest() {
        print("\(name)正在休息.")
    }
}

2.Department.swift(部门类)

import Foundation

// 定义了一个部门的类
class Department {
    var id: Int                    // 编号
    var name: String                  // 名称
    var empsArray: [Employee] = []    // 所属部门
    
    // 计算属性：部门人数
    // 因为员工是一个数组，直接返回数组长度即可
    var numberOfEmps: Int {
        get { return empsArray.count }
    }
    
    init(id: Int, name: String) {
        self.id = id
        self.name = name
    }
    
    // 添加员工的行为
    func addEmp(emp: Employee) {
        empsArray.append(emp)
    }
    
    // 删除员工的行为
    func removeEmp(id: Int) -> Bool {
        // 在员工的数组中寻找与传入的id相等的id的下标，(尾随闭包)
        // 然后赋值给index，在进行删除操作
        // 成功返回true，否则返回false
        if let index = empsArray.indexOf({ $0.id == id }) {
            empsArray.removeAtIndex(index)
            return true
        }
        return false
    }
}

题目二

设计一个构造等差数列（整数）的函数，
传入的三个参数分别是起始值、公差和元素个数，
返回一个数组，数组中的元素就是要求的等差数列。

// 传入三个参数，返回一个数组
func generateArithmeticProgression(startValue: Int, commonDifference: Int, numberOfElements: Int) -> [Int] {
    
    // 定义一个数组，长度为元素个数(numberOfElements),初始值为0
    var array = [Int](count: numberOfElements, repeatedValue: 0)
    // 利用循环输出一个等差数列的一个数组
    for i in 0..<array.count {
        array[i] = startValue + commonDifference * i
    }
    return array
}

// 函数的调用
print(generateArithmeticProgression(5, commonDifference: 3, numberOfElements: 10))

题目三

设计一个函数判断传入的整数数组中的元素能否构成等差数列。

func isProgression(array: [Int]) -> Bool {
    if array.count > 2 {
        // 对数组进行排序
        let newArray = array.sort(<)
        // 计算公差
        let commonDiff = newArray[1] - newArray[0]
        for i in 1..<newArray.count - 1 {
            // 利用循环判断相邻两个元素差是否等于公差
            if newArray[i + 1] - newArray[i] != commonDiff {
                return false
            }
        }
    }
    return true
}

题目四

设计一个生成指定长度的验证码的函数，
验证码由字母和数字构成，长度由传入的参数制定，
返回的字符串就是生成的验证码。

// 扩展：如果在某个特定的应用场景中你发现现有的类缺少某项功能
//      那么可以通过类扩展（extension）的方式现场添加这项功能
extension String {
    
    var length: UInt32 {
        get { return UInt32(self.characters.count) }
    }
    
    subscript(index: Int) -> Character {
        get { return self[self.startIndex.advancedBy(index)] }
    }
}

// 产生随机数
func randomInt(min: UInt32, _ max: UInt32) -> Int {
    return Int(arc4random_uniform(max - min + 1) + min)
}

// 利用函数返回验证码的字符串
func generateVerificationCode(length: Int) -> String {
    var code = ""
    if length > 0 {
        let str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        for _ in 0..<length {
            code.append(str[randomInt(0, str.length - 1)])
        }
    }
    return code
}

// 随记产生10个4位的验证码。
for _ in 1...10 {
    print(generateVerificationCode(4))
}

题目五

设计一个程序模拟考生找枪手代考的场景。
（提示：考生是委托方，枪手是被委托方）

1. 用代理的方法

// 此题 更适用代理的方法

// 协议： 考试答卷
protocol ExamCandidate: class {
    
    func answerTheQuestion()   // 行为：答卷
}

// 创建一个学生类，遵循ExamCandidate协议
class LazyStudent: ExamCandidate {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    // 因为学生没有参与考试的行为，所以在此处不实现（只定义了方法）
    func answerTheQuestion() {
        
    }
}

// 创建了一个枪手的类，遵循ExamCandidate协议
class Gunman: ExamCandidate {
    var name: String
    var target: LazyStudent?     // 代理对象
    
    init(name: String) {
        self.name = name
    }
    
    // 考试是枪手的行为，定义了考试的行为
    func answerTheQuestion() {
        // 是判断代理对象是否为空
        if let stu = target {
            print("\(name)正在替\(stu.name)考试。")
            print("\(name)奋笔疾书写答案")
            print("提交试卷")
        }
    }
}

let stu = LazyStudent(name: "王大锤")
let gun = Gunman(name: "张三")
gun.target = stu
gun.answerTheQuestion()

2. 用委托回调的方法

protocol ExamDelegate: class {

    func answerTheQuestion()
}
 // 创建一个学生类
class LazyStudent {
    var name: String
    // 委托方,遵循ExamDelegate协议,添加weak是为了在循环引用导致ARC无法释放内存的问题
    // 如果允许使用可空类型通常使用weak来破除循环引用
    weak var delegate: ExamDelegate?

    init(name: String) {
        self.name = name
    }
    // 定义了一个考试的方法
    func joinExam() {
        print("姓名: \(name)")
        delegate?.answerTheQuestion()
    }
}

// 创建了一个枪手的类，遵循了ExamDelegate协议
class Gunman: ExamDelegate {

    func answerTheQuestion() {
        print("奋笔疾书各种答案")
    }
}

let stu = LazyStudent(name: "王大锤")
let gun = Gunman()
stu.delegate = gun
// 在委托中这儿是学生在考试，这显然是不对的
 stu.joinExam()