Swift-----类型转换 、 嵌套类型 、 扩展 、 协议 、 访问控制

 

1 使用is和as操作符判断和转换数组中的对象类型

1.1 问题

类型转换可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。在Swift中使用is和as操作符实现类型转换。

本案例定义一个媒体类MediaItem，它有两个子类Movie和Song，创建一个存放Movie实例和Song实例的媒体数组library，使用is和as操作符判断和转化library数组中的实例类型。

1.2 方案

使用类型检查操作符is来检查一个实例是否属于特定子类型，如果属于该子类型操作符返回true，否则返回false。

某类型的一个常量或变量可能实际上属于某一个子类，使用类型转换操作符as可以将其转换成子类型。转换过程可能会失败，因此类型转换操作符有两种不同的形式，可选形式as?和强制形式as。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义MediaItem类

首先定义一个MediaItem媒体类，包含一个String类型的name属性，和一个init构造方法，代码如下所示：

 

1. //媒体类
2. class MediaItem {
3. var name : String
4. init(name:String){
5. self.name = name
6. }
7. }

然后定义MediaItem的两个子类，第一个子类Movie在父类的基础上增加一个director属性，和相应的构造方法。第二个子类Song，在父类的基础上增加了一个artist属性，和相应的构造方法，代码如下所示：

 

1. //电影类
2. class Movie : MediaItem {
3. var director : String
4. init(name: String, director:String){
5. self.director = director
6. super.init(name: name)
7. }
8. }
9. //歌曲类
10. class Song: MediaItem {
11. var airtist : String
12. init(name: String, airtist: String) {
13. self.airtist = airtist
14. super.init(name: name)
15. }
16. }

最后一个创建一个数组常量library，包含两个Movie实例和三个Song实例，library的类型是在它被初始化时根据它数组中包含的内容推断来的，Swift的类型检测能够推断出Movie和Song有共同的父类MediaItem，所以推断出library的类型是MediaItem[]，从library中取出的也是MediaItem类型，代码如下所示：

 

1. //媒体数组
2. let library /*: [MediaItem]*/ = [
3. Movie(name: "星际穿越", director: "Daniel"),
4. Song(name: "小苹果", airtist: "筷子兄弟"),
5. Movie(name: "Breaking Bad", director: "Guodh"),
6. Song(name: "最炫民族风", airtist: "凤凰传奇"),
7. Song(name: "菊花台", airtist: "Jay")
8. ]

步骤二：检测类型

定义两个变量movieCount和songCount，用来计算数组library中Movie和Song类型的实例数量。

遍历数组library中的每一个实例，使用is操作符判断类型，代码如下所示：

 

1. //电影多少部？歌曲多少首
2. var movieCount = 0
3. var songCount = 0
4. //is用于判断引用指向的对象是否是指定类型
5. for item in library {
6. if item is Movie {
7. movieCount++
8. }else if item is Song {
9. songCount++
10. }
11. }
12. movieCount
13. songCount

运行结果如图-1所示：

图-1

步骤三：转换类型

遍历library里的每一个MediaItem实例，并打印出适当的描述，item需要真正作为Movie或Song的类型来使用，这是需要使用as操作符进行类型转换，代码如下所示：

 

1. //遍历每个媒体，并打印详细信息
2. for item in library {
3. if item is Movie {
4. //as用于强制装换，能转就转，不能转的话程序直接崩溃
5. let movie = item as! Movie
6. println("电影名:(movie.name),导演:(movie.director)")
7. }else if item is Song {
8. let song = item as! Song
9. println("歌曲名:(song.name), 演唱者:(song.airtist)")
10. }
11. }

但是数组中的每一个item可能是Movie或Song，所以这里使用可选类型的转换符更合适，代码如下所示：

 

1. for item in library {
2. //as?与as功能相同，能转就转，不能转返回nil，程序不会崩溃，返回的是一个可选值
3. if let movie = item as? Movie {
4. println("电影名:(movie.name),导演:(movie.director)")
5. } else if let song = item as? Song {
6. println("歌曲名:(song.name), 演唱者:(song.airtist)")
7. }
8. }

1.4 完整代码

本案例中，完整代码如下所示：

 

