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 = 5
var second = 6
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: 1)
mystack.push(data: 2)
mystack.push(data: 3)
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 = 100
}
class B:MyC {
    var data:Int = 200
}
class C {
    var data:Int = 300
}
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
    }
}