实验2 闭包、扩展、泛型、协议
作业1（闭包、扩展、泛型）：
（1） 给定一个Dictionary数组，Dictionary包含key值name和age，用map函数返回age字符串数组;
var dic = [["name":"zhangsan","age":18],["name":"lisi","age":20]]
let str = dic.map({$0["age"]!})
print(str)
（2） 给定一个String数组，用filter函数选出能被转成Int的字符串
var arr = ["hello","Uinj","world!","3728367"]
let arr2 = arr.filter({Int($0) != nil})
print(arr2)
（3） 用reduce函数把String数组中元素连接成一个字符串，以逗号分隔
var str1 = arr.reduce("",{$0 + "," + $1})
str1.remove(at: str1.startIndex)
print(str1)
（4） 用 reduce 方法一次求出整数数组的最大值、最小值、总数和
var arr3 = [21,234,12,23,45,1]
let tp = arr3.reduce((max:arr3[0],min:arr3[0],sum:0),{
(max: max($0.max,$1),min: min($0.min,$1),$0.sum + $1)
})
print(tp)
（5） 新建一个函数数组，函数数组里面保存了不同函数类型的函数，要求从数组里找出参数为一个整数，返回值为一个整数的所有函数；
func f1() -> Int {
return 0
}
func f2() ->String{
return "hello world!"
}
func f3(sum:Int) -> Int{
return 12
}
func f4(sum:String) -> Int{
return 0
}
let funArr:[Any] = [f1,f2,f3,f4]
for(index,value) in funArr.enumerated(){
if value is (Int) -> Int{
print(index)
}
}
（6） 扩展Int，增加sqrt方法，可以计算Int的Sqrt值并返回浮点数，进行验证；
extension Int{
func sqrt() -> Double {
return Darwin.sqrt(Double(self))
}
}
print(4.sqrt())
（7） 实现一个支持泛型的函数，该函数接受任意个变量并返回最大和最小值，分别传入整数值、浮点数值、字符串进行验证。
func F <T:Comparable> (a:T...) -> String{
var max = a[0]
var min = a[0]
for item in a{
if item > max{
max = item
}else if item < min{
min = item
}
}
return "min:\(min),max:\(max)"
}
print(F(a:1,2,34,4,54,1,2,12,0))
print(F(a:"a","as","sdf","as","fgrx"))
（8） 掌握版本控制git的进阶使用
a) git reset 恢复到之前修改的版本；
b) git log 看提交记录；
c) git branch 新建分支；
d) git checkout 切换分支；
e) git branch -d 删除分支；
/*1-8掌握版本控制git的进阶使用
git reset 恢复到之前修改的版本
git log 看提交记录
git branch 新建分支
git checkout 切换分支
git branch -d 删除分支*/
作业2:（枚举、类、派生、协议）(红色字体为新增内容)
（1） 实现Person类：
a) 要求具有firstName, lastName，age，gender等存储属性,fullName计算属性；其中gender是枚举类型（male，female）；
b) 具有指定构造函数和便利构造函数；
c) 两个Person实例对象可以用==和!=进行比较；
d) Person实例可以直接用print输出；
e) Person增加run方法(方法里面直接print输出Person XXX is running;
//性别的枚举
enum Gender: Int {
case male //男性
case female //女性
case unknow //未知
//重载>操作符，方便后面排序使用
static func >(lhs: Gender, rhs: Gender) -> Bool {
return lhs.rawValue < rhs.rawValue
}
}
//人类
class Person: CustomStringConvertible {
var firstName: String //姓
var lastName: String //名
var age: Int //年龄
var gender: Gender //性别
var fullName: String { //全名
get {
return firstName + lastName
}
}
//构造方法
init(firstName: String, lastName: String, age: Int, gender: Gender) {
self.firstName = firstName
self.lastName = lastName
self.age = age
self.gender = gender
}
convenience init(firstName: String, age: Int, gender: Gender) {
self.init(firstName: firstName, lastName: "", age: age, gender: gender)
}
convenience init(firstName: String) {
self.init(firstName: firstName, age: 0, gender: Gender.unknow)
}
required convenience init() {
self.init(firstName: "")
}
//重载==
static func ==(lhs: Person, rhs: Person) -> Bool {
return lhs.fullName == rhs.fullName && lhs.age == rhs.age && lhs.gender == rhs.gender
}
//重载!=
static func !=(lhs: Person, rhs: Person) -> Bool {
return !(lhs == rhs)
}
//实现CustomStringConvertible协议中的计算属性，可以使用print直接输出对象内容
var description: String {
return "fullName: \(self.fullName), age: \(self.age), gender: \(self.gender)"
}
//输出Person XXX is running
func run() {
print("Person \(self.fullName) is running")
}
}
var p1 = Person(firstName: "张")
var p2 = Person(firstName: "张", age: 20, gender: .male)
print(p1) //输出fullName: 张, age: 0, gender: male
print(p1 == p2) //输出false
print(p1 != p2) //输出true
（2） 从Person分别派生Teacher类和Student类：
a) Teacher类增加属性title，实例可以直接用print输出；
b) Student类增加属性stuNo，实例可以直接用print输出；
c) Teacher和Student重载run方法(方法里面直接print输出Teacher XXX is running和Student XXX is running)
//教师类
class Teacher: Person, SchoolProtocol {
var title: String //标题
var department: Department //公寓
//构造方法
init(title: String, firstName: String, lastName: String, age: Int, gender: Gender, department: Department) {
self.title = title
self.department = department
super.init(firstName: firstName, lastName: lastName, age: age, gender: gender)
}
init(title: String, department: Department) {
self.title = title
self.department = department
super.init(firstName: "", lastName: "", age: 0, gender: .unknow)
}
convenience required init() {
self.init(title: "", department: Department.one)
}
//重写父类的计算属性
override var description: String {
return "title: \(self.title), fullName: \(self.fullName), age: \(self.age), gender: \(self.gender), department: \(self.department)"
}
//重载父类run方法
override func run() {
print("Teacher \(self.fullName) is running")
}
//遵循协议的方法
func lendBook() {
print("Teacher \(self.fullName) lend a book")
}
}
var t1 = Teacher(title: "hello", department: .one)
print(t1) //输出title: hello, fullName: , age: 0, gender: unknow, department: one
//定义Student类并实例化
//学生类
class Student: Person, SchoolProtocol {
var stuNo: Int //学号
var department: Department //公寓
//构造方法
init(stuNo: Int, firstName: String, lastName: String, age: Int, gender: Gender, department: Department) {
self.stuNo = stuNo
self.department = department
super.init(firstName: firstName, lastName: lastName, age: age, gender: gender)
}
init(stuNo: Int, department: Department) {
self.stuNo = stuNo
self.department = department
super.init(firstName: "", lastName: "", age: 0, gender: Gender.unknow)
}
required convenience init() {
self.init(stuNo: 0, department: .one)
}
//重写父类的计算属性
override var description: String {
return "stuNo: \(self.stuNo), fullName: \(self.fullName), age: \(self.age), gender: \(self.gender), department: \(self.department)"
}
//重载父类run方法
override func run() {
print("Student \(self.fullName) is running")
}
//遵循协议的方法
func lendBook() {
print("Teacher \(self.fullName) lend a book")
}
}
var s1 = Student(stuNo: 2015110101, department: .two)
print(s1) //输出stuNo: 2015110101, fullName: , age: 0, gender: unknow, department: two
（3） 分别构造多个Person、Teacher和Student对象，并将这些对象存入同一个数组中；
//初始化一个空的Person数组
var array = [Person]()
//生成5个Person对象
for i in 1...5 {
let temp = Person(firstName: "张", lastName: "\(i)", age: 20, gender: .male)
array.append(temp)
}
//生成3个Teacher对象
for i in 1...3 {
let temp = Teacher(title: "hello", firstName: "李", lastName: "\(i)", age: 21, gender: .female, department: .one)
array.append(temp)
}
//生成4个Student对象
for i in 1..<5 {
let temp = Student(stuNo: 2015110100 + i, firstName: "王", lastName: "\(i)", age: 19, gender: .male, department: .two)
array.append(temp)
}
（4） 新建一个协议SchoolProtocol，协议包括一个department属性(Enum，自己实现enum的定义)和lendBook方法（随便写点内容，能区隔即可）；
//公寓的枚举
enum Department {
case one, two, three
}
//学校协议
protocol SchoolProtocol {
var department: Department { get set }
func lendBook()
}
（5） 修改Teacher和Student，让这两个类实现该协议；
/*上面👆代码已经实现该协议*/
（6） 对数组执行以下要求：
a) 分别统计Person、Teacher和Student对象的个数并放入一字典中，统计完后输出字典内容；
b) 对数组按以下要求排序并输出：age、fullName、gender+age；
c) 对数组进行穷举，调用每个对象的run方法，同时调用满足协议SchoolProtocol对象的lendBook方法；
//定义一个字典，用于统计每个类的对象个数
var dict = ["Person": 0, "Teacher": 0, "Student": 0]
for item in array {
if item is Teacher { //是否是Teacher类
dict["Teacher"]! += 1
} else if item is Student { //是否是Student
dict["Student"]! += 1
} else { //Person类
dict["Person"]! += 1
}
}
//输出字典值
for (key, value) in dict {
print("\(key) has \(value) items")
}
//原始数组
print("------------------------------")
for item in array {
print(item)
}
//根据age从大到小排序
print("------------------------------")
array.sort { return $0.age > $1.age}
for item in array {
print(item)
}
//根据全名从前往后排序
print("------------------------------")
array.sort { return $0.fullName < $1.fullName}
for item in array {
print(item)
}
//根据gender和age从大往小排序
print("------------------------------")
array.sort { return ($0.gender > $1.gender) && ($0.age > $1.age) }
for item in array {
print(item)
}
//穷举，调用run方法和lendBook方法
print("------------------------------")
for item in array {
item.run()
if let teacher = item as? Teacher {
teacher.lendBook()
} else if let student = item as? Student {
student.lendBook()
}
}
