6.Swift协议|扩展|访问权限|异常调试|类型转换|运算函数|ARC|类类型初试化器|值类型初始化器

1. 协议(Protocol)：与OC之间唯一不同的是Swift中的协议不管是属性还时方法全部是必须实现的

/** protocol*/

protocol FullNamed {

/** 计算属性申明,只读的计算属性*/

var fullName:String { get }

}

/** 实现协议*/

struct Person:FullNamed {

/** 实现协议  可以把计算属性实现为存储属性，更改其本身的性质*/

var fullName: String = "abc"

}

/** 开发中的协议*/

protocol MyPotocol {

//计算属性的get set声明

var prop:Int {

get

set

}

var onlyRead:Int{ get }

//实例方法

func instanceMethod()->Int

//静态方法或者类方法

static func typeMethod()

}

class MyClass: MyPotocol {

var prop:Int = 10

var onlyRead:Int = 10

func instanceMethod() -> Int {

return 10

}

//此处按规范应该写static

class func typeMethod() {

print("class method")

}

}

var mc = MyClass()

mc.prop = 3

MyClass.typeMethod()

mc.instanceMethod()

mc.onlyRead = 5

mc.onlyRead

protocol SomeProtocol {

init(a: Int)

func test() -> Int

}

class parent {

init(a:Int){}

}

/** Swift中的协议的所有方法都必须实现,此处MyClass需要实现协议就需要对父类的方法进行改写，所以同时改写方法和实现required协议，前面使用  override 和 required关键字组合搭配：*/

class MyClass1: parent,SomeProtocol {

override required init(a:Int) {

super.init(a: 100)  //改写内部实现方法依然为父类的方法。

}

func test()->Int {

return 1

}

}

//使用OC中的协议方式

@objc protocol ObjecProtocol {

func requiredMethod()

optional func optionalMethod()

}

class ObjectClass:ObjecProtocol {

@objc func requiredMethod() {

}

}

var r2 = Rect(x: 100, y: 200, w: 33, h: 2)

2.扩展(Extension),Swift中使用扩展的原则

不可以再扩展中定义存储属性，这是格式，定义了会报错，无法执行

可以再扩展中定义计算属性

extension Double{

//不可以在扩展中定义存储属性

//错误 var i = 10

//可以在扩展中定义计算属性

var km:Double {

return self/1000.0

}

var cm:Double {

return self * 100.0

}

/** 扩展一个方法实现四舍五入*/

func round()->Int{

//整数情况

return Int(self + 0.5)

}

}

350.0

print(350.5.km)

print(350.5.cm)

print(350.49.round())

print(350.50.round())

struct Point {

var x = 0.0

var y = 0.0

}

struct Size {

var w = 0.0

var h = 0.0

}

struct Rect {

var origin = Point()

var size = Size()

}

var r = Rect()

//通过扩展一个带有四个参数的初始化器使得Rect在初始化的时候可以同时赋上四个值

extension Rect {

init(x:Double,y:Double, w:Double, h:Double){

self.origin = Point(x: x, y: y)

self.size = Size(w: w, h: h)

}

}

//其实上面的操作和OC里面的  -(id)initWithName:(NSString*)name andAge:(int) age{   if (self = [super init];  self.name = name, self.age = age)}功能是差不多的，只是表现形式不同而已

还可以通过扩展对系统类型的空间进行增加方法或者计算值属性

extension UIButton {

func show(){

print(self.tag)

}

}

3. 泛型(genericity): 字面意思理解就是广泛地被使用的类型,言外之意可以充当很多中类型。并且在赋值的时候它会根据系统的自动推倒公司变成制定的类型(Swift语言所期望的类型)

比如当我有很多个不同类型它门需要调换值,且实现逻辑一样。

函数+<T>指定T是一个泛型    T就代表各种类型的类型了

func swapTwoValues<T>(inout a:T,inout b:T) {

let temp = a

a = b

b = temp

}

swap(&str1, &str2)

str1

str2

/**类型的范型  Array<Double 属于一个类型> */

var arr:Array<Double> = Array()

struct  Instack {

private var items = [Int]()

/**栈的特点后进先出*/

mutating func push(item:Int){

items.append(item)

}

mutating func pop(item:Int){

items.removeLast()

}

}

/**T属于一个类型函数，必须根据用户制定，通过Stack制定T(数组中元素的类型)*/

struct Stack<T> {

private var items = [T]()  //一个任意类型的数组,当T被指定为什么类型，那么该数组就为什么类型］

/**这里利用栈的特定，后进先出 构造一个数组*/

mutating func  push(item:T){

items.append(item)

mutating func pop(item:T){

items.removeLast()

}

}

var intStack:Stack<Int> = Stack()

var StringStack:Stack<String> = Stack()

4. 访问控制public表示在任何地方都能访问

internal表示在本项目能访问，为了限制类成员的作用阈在类的作用阈范围内，所以在类的内部不能使用public

private 职能在本.xxx文件中访问

/** 任何地方都可以访问*/

public class AClass {

}

/** 在本项目中访问*/

internal class IClass {

}

/**限于本文件中*/

private class CClass {

}

/** internal*/

class FClass {

//属性的权限不能高于类   public var = c = 2

internal var a = 10

private var b = 20

}

var fc:FClass = FClass()

fc.a

fc.b

5. 异常处理:非常有用，尤其在后续开发设计用户体验度相关问题的时候。**********************

/**异常处理(exception) ，这是OC常用的描述，而在我们的Swif提供了一类错误的支持，包括运行时抛出错误，捕捉错误，以及控制收回错误，使用了一个符合的ErrorType协议来表示。

1. 定义错误type,一般为枚举值,需要用一个值把程序中的问题表达出来

2. 根据不同的运算结果返回不同的ErrorType枚举值

3. 处理抛出的异常，通常采用  throws{ }  方法来判断不同的逻辑值后再调用throw选择性的抛出错误值

4. 处理抛出的异常，采用 do { try } catch 枚举值{  }catch枚举值{  }，这样一个循环监听事件，持续的尝试去判断逻辑抛出一异常，然后执行接收异常。

*/

/** 自动售货机的Error*/

enum VendingMachineError:ErrorType {

case InvalidSelection //没有物品或者选择错误，选择物品错误

case OutOfStock       //超出了范围,数量不够

case InsufficentFounds(required:Double)     //前不够,差多少

}

/** 商品条目*/

struct Item {

var price:Double

var count:Int

}

/** 商品的数组*/

var inventory = ["可乐":Item(price: 1.25, count: 0),"