1. import UIKit
2. //媒体类
3. class MediaItem {
4. var name : String
5. init(name:String){
6. self.name = name
7. }
8. }
9. //电影类
10. class Movie : MediaItem {
11. var director : String
12. init(name: String, director:String){
13. self.director = director
14. super.init(name: name)
15. }
16. }
17. //歌曲类
18. class Song: MediaItem {
19. var airtist : String
20. init(name: String, airtist: String) {
21. self.airtist = airtist
22. super.init(name: name)
23. }
24. }
25. //媒体数组
26. let library /*: [MediaItem]*/ = [
27. Movie(name: "星际穿越", director: "Daniel"),
28. Song(name: "小苹果", airtist: "筷子兄弟"),
29. Movie(name: "Breaking Bad", director: "Guodh"),
30. Song(name: "最炫民族风", airtist: "凤凰传奇"),
31. Song(name: "菊花台", airtist: "Jay")
32. ]
34. //电影多少部？歌曲多少首
35. var movieCount = 0
36. var songCount = 0
37. //is用于判断引用指向的对象是否是指定类型
38. for item in library {
39. if item is Movie {
40. movieCount++
41. }else if item is Song {
42. songCount++
43. }
44. }
45. movieCount
46. songCount
48. //遍历每个媒体，并打印详细信息
49. for item in library {
50. if item is Movie {
51. //as用于强制装换，能转就转，不能转的话程序直接崩溃
52. let movie = item as! Movie
53. println("电影名:(movie.name),导演:(movie.director)")
54. }else if item is Song {
55. let song = item as! Song
56. println("歌曲名:(song.name), 演唱者:(song.airtist)")
57. }
58. }
60. for item in library {
61. //as?与as功能相同，能转就转，不能转返回nil，程序不会崩溃，返回的是一个可选值
62. if let movie = item as? Movie {
63. println("电影名:(movie.name),导演:(movie.director)")
64. } else if let song = item as? Song {
65. println("歌曲名:(song.name), 演唱者:(song.airtist)")
66. }
67. }

2 扩展的使用

2.1 问题

扩展就是向一个已有的类、结构体或枚举添加新功能，和OC的分类类似。本案例演示Swift中扩展的用法，包括在扩展中添加计算属性、构造方法。实例方法和类型方法等。

2.2 方案

Swift中的扩展可以向已有的类型添加计算型实例属性和计算型类型属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器。

扩展还可以向已有的类型添加新的构造器，新构造器有责任保证构造过程能够让所有属性全都初始化。对于类而言扩展只能添加新的便利构造器，不能添加新的指定构造器和析构方法，指定构造器和析构方法必须总是由原始的类提供。

扩展可以向已有类型添加新的实例方法和类型方法。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：添加计算型属性

下面这个例子向已有的类型添加计算型属性，向Swift中的Double类型添加五个计算型实例属性，从而提供对距离单位的支持，这些属性都是可以通过点语法来访问。

这些属性表达的含义是把一个Double类型的值看做是某单位下的长度值，1.0用来表示一米单位为m，其他单位则需要一些转换来表示在米下测量的值，km表示千米，ft表示英尺，cm表示厘米，mm表示毫米。

这些属性都是只读的计算属性，所以可以省略get关键字，返回类型都是Double类型，代码如下所示：

1. extension Double {
2. var km:Double {
3. return self*1000
4. }
5. var m:Double {
6. return self
7. }
8. var cm:Double {
9. return self/100
10. }
11. var mm:Double {
12. return self/1000
13. }
14. var ft:Double {
15. return self/3.28084
16. }
17. }
18. let oneIch = 25.4.mm
19. let threeFeet = 3.ft

运行结果如图-2所示：

图-2

步骤二：添加构造方法

定义一个用于描述几何矩形的定制结构体Rect，这个例子同时定义了两个辅助结构体Size和Point，0.0作为所有属性的默认值，代码如下所示：

 

1. struct Point {
2. var x = 0.0
3. var y = 0.0
4. }
5. struct Size {
6. var width = 0.0
7. var height = 0.0
8. }
9. struct Rect {
10. var origin = Point()
11. var size = Size()
12. }

再使用扩展提供一个额外的构造器，可以使用中心点来进行构造，代码如下所示：

 

1. extension Rect {
2. init(center:Point,size:Size) {
3. var originX = center.x - size.width/2
4. var originY = center.y - size.height/2
5. self.origin = Point(x: originX, y: originY)
6. self.size = size
7. }
8. }
9. var rect = Rect(center: Point(x: 20, y: 10), size: Size(width: 10, height: 10))

