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. }
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hytx/p/5053772.html