博客> Swift 基础:
Swift 基础:
2017-05-22 20:36 评论:0 阅读:336 alanzengficent
swift 基础知识

优点:1.Swift保留了C与OC的优点,并抛弃了其为兼容C所受到的限制。 2.吸纳了安全编程模式,新增了现代化功能,更容易使用,灵活。 3.与Cocoa、Cocoa touch相结合,其内存管理使用ARC 属性是. 方法带括号 2.2.1.使用Xcode project编写第一个swift 3.2.2 使用Playground创建,便写边运行

let MAXHeight = 10//let声明常量 var acc = "hellow"//var声明变量 var currentPageIndex = 0 常量不能被赋值 运算符和C++ 是一样的

int i = 0定义是错误的只能用var if !(currentPageIndex]] > 10) && 100]] > 10{ println("true") } 判断语句可以不加括号

var s = currentPageIndex>10 ? "优秀" : “良好” 最好加括号,如果 > 号前空格的话编译错误(可能被后期版本修复)

定义变量不指定数据类型 var a1 = 10 var a2 = 2 自动推导 制定数据类型 var i :Int = 10 建议

可以由封号结尾(两条语句同一行中间必须加封号) var i :Int = 10;var i2:Int = 20

注释// / /

数据类型 整形 32位机器 Int与Int32宽度一致 UInt与UInt32 浮点型 float 32 double 64 var i :Float = 10;var i2:Float = 20 数字型

let decimalInteger = 17 let binaryInteger = 0b10001 二进制 let octalInteger = 0o21 8进制 let hexadecimalInteger = 0x11 16进制

布尔类型

let isLogin = false let isUp = true

类型转换

let twoThousand:UInt16 = 2000 let one:UInt8 = 1 let twoThousandAndOne = twoThousand + UInt16(one) 不是(UInt16)one

整形浮点转换 let three = 3 let pointOneFourOneFiveNine = 0.14159 let pi = Double(three) + pointOneFourOneFiveNine

字符串类型

let someString = "Some string literal value" let wiseWords = "\"Inagination is more important than knowledge\" - Einstein”

//下面三种在xcode6.0.1中playground中异常(未知原因) let dollarSign = "\x24" // Unicode scalar U+0024 let blackHeart = "\u2665" // Unicode scalar U+2665 let sparklingHeart = "\U0001F496" // Unicode scalar U+1F496

初始化空字符串 var emptyString = "" var anotherEmptyString = String() if emptyString.isEmpty{ println("nothing is see here") } if anotherEmptyString.isEmpty{ println("nothing is see here") } if anotherEmptyString==""{ println("nothing is see here") }

let 声明不可修改 var 声明的字符串可以修改

emptyString += “horse” 字符串拼接

let multipler = 3 let message = "(multipler) times 2.5 is ((Double)(multipler)*2.5)” 变量嵌入字符串 (表达式)相当于%@

//字符串长度 let unusualMenagerie = "Koala,Snail,Penguim,Dromedary" println("unusualMenagerie has (countElements(unusualMenagerie)) characters")

字符串比较

//字符串比较 let quotation = "We're a lot alike ,you and I." let sameQuotation = "We're a lot alike ,you and I." if quotation == sameQuotation{ println("these two strings are considered equal") }

//元组类型(tuple) //元组将多个值组合为单个值,元组内的值可以是任意类型,各元素可以不必是相同的类型,元组在作为函数返回值时尤其有用。 let http404Error = (404,"Not Found”);//定义方法一 println("The status code is (http404Error.0)") println("The status message is (http404Error.1)”)

let http404Error = (statusCode:200,description:"Not Found”);//定义方法二 println("The status code is (http404Error.statusCode)") println("The status message is (http404Error.description)”)

//可选类型(Optional) //如下情况我们使用可选类型 //1.它有值但不确定2.没有任何值 let possibleNumber = "hello"//Hello let convertedNumber:Int? = possibleNumber.toInt() //"Int?"是可选类型 if (convertedNumber != nil) { println("(possibleNumber) has an integer value of (convertedNumber!)") }else{ println("(possibleNumber) couldnot be integer") } var serverResponseCode:Int? = 404 serverResponseCode = nil;