运行结果如图-3所示：

图-3

步骤三：添加方法

向Int类型添加一个名为repetitions的新的实例方法，代码如下所示：

 

1. extension Int {
2. func repetition(task:()->()) {
3. for i in 0...self {
4. task()
5. }
6. }
7. }
8. var i = 3
9. i.repetition({println("hehe")})

运行结果如图-4所示：

图-4

2.4 完整代码

本案例中，完整代码如下所示：

 

1. import UIKit
2. //扩展计算属性
3. extension Double {
4. var km:Double {
5. return self*1000
6. }
7. var m:Double {
8. return self
9. }
10. var cm:Double {
11. return self/100
12. }
13. var mm:Double {
14. return self/1000
15. }
16. var ft:Double {
17. return self/3.28084
18. }
19. }
21. let oneIch = 25.4.mm
22. let threeFeet = 3.ft
23. //扩展构造器
24. struct Point {
25. var x = 0.0
26. var y = 0.0
27. }
28. struct Size {
29. var width = 0.0
30. var height = 0.0
31. }
32. struct Rect {
33. var origin = Point()
34. var size = Size()
35. }
37. extension Rect {
38. init(center:Point,size:Size) {
39. var originX = center.x - size.width/2
40. var originY = center.y - size.height/2
41. self.origin = Point(x: originX, y: originY)
42. self.size = size
43. }
44. }
45. var rect = Rect(center: Point(x: 20, y: 10), size: Size(width: 10, height: 10))
47. //扩展方法
48. extension Int {
49. func repetition(task:()->()) {
50. for i in 0...self {
51. task()
52. }
53. }
54. }
55. var i = 3
56. repetition({println("hehe")})

3 计时器

3.1 问题

本案例学习使用Swift语言使用纯代码的方式实现第一个Swift项目——一个简单的计时器，如图-5，图-6所示：

图-5

图-6

3.2 方案

首先使用Xcode创建一个SingleViewApplication项目，编程语言选择Swift，可以看到Xcode已经提供的项目代码全都换成Swift语言实现，如图-7所示：

图-7

本案例采用纯代码的方式实现所以删除Storyboard，将程序的MainInterface清空，在程序的启动方法中，采用手写代码的方式创建的window，如图-8所示：

图-8

接下来使用代码搭建计时器项目的界面，界面上方是一个现实倒计时的Label控件，下方是一排预设的时间按钮，最下方是启动和复位按钮。

扩展可以向已有类型添加新的实例方法和类型方法。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：创建window对象和根视图控制器

首先在AppDeleagte类中程序加载完成的方法中创建一个和屏幕大小一样的window对象，并将window的背景颜色设置为白色，代码如下所示：

 

1. func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
2. // Override point for customization after application launch.
3. self.window = UIWindow(frame: UIScreen.mainScreen().bounds)
4. //可选链，设置背景颜色
5. self.window?.backgroundColor = UIColor.whiteColor()
6. self.window?.makeKeyAndVisible()
7. return true
8. }

然后创建window的根视图控制器，根视图控制器是ViewController类型，Swift项目中不需要导入头文件就可以使用项目中定义好的ViewController类，代码如下所示：

 

1. func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
2. // Override point for customization after application launch.
3. self.window = UIWindow(frame: UIScreen.mainScreen().bounds)
4. //可选链，设置背景颜色
5. self.window?.backgroundColor = UIColor.whiteColor()
6. //创建根视图控制器
7. self.window?.rootViewController = ViewController()
8. self.window?.makeKeyAndVisible()
9. return true
10. }

由上面的代码可以看出OC语言提供的类和方法完全可以在Swift中使用，只是换成Swift的语法而已，IOS程序的运行原理和开发思想与之前所学完全一致。

步骤二：搭建界面

计时器的界面上方是一个现实倒计时的Label控件，下方是一排预设的时间按钮，最下方是启动和复位按钮，首先将这些控件全都设置为ViewController的存储属性，在viewDidLoad方法中进行初始状态的设置，布局代码写在viewDidLayoutSubviews方法中，代码如下所示：

 

