IOS系列swift语言之课时六

这节课需要讲的就是协议，方法，委托模式(依赖倒转)

代码刷起中......

 //
 //  main.swift
 //  ExAndProtocol
 //
 //  Created by David on 23/11/2016.
 //  Copyright © 2016 DavidIOS. All rights reserved.
 //
 
 import Foundation
 //extension Double   {
 //    var km: Double {
 //        return self * 1000
 //    }
 //}
 //
 //let d: Double = 5
 //print(d.km)
 
 /* 协议中属性的说明
  1.只指定属性的名字与类型，不指定是否是存储与计算属性
  2.只能在协议中用static修饰静态属性。但在实现类型可以用class 也可以用static
  3.只读属性 var a: Int {get}
  4.读写属性var b: Int {get set}
  5.协议中的属性总是用var声明的 , 但是在实现时可以实现为let
 
  方法的说明
  1.不需要大括号
  2.支持可变长度参数
  3.默认值不能在协议中指明
  4.静态方法也用static修饰（在协议中）
  5.协议中得方法可以添加mutating，在类中得实现中，可以不需要mutating，在值类型
  中得实现中就必须加mutating
 
  */
 
 protocol User {
     func getName() -> String
     var p: Int {get}
     var p2: Int {get set}
 }
 //class UserInfo: User {
 //     func getName() -> String {
 //        return "xxx"
 //    }
 //
 //
 //}
 
 //let u: User = UserInfo()
 
 //protocol A {
 //    var p: Int {get set}
 //}
 //
 //protocol B {
 //    var p2: Int {get set}
 //}
 //
 //class ABImpl : A,B {
 //
 //    var p: Int  = 0
 //    var p2: Int {
 //        get{
 //            return p
 //        }
 //        set{
 //            p = newValue
 //        }
 //    }
 //
 //}
 //func test(a: A & B)  {
 //    print(a.p)
 //}
 //test(a: ABImpl())
 
 protocol TableDelegate {
     func generateHeader() -> String
     func generateRow() -> String
 }
 
 class OneRowAndColumn: TableDelegate {
     func generateHeader() -> String {
         let header = "<tr><td>名字</td></tr>"
         return header
     }
 
     func generateRow() -> String {
         let row = "<tr><td>xxx</td></tr><tr><td>yyyy</td></tr>"
         return row
     }
 }
 
 class TwoRowAndColumn: TableDelegate {
     func generateHeader() -> String {
         let header = "<tr><td>id</td><td>名字</td></tr>"
         return header
     }
 
     func generateRow() -> String {
         let row = "<tr><td>1</td><td>xxx</td></tr><tr><td>2</td><td>yyyy</td></tr>"
         return row
     }
 }
 class Table {
     let delegate: TableDelegate
     init(delegate: TableDelegate) {
         self.delegate = delegate
     }
     func generateTable() -> String {
         let str = "<table>" + delegate.generateHeader() + delegate.generateRow() + "</table>"
         return str
     }
 
 }
 //let firstDelegate = TwoRowAndColumn()
 //let secondDelegate = OneRowAndColumn()
 //let table = Table(delegate: secondDelegate)
 //print(table.generateTable())
 
 struct UserBean  {
     let id: Int
     let name: String
 }
 
 protocol UserDaoInf { //女朋友标准
     func insert(userInfo: UserBean) -> Bool //标准1
 }
 class UserDao: UserDaoInf{ //满足女朋友标准的一类人
     func insert(userInfo : UserBean) -> Bool {
         print("inserting......")
         print(userInfo.id)
         return true
     }
 }
 
 class UserService {
     let dao: UserDaoInf
     init (dao: UserDaoInf)  { //找到女朋友
         self.dao = dao
     }
     func insert(userInfo: UserBean) -> Bool {
         return dao.insert(userInfo: userInfo)
     }
 }
 let userbean = UserBean(id: , name: "")
 let userdao: UserDaoInf = UserDao()
 let userService =  UserService(dao: userdao)
 userService.insert(userInfo: userbean)
 
 /*
  所谓委托模式（依赖倒转）
  1.创建一个接口
  2.创建一个类型实现接口
  3.有一个类，里面很可能是一个属性，其类型为第一步
  的接口，属性名一般为delegate
 
  */
 
 protocol AA {
     func m()
 }
 
 class A : AA {
     func m() {
 
     }
 }
 class B: AA  {
     func m() {
 
     }
 }
 
 extension AA {
     func n() {
 
     }
 }
 
 let a = A()
 let b = B()
 b