//数组 //数组初始化 var shoppinList = ["Eggs","Milk"] var arr : Array = ["111","222"] //数组追加元素 shoppinList.append("Four")

shoppinList += ["five","cheese"]where println("The shopping list contains (shoppinList.count) items") //数组插入元素

shoppinList.insert("Maple syrup", atIndex:0) //数组删除元素 shoppinList.removeAtIndex(1) println(shoppinList) //数组长度 println("The shopping list contains (shoppinList.count) items")

//数组遍历 for item in shoppinList{ println(item) }

for(index,value) in enumerate(shoppinList){ println("Item(index+1):(value)") }

func allItemsMatch< C1 xss=removed> (someContainer: C1, anotherContainer: C2) -> Bool {

    // check that both containers contain the same number of items
    if someContainer.count != anotherContainer.count {
        return false
    }

    // check each pair of items to see if they are equivalent
    for i in 0..someContainer.count {
        if someContainer[i] != anotherContainer[i] {
            return false
        }
    }

    // all items match, so return true
    return true

}

这个函数用了两个参数:someContainer和anotherContainer。someContainer参数是类型C1,anotherContainer参数是类型C2。C1和C2是容器的两个占位类型参数,决定了这个函数何时被调用。

这个函数的类型参数列紧随在两个类型参数需求的后面:

  • C1必须遵循Container协议 (写作 C1: Container)。
  • C2必须遵循Container协议 (写作 C2: Container)。
  • C1的ItemType同样是C2的ItemType(写作 C1.ItemType == C2.ItemType)。
  • C1的ItemType必须遵循Equatable协议 (写作 C1.ItemType: Equatable)。

//字典 //[key1:value1,key2:value2,key3:value3,key4:value4] //字典初始化 var airports:Dictionary= ["key1":"value1","key2":"value2"] //字典追加元素 airports["sss"] = "london" //字典删除元素 var removeValue = airports.removeValueForKey("key1") //字典长度 var count:Int = airports.count //字典遍历 for(airportcode,airportName) in airports{ println("(airportcode):(airportName)") }

for airportcode in airports.keys{ println("airport code:(airportcode)") }

for airportName in airports.values{ println("airport code:(airportName)") }

//获得键或值的数组 var airportcodes = Array(airports.keys)

var airportNames = Array(airports.values)

//分支语句 //if ...else... var booleanEx:Bool = true if booleanEx {

}else if(!booleanEx){

} else{

}

var number1 = 0; var number2 = 1; var max = 0;

