IOS系列swift语言之课时七

这下需要掌握的就是类型转换，类的构造器，判断类型，异常，异常的处理，defer，范型，约束
加速刷代码

 import Foundation

 /*   类型转换
  1.利用类的构造器进行转换
  2.系统可能提供一些特定的类型专门用来进行类型转换
  3.as? 和as!

  类型判断 is 和===

  */

 //let i = 5
 //let stri = String(i)
 //
 //class A {
 //    func am(){
 //
 //    }
 //}
 //class B: A {
 //    func bm() {
 //
 //    }
 //}
 //class C {
 //
 //}
 //
 //let ins: A = B()
 //let insb = ins as? B
 //let insb2 = ins as! B
 //insb2.bm()
 //if insb == nil {
 //    print("faill")
 //}
 //
 //if let z = ins as? B {
 //
 //}
 //
 //if ins is A {
 //    print("is a ...")
 //}
 //
 //if ins is B  {
 //    print("is b")
 //}
 //
 //let ins3 = B()
 //let ins4 = B()
 //let ins5 = ins3
 //if ins3 === ins5 {
 //    print("true...")
 //}

 //实现了Error接口的类型称之为异常
 //swift 中一般用枚举类型来实现
 //enum MyEx: Error {
 //    case Blank
 //    case Length
 //}
 //func login(pwd: String) throws -> Bool {
 //
 //    if pwd.isEmpty {
 //        throw MyEx.Blank
 //    }
 //    if pwd == "abc"{
 //            return true
 //    }
 //    else {
 //        return false
 //    }
 //}
 //
 //
 //
 ////do
 ////{
 ////    //调用可能抛出异常的方法，必须加try来调用
 ////    let result = try login(pwd: "")
 ////}   catch MyEx.Blank {
 ////    print("blank....")
 ////}
 //
 //
 ////do
 ////{
 ////        let result = try login(pwd: "")
 ////}   catch {
 ////    print(error) //隐藏的异常对象
 ////}
 //
 ////第二种处理异常的方法，就是不处理，直接抛出
 //func callThrow() throws {
 //    try  login(pwd: "a")
 //}
 //
 //
 ////Void?
 ////try? 自己确定不会所调用的方法，不会抛出异常
 ////也不关心方法返回结果
 ////let result = try? callThrow()
 ////if result == nil {
 ////    print("pao")
 ////
 ////}
 ////
 //// print(result)
 //
 ////let result = try! callThrow()
 ////if result == nil {
 ////    print("pao")
 ////
 ////}
 ////
 ////print(result)
 //
 //
 ////defer是函数里面最后执行的
 ////多个defer，其执行顺序与出现的顺序相反
 ////如果方法抛出了异常，defer仍然不会执行
 //
 //func deferDemo() throws{
 //    print("before")
 //    throw MyEx.Blank
 //    defer {
 //        print("first defer")
 //    }
 //    defer {
 //        print("second defer")
 //    }
 //    print("after")
 //}
 //func deferDemo2 (){
 //    let f: FileHandle
 //    defer {
 //        f.close()
 //    }
 //}

 //开始使用这种对象的一系列方法
     //
    /**  泛型 */
 func swapInt(a: inout Int,b: inout Int ) {
     let temp = a
     a = b
     b = temp
 }
 var first =
 var second =
 swapInt(a: &first, b: &second)
 print(first)
 print(second)

 func swapString(a: inout String,b: inout String ) {
     let temp = a
     a = b
     b = temp
 }

 var firststr = "a"
 var secondStr = "b"
 swapString(a: &firststr, b: &secondStr)

 func swapData<T>(a: inout T,b: inout T)  {
     let temp = a
     a = b
     b = temp
 }

 var doublea = 5.5
 var doubleb = 6.6
 let result = swapData(a: &doublea, b: &doubleb)

 print(doublea)
 print(doubleb)

 struct IntStack {
     var container = [Int]()
    mutating func push(data: Int) {
         container.append( data)
     }

    mutating func pop() ->Int {
        return container.removeLast()
     }
 }

 var mystack = IntStack()
 mystack.push(data: )
 mystack.push(data: )
 mystack.push(data: )
 print(mystack)
 mystack.pop()
 print(mystack)

 struct Stack<T> {
     var items = [T]()

     mutating func push(data: T) {
         items.append(data)
     }

     mutating func pop()-> T {
         return items.removeLast()
     }
 }
 protocol MyC {
     var data: Int{get set}
 }
 class A:MyC {
     var data:Int =
 }
 class B:MyC {
     var data:Int =
 }
 class C {
     var data:Int =
 }
 func sumData<T: MyC>(a: T,b: T) -> Int {
     let sum = a.data + b.data
     return sum
 }
 //约束的语法：T:父类或接口
 //多个类型参数之间用逗号，比如T和U
 func sumData2<T: MyC,U:MyC>(a: T,b: U) -> Int {
     let sum = a.data + b.data
     return sum
 }
 let ains = A()
 let bins = B()
 let cins = C()

 //sumdata,因为2个参数用的是同样的T，意味
 //着，a和b必须是同样类型的实例，而不能是实现同样接口的不同类型的实例
 let result22 = sumData(a: ains, b: ains)
 print(result22)

 let result33 = sumData2(a: ains, b: bins)
 print(result33)

 //下面因为c没有实现接口，所以不能调用
 //let result44 = sumData2(a: cins, b: cins)
 //print(result44)

 //利用assocatedType来实现泛型接口的样子
 protocol Containter {
     associatedtype XXXX //关联类型
     func append(data: XXXX)

 }

 struct MyContainer<T>: Containter {
     //typealias XXXX = T
     func append(data: T) {

     }

 }
 /*
  接口中的associatedType有两种作用
  一种是当成泛型接口的用，比如上面的例子

  还有一种用途，只是在接口中声明一个类型而已
  在其实现类中，通过typealias把其真正关联中
  某一个具体的类型
  */
 struct AAA: Containter {
    // typealias XXXX = Int
     func append(data: Int) {

     }

 }

 //泛型接口与类的扩展
 extension Stack {
     func count() -> Int {
         return items.count
     }
 }