1. class ViewController: UIViewController {
2. var timeLabel:UILabel!
3. var timeButtons:[UIButton]!
4. var startButton:UIButton!
5. var resetButton:UIButton!
7. func setupTimeLabel(){
8. timeLabel = UILabel()
9. timeLabel.textColor = UIColor.whiteColor()
10. timeLabel.font = UIFont.boldSystemFontOfSize(80)
11. timeLabel.backgroundColor = UIColor.blackColor()
12. timeLabel.textAlignment = NSTextAlignment.Center
13. view.addSubview(timeLabel)
14. }
15. //预设时间按钮的信息
16. let timeButtonsInfo = [("1min",60),("3min",180),("5min",300),("sec",1)]
17. func setupTimeButtons(){
18. timeButtons = []
19. for (title,sec) in timeButtonsInfo {
20. let button = UIButton()
21. button.backgroundColor = UIColor.orangeColor()
22. button.setTitle(title, forState:UIControlState.Normal)
23. button.setTitleColor(UIColor.whiteColor(), forState: UIControlState.Normal)
24. button.setTitleColor(UIColor.blackColor(), forState: UIControlState.Highlighted)
25. //记录对应的时间给tag
26. button.tag = sec
27. view.addSubview(button)
28. timeButtons.append(button)
30. }
31. }
32. func timeButtonTapped (button:UIButton){
33. remainingSeconds = button.tag
34. }
36. //设置启动，复位按钮
37. func setupActionButtons() {
38. startButton = UIButton()
39. startButton.backgroundColor = UIColor.redColor()
40. startButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
41. startButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
42. startButton.setTitle("Start", forState: .Normal)
43. view.addSubview(startButton)
45. resetButton = UIButton()
46. resetButton.backgroundColor = UIColor.redColor()
47. resetButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
48. resetButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
49. resetButton.setTitle("Reset", forState: .Normal)
50. view.addSubview(resetButton)
52. }
53. override func viewDidLoad() {
54. super.viewDidLoad()
55. setupTimeLabel()
56. setupTimeButtons()
57. setupActionButtons()
58. }
59. //布局代码
60. override func viewDidLayoutSubviews() {
61. //时间窗口的布局
62. timeLabel.frame = CGRect(x: 10, y: 40, width: view.bounds.size.width-20, height: 120)
64. //时间按钮的布局：按钮大小:64x44，按钮之间的间隔
65. let cnt = timeButtons.count - 1
66. let width = view.bounds.width - 10*2.0 - CGFloat(timeButtons.count) * 64.0
67. let gap = width / CGFloat(cnt)
68. for (index, button) in enumerate(timeButtons) {
69. let buttonLeft = 10.0 + CGFloat(index) * (64.0 + gap)
70. button.frame = CGRectMake(CGFloat(buttonLeft), view.bounds.height-120.0, 64, 44)
71. }
72. //启动复位按钮的布局
73. startButton.frame = CGRectMake(10, view.bounds.height - 60, view.bounds.width - 20 - 100, 44)
74. resetButton.frame = CGRectMake(10 + startButton.frame.width+20, view.bounds.height - 60, 80, 44)
75. }
76. }

运行程序完成的界面如图-9所示：

图-9

步骤三：实现计时功能

首先设置一个记录当前剩余秒数的属性remainingSeconds，该属性是一个整型的计算属性，当remainingSeconds的值发生改变就更新timeLabel的显示内容，因此给该属性添加一个属性监视器，通过newValue计算出timeLabel显示的内容，代码如下所示：

 

1. //计算剩余时间
2. var remainingSeconds:Int = 0 {
3. //属性监视器
4. willSet {
5. let min = newValue/60
6. let sec = newValue%60
7. timeLabel.text = String(NSString(format: "%02d:%02d", min,sec))
8. }
9. }

其次给预设时间按钮添加点击事件timeButtonTapped:，该方法将用户选择的时间秒数赋值给remainingSeconds，代码如下所示：

 

1. //预设时间按钮的信息
2. let timeButtonsInfo = [("1min",60),("3min",180),("5min",300),("sec",1)]
3. func setupTimeButtons(){
4. timeButtons = []
5. for (title,sec) in timeButtonsInfo {
6. let button = UIButton()
7. button.backgroundColor = UIColor.orangeColor()
8. button.setTitle(title, forState:UIControlState.Normal)
9. button.setTitleColor(UIColor.whiteColor(), forState: UIControlState.Normal)
10. button.setTitleColor(UIColor.blackColor(), forState: UIControlState.Highlighted)
11. //记录对应的时间给tag
12. button.tag = sec
13. //给按钮添加点击事件
14. button.addTarget(self, action: Selector("timeButtonTapped:"), forControlEvents: UIControlEvents.TouchUpInside)
15. view.addSubview(button)
16. timeButtons.append(button)
18. }
19. }
20. func timeButtonTapped (button:UIButton){
21. remainingSeconds += button.tag
22. }

