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: 5, name: "555")
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