if number1 > number2{ max = number1 }else if number1 < number2 xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed description = "The number (integerToDescribe)">String{//:后面是参数类型 ->返回值类型 去掉-> 表示无返回值(void) return "(para1)+(para2)" } //函数调用 funcName("Bob", "Tuesday"); //多值返回 元组返回值 func countStr(string: String) -> (vowels:Int,consonants:Int,others:Int){ var vowels = 0,consonants = 0, others = 0 for character in string { switch String(character).lowercaseString{ case "a","e","i","o","u": ++vowels case "b","c","d","r","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z": ++consonants default: ++others } } return (vowels,consonants,others) } //countStr("myname"); //嵌入函数 func chooseStepFunction(backwards:Bool)-> (Int)->Int{ func stepForward(input:Int) -> Int {return input + 1}; func stepBacward(input: Int) -> Int {return input - 1}; return backwards ? stepBacward : stepForward } var currentValue = -4 let moveNearerToZero = chooseStepFunction(currentValue > 0) while currentValue != 0 { currentValue = moveNearerToZero(currentValue) println("(currentValue)...") }

//· 类似block 函数代码块 匿名内部类 / {(parameters)->return type in statements } /

//实例 采用函数实现 //let names = ["Chris","Alex","Ewa","Barry","DanieMa"]; //func backwards(s1: String,s2: String) -> Bool{ // return s1 > s2 //} //var re = sorted(names, backwards) //降序排列

//println(re);

//用闭包实现

let names = ["Chris","Alex","Ewa","Barry","DanieMa"]; var reversed = sorted(names,{(s1: String,s2: String) -> Bool in // var a = 100 // var s3 = "(a)" return s1 > s2 })

//因为排序闭包是作为函数的参数进行传入的,Swift可以推断其参数和返回值的类型。 sort 期望第二个参数是类型为 (String, String) -> Bool 的函数,因此实际上 String, String 和 Bool 类型并不需要作为闭包表达式定义中的一部分。 因为所有的类型都可以被正确推断,返回箭头 (->) 和 围绕在参数周围的括号也可以被省略: var reversed1 = sorted(names,{s1,s2 in return s1 > s2 }) //单行表达式闭包可以通过隐藏 return 关键字来隐式返回单行表达式的结果,如上版本的例子可以改写为: var reversed2 = sorted(names, { s1, s2 in s1 > s2 }) //println(reversed)

//Swift 自动为内联函数提供了参数名称简写功能,您可以直接通过 $0,$1,$2等名字来引用的闭包的参数的值 var reverse3 = sorted(names, { $0 > $1 }) //实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。 Swift的 String 类型定义了关于大于号 (>) 的字符串实现,让其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值。 而这正好与 sort 函数的第二个参数需要的函数类型相符合。 因此,您可以简单地传递一个大于号,Swift可以自动推断出您想使用大于号的字符串函数实现: var reverse4 = sorted(names, >)//官方swift文档 运算符函数 //https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/RevisionHistory.html#//apple_ref/doc/uid/TP40014097-CH40-XID_1655

//Trailing闭包多行代码 //如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数,可以使用 trailing 闭包来增强函数的可读性。Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式,函数支持将其作为最后一个参数调用。

func someFunctionThatTakesAClosure(closure: () -> ()) { // 函数体部分 println("aaa") closure() } // 以下是不使用 trailing 闭包进行函数调用 someFunctionThatTakesAClosure({()->() in println("ccc") // 闭包主体部分 }) // 以下是使用 trailing 闭包进行函数调用 作为函数最后一个参数调用 someFunctionThatTakesAClosure() { // 闭包主体部分 println("sss") println("kkk") }

//实例 闭包是一个引用类型 如果您将闭包赋值给了两个不同的常量/变量,两个值都会指向同一个闭包 let digitNames = [ 0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four", 5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine" ] let numbers = [16, 58, 510]

let strings = numbers.map {//numbers中每个元素作为参数 执行闭包代码 (var number) -> String in var output = "" while number > 0 {//!表示取得可选参数的值防止取值失败 output = digitNames[number % 10]! + output number /= 10 } return output } // strings 常量被推断为字符串类型数组,即 String[] // 其值为 ["OneSix", "FiveEight", "FiveOneZero"]

//捕获(Caputure) // 闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原作用域已经不存在,闭包仍然可以在闭包函数体内引用和修改这些值。Swift最简单的闭包形式是嵌套函数,也就是定义在其他函数体内的函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。

func makeIncrementor(forIncrement amount: Int) -> () -> Int { var runningTotal = 0 func incrementor() -> Int { runningTotal += amount return runningTotal } return incrementor } //makeIncrementor 返回类型为 () -> Int。 这意味着其返回的是一个函数,而不是一个简单类型值。 该函数在每次调用时不接受参数只返回一个 Int 类型的值 //makeIncrementor 函数定义了一个整型变量 runningTotal (初始为0) 用来存储当前增加总数。 该值通过 incrementor 返回。

//makeIncrementor 有一个 Int 类型的参数,其外部命名为 forIncrement, 内部命名为 amount,表示每次 incrementor 被调用时runningTotal 将要增加的量。

//incrementor 函数用来执行实际的增加操作。 该函数简单地使 runningTotal 增加 amount,并将其返回。 / func incrementor() -> Int { runningTotal += amount return runningTotal } /

//incrementor 函数并没有获取任何参数,但是在函数体内访问了 runningTotal 和 amount 变量。这是因为其通过捕获在包含它的函数体内已经存在的 runningTotal 和 amount 变量而实现。

//由于没有修改 amount 变量,incrementor 实际上捕获并存储了该变量的一个副本,而该副本随着 incrementor 一同被存储。

//然而,因为每次调用该函数的时候都会修改 runningTotal 的值,incrementor 捕获了当前 runningTotal 变量的引用,而不是仅仅复制该变量的初始值。捕获一个引用保证了当 makeIncrementor 结束时候并不会消失,也保证了当下一次执行 incrementor 函数时,runningTotal 可以继续增加。

//实例 let incrementByTen = makeIncrementor(forIncrement: 10)

incrementByTen() // 返回的值为10 incrementByTen() // 返回的值为20 incrementByTen() // 返回的值为30

//如果您创建了另一个 incrementor,其会有一个属于自己的独立的 runningTotal 变量的引用。 下面的例子中,incrementBySevne 捕获了一个新的 runningTotal 变量,该变量和 incrementByTen 中捕获的变量没有任何联系: let incrementBySeven = makeIncrementor(forIncrement: 7) incrementBySeven() // 返回的值为7 incrementByTen() // 返回的值为40

//类和结构体共性 /* 结构体与C++ 结构体区别很大 1.定义属性存储数据 2.定义方法执行功能处理 3.定义下标,通过下标访问他们的值 4.初始化他们的状态 5.通过扩展(Extension)扩展其功能 6.遵守协议(Protocol)协议提供一种特定的标准功能

类比结构体多出的功能 1.能够继承另一个类 2.能够核对运行期对象的类型 3.析构对象释放资源 4.引用计数允许一个类实例有多个引用 */ class SomeClass {//不存在头文件 // } struct SomeStructure {

} //实例 struct Resolution{ var width = 0 var height = 0 } class VideoMode { var resolution = Resolution() var interfaced = false var frameRate = 0.0 var name:String? //可选类型 }

//类和结构体的实例化 let someResolution = Resolution() let someVideoMode = VideoMode()

//属性 OC的成员变量 struct FixedLengthRange{ var firstValue:Int let length:Int } var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)

rangeOfThreeItems.firstValue = 6

let rangeOfthreeItems = FixedLengthRange(firstValue: 0, length: 3) //不能修改其所有属性

//延迟存储属性 lazy 修饰 两个类之间的依赖关系,可能属性不使用,导致大量内存 使用次数相对较少 class DataImporter{ var fileName = "data.txt" } class DataManager { lazy var importer = DataImporter() // 开始没有值,只有第一次使用后才会赋值给他 var data = "" } let manager = DataManager() manager.data += "Some data" manager.data += "Some more data" println(manager.importer.fileName)//这里importer 开始有值

//计算属性 struct Point { var x = 0.0,y = 0.0 } struct Size { var width = 0.0,height = 0.0 }

struct Rect { var origin = Point() var size = Size() var center : Point {//计算属性 get { let centerX = origin.x + size.width / 2 let centerY = origin.y + size.height / 2 return Point(x: centerX, y: centerY) } set (newCenter){ origin.x = newCenter.x - size.width / 2 origin.y = newCenter.y - size.height / 2 } } }

var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0)) let initialSquareCenter = square.center square.center = Point(x: 15.0, y: 15.0) println("square.origin is now at((square.origin.x),(square.origin.y))")

//属性观察者 为了监听属性变化 swift 通过了属性观察者。willSet观察者是在存储之前调用,didSet新值存储后调用 class StepCounter {//可以监听下载进度等 var totalSteps: Int = 0 {//不重写willset和didset方法会编译报错 willSet(newTotalSteps) { println("About to set totalSteps to (newTotalSteps)") } didSet { if totalSteps > oldValue {//oldValue didset隐式 老值 println("steps") } println("Added (totalSteps - oldValue)") } } } let stepCounter = StepCounter() stepCounter.totalSteps = 200 // About to set totalStepsto 200 stepCounter.totalSteps = 360 // About to set totalStepsto 360 stepCounter.totalSteps = 896 // About to set totalStepsto 896 // Added536steps

//静态属性 结构体中使用static定义,类中使用class 修饰定义 //调用的时候可以直接使用类或者结构体名调用 struct SomeStructure { static var storedTypeProperty = "Some value." static var computedTypeProperty: Int{ // return anInt value here return 1 } } class SomeClass { class var computedTypeProperty: Int { // return anInt value here return 1 } }

struct AudioChannel { static let thresHoldLevel = 10 static var maxInputLevelForAllChannel = 0 //可以修改 var currentLevel:Int = 0{ didSet { if currentLevel > AudioChannel.thresHoldLevel{ currentLevel = AudioChannel.thresHoldLevel } if currentLevel > AudioChannel.maxInputLevelForAllChannel{ AudioChannel.maxInputLevelForAllChannel = currentLevel } } } } var leftChannel = AudioChannel() var rightChannel = AudioChannel() //leftChannel.maxInputLevelForAllChannel //访问静态的不被允许 println(leftChannel.currentLevel)

//方法实例方法 静态方法 swift中方法是(类,结构体,枚举里面定义的 , 在其外面叫做函数)相关函数 class Counter{ var count = 0 func increment(){//实例方法 count++ } func incrementBy(amount:Int){ count += amount } func reset(){ count = 0 }

} let counter = Counter() counter.increment() counter.incrementBy(5) counter.reset()

//使用self 类或结构体内部使用 struct Point{ var x = 0.0 ,y = 0.0 func isToTheRightOfx(x:Double)->Bool{ return self.x > x //区分x } } let somePoint = Point(x: 4.0, y: 5.0) if somePoint.isToTheRightOfx(1.0){ println("This point is the right of the line where x == 1.0") }

//51 下标-定义下标

//回顾字典 var numberOfLegs = ["spider":8,"ant":6,"cat":4] numberOfLegs["bird"]=2 //往字典中添加内容 //["bird"]就是下标 //下标可以在类和结构体中定义

/*

//定义下标的例子 下标的关键字subscript 只能定义在类型或结构体里面 subscript(index:Int)->Int{ get{ // return an appropriate subscript value here return 1 } set{ // perform a suitable setting action here } } */

//只读下标 struct TimesTable{ let mulitiplier:Int subscript(index:Int)->Int{//只读 可以省略get return mulitiplier*index } } let threeTimesTable = TimesTable(mulitiplier: 3) print("six times three is (threeTimesTable[6])") //prints "six times three is 18"

// 继承只能在类中,结构体不行 //继承 -定义基类 //Swift中得类能够继承其他类的属性、方法等。

//定义基类 基类:没有父类,被别人调用实现和继承的 class Vehicle{ //继承用冒号 var numberOfWheels:Int var maxPassengers:Int func description()->String{ return "(numberOfWheels)wheels;up to(maxPassengers)passengers" } init(){ numberOfWheels = 0 maxPassengers = 1 } } let someVehicle = Vehicle()

//定义子类 / class SomeClass : SomeSuperClass{ //class definetion goes here } / class Bicycle:Vehicle { override init() { super.init()//初始化父类 numberOfWheels = 2 } } let bicycle = Bicycle() println("Bicycle:(bicycle.description())")

// 子类 能够 重写父类的方法,属性,下标 //方法重写 swift中无多态的问题 class Car :Vehicle{ var speed:Double = 0.0 override init() { super.init() maxPassengers = 5 numberOfWheels = 4 } override func description() -> String { return super.description()+";"+"traveling at (speed)mph" } } let car = Car() println("Car:(car.description())")

//属性重写 //get和set访问器的重写 class Car{ var speed:Double = 0.0 func description()->String{ return "aaa" } } class SpeedLimitedCar:Car{ override var speed:Double{ get{ return super.speed } set{

    }
}

} let limitedCar = SpeedLimitedCar() limitedCar.speed = 60.0 println("SpeedLimitedCar:(limitedCar.description())")

//构造器 为了初始化结构体和类等类型的实例属性 //默认构造器 init(){}无返回值

//自定义构造器

//析构器与构造器相反,在对象释放时候调用 //使用deinit。语法如下

class A { var a:Int deinit{ // perform the deinitialization } init(){ a = 0 println("aa") } }

//实例 class Player{ var coinsInPurse:Int init(coins:Int){ println("call init") coinsInPurse = coins } func winCoins(coins:Int){ coinsInPurse += 10 } deinit{ coinsInPurse = 0 } }

var playerOne:Player?=Player(coins: 100)

println("coinsInPurse:(playerOne!.coinsInPurse)coins") playerOne = nil println("PlayerOne has left the game")

struct Fahrenheit { var temperature:Double // init(){ 默认构造器无参数 // temperature = 12.2 // } } //var f = Fahrenheit()//无默认构造方法不能使用 var f = Fahrenheit(temperature: 12.2) //有默认构造方法不能使用,反之可用

struct Celsius { var temperatureIncelsius:Double = 0.0 init(fromFahrenheit fahrenheit:Double){//fromFahrenheit 用于区分调用哪个构造器 temperatureIncelsius = (fahrenheit - 32.0)/1.0 } init(fromKelvin kelvin:Double){ temperatureIncelsius = kelvin - 273.15 } init(fromFahrenheit fahrenheit:Double,aaccc aaa:Int){//fromFahrenheit 用于区分调用哪个构造器 temperatureIncelsius = (fahrenheit - 32.0)/1.0 } }

let boilingPointOfWater = Celsius(fromFahrenheit: 212.0) let freezingPointOfWater = Celsius(fromKelvin: 273.15)

let boilingPointOfWater2 = Celsius(fromFahrenheit: 212.0,aaccc:1)

//扩展 在现有类和机构提的基础上,扩展新的功能 属性计算 /* extension SomeType{

}

extension SomeType:SomeProtocol,AnotherProtocol{

}

/ extension Double{ var km:Double{return self1_000.0} var m:Double{return self} var cm:Double{//不是方法,是个属性省略了get{} return self/100.0 } }

let oneKm = 1.0.km

struct Size { var width = 0.0,height = 0.0 } struct Point { var x = 0.0, y = 0.0 } struct Rect { var origin = Point() var size = Size() }

extension Rect{ init(center:Point,size:Size){ let originx = center.x - size.width/2 let origniy = center.y - size.height/2 self.init(origin:Point(x:originx,y:origniy),size:size)//Rect 结构体构造器 } } //let centerRect = Rect(origin: <#Point#>, size: <#Size#>)) let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width:3.0,height:3.0))

//方法扩展 extension Int{ func message() ->String{ var message = "" switch self{ case 0 : message = "成功"; case -1: message = "用户登录失败" default: message = "未知错误" } return message } }

3.message() 0.message() (-1).message()

//协议 是为方法、属性等定义一套规范、没有具体的实现、协议能被类、结构体等具体实现(或遵守) protocol SomeProtocol{ var mustBeSettable:Int{get set} var doesNotNeedToBeSettable:Int{get} } protocol FirstProtocol{

} //静态属性 protocol AnotherProtocol{ class var someTypeProperty:Int{get set} //只能被类实现 static let someType:Int //只能被机构体实现 }

class SomeSuperclass {

} //只读 protocol FullyNamed{ var fullName:String{get} } /* struct SomeStructure:FirstProtocol,AnotherProtocol {

} class SomeClass: SomeSuperclass,FirstProtocol,AnotherProtocol { //class definition goes here 第一个是类,其他是协议 }*/

struct Person:FullyNamed { var fullName:String } let john = Person(fullName: "John Applessed") class Starship: FullyNamed { var prefix:String?//可选类型 var name:String init (name: String,prefix: String? = nil){ self.name = name self.prefix = prefix }

var fullName: String{
    return ((prefix != nil) ? (prefix! + " ") : "") + name
}

}

var ncc1701 = Starship(name: "Enterprise", prefix: "USS")

//协议中使用方法 protocol RandomNumberGenerator{ func random() ->Int }

class LinearCongruentialGenerator: RandomNumberGenerator { var lastRandom = 42 let a = 1111 let b = 3877 let c = 32153 func random() -> Int { lastRandom = ( lastRandom a c ) % 5 return lastRandom } }

let generator = LinearCongruentialGenerator()

generator.random() generator.random()

//协议作为类型使用 class Dice { var sides:Int = 0 var generator:RandomNumberGenerator // 协议可作为类型,但是不能十实例化 init(sizes:Int , generator:RandomNumberGenerator){ self.sides = sizes self.generator = generator } func roll()->Int{ return Int(generator.random() * Int(sides)) + 1 }

}

var d6 = Dice (sizes: 6, generator: LinearCongruentialGenerator()) for _ in 1 ... 5{ println("Random dice roll is(d6.roll())") }

收藏
1
sina weixin mail 回到顶部