然后给启动和复位按钮添加点击事件startButtonTapped:和resetButtonTapped:，代码如下所示：

 

1. //设置启动，复位按钮
2. func setupActionButtons() {
3. startButton = UIButton()
4. startButton.backgroundColor = UIColor.redColor()
5. startButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
6. startButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
7. startButton.setTitle("Start", forState: .Normal)
8. view.addSubview(startButton)
9. //添加事件
10. startButton.addTarget(self, action: "startButtonTapped:", forControlEvents: .TouchUpInside)
12. resetButton = UIButton()
13. resetButton.backgroundColor = UIColor.redColor()
14. resetButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
15. resetButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
16. resetButton.setTitle("Reset", forState: .Normal)
17. view.addSubview(resetButton)
19. resetButton.addTarget(self, action: "resetButtonTapped:", forControlEvents: .TouchUpInside)
20. }

接下来需要实现startButtonTapped:和resetButtonTapped:方法，当点击启动按钮时计时器开始计时，因此需要开启一个timer。

在实现startButtonTapped:和resetButtonTapped:方法之前需要在ViewController类中定义一个NSTimer类型的存储属性timer，以及一个用于记录当前计时状态的Bool类型的计算属性isCounting，并带有一个属性监视器。当isCounting属性值为true则表示当前处于计时状态，对timer进行初始化并开始计时，当isCounting属性值为false则表示当前停止计时，timer停止计时并清空，代码如下所示：

 

1. //计时器计算属性
2. var timer:NSTimer?
3. var isCounting:Bool = false {
4. //添加属性监视器，当计时开始创建timer否则停止
5. willSet {
6. if newValue {
7. timer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("updateTimer:"), userInfo: nil, repeats: true)
8. }else {
9. timer?.invalidate()
10. timer = nil
11. }
12. setSettingButtonsEnabled(!newValue)
13. }
14. }
15. //计时方法每一秒调用改变timeLable的显示，直到计时结束
16. func updateTimer(timer:NSTimer){
17. remainingSeconds--
18. if remainingSeconds<=0 {
19. isCounting = false
20. var alertVC = UIAlertController(title: "时间到", message: "", preferredStyle:.Alert)
21. let action = UIAlertAction(title: "确定", style: UIAlertActionStyle.Default, handler: { (action) -> Void in
22. println("被按了")
23. })
24. alertVC.addAction(action)
25. self.presentViewController(alertVC, animated: true, completion: nil)
26. }
27. }
28. //打开或关闭设置时间的按钮
29. func setSettingButtonsEnabled(enable:Bool) {
30. for button in timeButtons {
31. button.enabled = enable
32. button.alpha = enable ?1.0 : 0.3
33. }
34. resetButton.enabled = enable
35. resetButton.alpha = enable ?1.0 : 0.3
36. let title = enable ? "启动" : "停止"
37. startButton.setTitle(title, forState: .Normal)
38. }

此时再实现startButtonTapped:和resetButtonTapped:方法，代码如下所示：

 

1. func startButtonTapped(button:UIButton){
2. isCounting = !isCounting
3. }
4. func resetButtonTapped(){
5. remainingSeconds = 0
6. }

步骤四：后台计时，推送消息

IOS8对程序的后台运行有很好的支持，当计时器退到后台，不用做任何操作就会自动后台计时，但是当计时完成用户并不知道计时已经完成，所以这个时候就需要使用IOS系统提供的本地消息推送功能，首先需要在程序加载成功的方法中请求用户同意接受消息推送，代码如下所示：

 

1. func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
2. // Override point for customization after application launch.
3. self.window = UIWindow(frame: UIScreen.mainScreen().bounds)
4. //可选链，设置背景颜色
5. self.window?.backgroundColor = UIColor.whiteColor()
6. self.window?.rootViewController = ViewController()
7. self.window?.makeKeyAndVisible()
8. //请求用户获取消息推送权限
9. let settings = UIUserNotificationSettings(forTypes: UIUserNotificationType.Alert | UIUserNotificationType.Sound | UIUserNotificationType.Badge,categories: nil)
10. application.registerUserNotificationSettings(settings)
11. return true
12. }

其次从计时开始就添加消息推送，当计时完成时推送消息，代码如下所示：

 

1. func startButtonTapped(button:UIButton){
2. isCounting = !isCounting
3. if isCounting {
4. //添加消息推送
5. createAndFireLocalNotificationAfterSeconds(Double(remainingSeconds))
6. }else {
7. //计时结束退出消息推送
8. UIApplication.sharedApplication().cancelAllLocalNotifications()
9. }
10. }
11. //添加消息推送方法
12. func createAndFireLocalNotificationAfterSeconds(seconds:NSTimeInterval) {
13. UIApplication.sharedApplication().cancelAllLocalNotifications()
14. let notification = UILocalNotification()
15. //推送时间
16. notification.fireDate = NSDate(timeIntervalSinceNow: seconds)
17. //推送时区
18. notification.timeZone = NSTimeZone.systemTimeZone()
19. //推送通知的内容
20. notification.alertBody = "Time is up!"
21. UIApplication.sharedApplication().scheduleLocalNotification(notification)
22. }

运行程序消息推送效果如图-10所示：

图-10

3.4 完整代码

本案例中，AppDelegate.swift文件中完整代码如下所示：

 

1. import UIKit
2. @UIApplicationMain
3. class AppDelegate: UIResponder, UIApplicationDelegate {
4. var window: UIWindow?
5. func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
6. // Override point for customization after application launch.
7. self.window = UIWindow(frame: UIScreen.mainScreen().bounds)
8. //可选链，设置背景颜色
9. self.window?.backgroundColor = UIColor.whiteColor()
10. self.window?.rootViewController = ViewController()
11. self.window?.makeKeyAndVisible()
12. //请求用户获取消息推送权限
13. let settings = UIUserNotificationSettings(forTypes: UIUserNotificationType.Alert | UIUserNotificationType.Sound | UIUserNotificationType.Badge,categories: nil)
14. application.registerUserNotificationSettings(settings)
15. return true
16. }
17. }

本案例中，ViewController.swift文件中完整代码如下所示：

 

1. import UIKit
3. class ViewController: UIViewController {
4. var timeLabel:UILabel!
5. var timeButtons:[UIButton]!
6. var startButton:UIButton!
7. var resetButton:UIButton!
9. //计算剩余时间
10. var remainingSeconds:Int = 0 {
11. //属性监视器
12. willSet {
13. let min = newValue/60
14. let sec = newValue%60
15. timeLabel.text = String(NSString(format: "%02d:%02d", min,sec))
16. }
17. }
18. //计时器计算属性
19. var timer:NSTimer?
20. var isCounting:Bool = false {
21. //添加属性监视器，当计时开始创建timer否则停止
22. willSet {
23. if newValue {
24. timer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("updateTimer:"), userInfo: nil, repeats: true)
25. }else {
26. timer?.invalidate()
27. timer = nil
28. }
29. setSettingButtonsEnabled(!newValue)
30. }
32. }
33. //计时方法每一秒调用改变timeLable的显示，直到计时结束
34. func updateTimer(timer:NSTimer){
35. remainingSeconds--
36. if remainingSeconds<=0 {
37. isCounting = false
38. var alertVC = UIAlertController(title: "time is up", message: "", preferredStyle:.Alert)
39. let action = UIAlertAction(title: "Done", style: UIAlertActionStyle.Default, handler: { (action) -> Void in
40. println("被按了")
41. })
42. alertVC.addAction(action)
43. self.presentViewController(alertVC, animated: true, completion: nil)
44. }
45. }
46. //打开或关闭设置时间的按钮
47. func setSettingButtonsEnabled(enable:Bool) {
48. for button in timeButtons {
49. button.enabled = enable
50. button.alpha = enable ?1.0 : 0.3
51. }
52. resetButton.enabled = enable
53. resetButton.alpha = enable ?1.0 : 0.3
54. let title = enable ? "Start" : "Stop"
55. startButton.setTitle(title, forState: .Normal)
56. }
58. func setupTimeLabel(){
59. timeLabel = UILabel()
60. timeLabel.textColor = UIColor.whiteColor()
61. timeLabel.font = UIFont.boldSystemFontOfSize(80)
62. timeLabel.backgroundColor = UIColor.blackColor()
63. timeLabel.textAlignment = NSTextAlignment.Center
64. view.addSubview(timeLabel)
65. }
66. //预设时间按钮的信息
67. let timeButtonsInfo = [("1min",60),("3min",180),("5min",300),("sec",1)]
68. func setupTimeButtons(){
69. timeButtons = []
70. for (title,sec) in timeButtonsInfo {
71. let button = UIButton()
72. button.backgroundColor = UIColor.orangeColor()
73. button.setTitle(title, forState:UIControlState.Normal)
74. button.setTitleColor(UIColor.whiteColor(), forState: UIControlState.Normal)
75. button.setTitleColor(UIColor.blackColor(), forState: UIControlState.Highlighted)
76. //记录对应的时间给tag
77. button.tag = sec
78. //给按钮添加点击事件
79. button.addTarget(self, action: Selector("timeButtonTapped:"), forControlEvents: UIControlEvents.TouchUpInside)
80. view.addSubview(button)
81. timeButtons.append(button)
83. }
84. }
85. func timeButtonTapped (button:UIButton){
86. remainingSeconds += button.tag
87. }
89. //设置启动，复位按钮
90. func setupActionButtons() {
91. startButton = UIButton()
92. startButton.backgroundColor = UIColor.redColor()
93. startButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
94. startButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
95. startButton.setTitle("Start", forState: .Normal)
96. view.addSubview(startButton)
97. //添加事件
98. startButton.addTarget(self, action: "startButtonTapped:", forControlEvents: .TouchUpInside)
100. resetButton = UIButton()
101. resetButton.backgroundColor = UIColor.redColor()
102. resetButton.setTitleColor(UIColor.whiteColor(), forState: .Normal)
103. resetButton.setTitleColor(UIColor.blackColor(), forState: .Highlighted)
104. resetButton.setTitle("Reset", forState: .Normal)
105. view.addSubview(resetButton)
106. resetButton.addTarget(self, action: "resetButtonTapped:", forControlEvents: .TouchUpInside)
107. }
109. func startButtonTapped(button:UIButton){
110. isCounting = !isCounting
111. if isCounting {
112. //添加消息推送
113. createAndFireLocalNotificationAfterSeconds(Double(remainingSeconds))
114. }else {
115. //计时结束退出消息推送
116. UIApplication.sharedApplication().cancelAllLocalNotifications()
117. }
118. }
119. func resetButtonTapped(button:UIButton){
120. remainingSeconds = 0
121. }
122. //添加消息推送方法
123. func createAndFireLocalNotificationAfterSeconds(seconds:NSTimeInterval) {
124. //取消之前所有的消息推送
125. UIApplication.sharedApplication().cancelAllLocalNotifications()
126. let notification = UILocalNotification()
127. //推送时间
128. notification.fireDate = NSDate(timeIntervalSinceNow: seconds)
129. //推送时区
130. notification.timeZone = NSTimeZone.systemTimeZone()
131. //推送通知的内容
132. notification.alertBody = "Time is up!"
133. UIApplication.sharedApplication().scheduleLocalNotification(notification)
134. }
135. override func viewDidLoad() {
136. super.viewDidLoad()
137. setupTimeLabel()
138. setupTimeButtons()
139. setupActionButtons()
141. }
142. //布局代码
143. override func viewDidLayoutSubviews() {
144. //时间窗口的布局
145. timeLabel.frame = CGRect(x: 10, y: 40, width: view.bounds.size.width-20, height: 120)
147. //时间按钮的布局：按钮大小:64x44，按钮之间的间隔
148. let cnt = timeButtons.count - 1
149. let width = view.bounds.width - 10*2.0 - CGFloat(timeButtons.count) * 64.0
150. let gap = width / CGFloat(cnt)
151. for (index, button) in enumerate(timeButtons) {
152. let buttonLeft = 10.0 + CGFloat(index) * (64.0 + gap)
153. button.frame = CGRectMake(CGFloat(buttonLeft), view.bounds.height-120.0, 64, 44)
154. }
155. //启动复位按钮的布局
156. startButton.frame = CGRectMake(10, view.bounds.height - 60, view.bounds.width - 20 - 100, 44)
157. resetButton.frame = CGRectMake(10 + startButton.frame.width+20, view.bounds.height - 60, 80, 44)
158. }
159. }