在Swift中,使用struct 创建结构体类型;结构体支持的行为与类非常相似,都有成员方法与初始化;结构体与类最大的区别是在代码中使用结构体的时候,它总是会被拷贝;但是类在使用的时候,只是采用引用方式.

　　 struct Card {

   　　 var rank: Rank

  　　  var suit: Suit

   　　 func simpleDescription() -> String {

    　　    return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"

  　　  }

　　}

　　let threeOfSpades = Card(rank: .Three, suit: .Spades)

　　let threeOfSpadesDescription = threeOfSpades.simpleDescription()

　　EXPERIMENT // 练习题

　　Add a method to Card that creates a full deck of cards, with one card of each combination of rank and suit. //给Card增加一个方法创建整副牌;并且带有一张包含rank 和suit的卡牌

一个枚举成员的实例可以拥有这个实例的关联值,多个枚举成员可以有不同的关联值;在创建成员实例的时候可以构建关联值.但是关联值与原始值是不同的:一个枚举成员的原始值,对于它的所有实例来说,都是相同的.并且,是你在定义枚举的时候构建的.

例如,有一种情况,从一个服务器上请求获取日出(sunrise)和日落(sunset)的时间,服务器要么响应信息,要么响应错误信息.

　　enum ServerResponse {

  　　  case Result(String, String)

  　　  case Error(String)

　　}

　　let success = ServerResponse.Result("6:00 am", "8:09 pm")

　　let failure = ServerResponse.Error("Out of cheese.")

　　switch success {

　　case let .Result(sunrise, sunset):

  　　  let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."

　　case let .Error(error):

  　　  let serverResponse = "Failure...  \(error)"

　　}

　　EXPERIMENT // 练习题

　　Add a third case to ServerResponse and to the switch. // 添加第三个case给 ServerResponse 和 switch

Protocols and Extensions  // 协议和扩展

使用protocol创建一个协议

　　protocol ExampleProtocol {

  　　  var simpleDescription: String { get }

  　　  mutating func adjust()

　　}

类,枚举,结构体都可以遵从协议;

　　class SimpleClass: ExampleProtocol {

 　　   var simpleDescription: String = "A very simple class."

　　  var anotherProperty: Int = 69105

 　　   func adjust() {

  　　      simpleDescription += "  Now 100% adjusted."

 　　   }

　　}

　　var a = SimpleClass()

　　a.adjust()

　　let aDescription = a.simpleDescription

　　struct SimpleStructure: ExampleProtocol {

   　　 var simpleDescription: String = "A simple structure"

   　　 mutating func adjust() {

    　　    simpleDescription += " (adjusted)"

   　　 }

　　}

　　var b = SimpleStructure()

　　b.adjust()

　　let bDescription = b.simpleDescription”

　　EXPERIMENT  // 练习题

　　Write an enumeration that conforms to this protocol. // 编写一个枚举,遵守协议;

注意在SimpleStructure结构体中使用的关键字 mutating(标记一个可以修改结构的方法), SimpleClass类的声明不需要任何标记 mutating的方法,因为类的方法总是可以修改类的.

使用extension给一个存在的类型添加功能,比如新的方法或者属性;也可以使用 extension 增加协议响应类型,甚至从库或者框架中导入的类型.

　　extension Int: ExampleProtocol {

    　　var simpleDescription: String {

   　　 return "The number \(self)"

   　　 }

   　　 mutating func adjust() {

      　　  self += 42

  　　  }

　　}

　　7.simpleDescription

　　EXPERIMENT  // 练习题

　　Write an extension for the Double type that adds an absoluteValue property. // 给Double类型写一个扩展,增加一个 absoluteValue属性;

可以使用协议名(就像使用其他类型名一样 )来创建一个包含多种数据类型的对象集合来遵守单一协议.当你处理的一个协议类型的值时,协议的外部方法是无法访问的.

　　let protocolValue: ExampleProtocol = a

　　protocolValue.simpleDescription

在上面的代码中,变量protocolValue即使是动态运行时的SimpleClass类型,但编译器仍然将它当做指定的类型ExampleProtocol.这意味着你不可以附加了协议的类的方法和属性.

Generics  // 泛型

在<>中填写一个名称可以来定义一个泛型函数或者类型;

　　func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {

   　　 var result = ItemType[]()

   　　 for i in 0..times {

   　　     result += item

  　　  }

  　　  return result

　　}

　　repeat("knock", 4)

函数或者方法都可以使用泛型定义,(就像类,枚举和结构体它们一样)

　　 enum OptionalValue<T> {

  　　  case None

  　　  case Some(T)

　　}

　　var possibleInteger: OptionalValue<Int> = .None

　　possibleInteger = .Some(100)

在类型名后面使用where关键字可以定义一个限制列表,例如,限制类型实现某一协议,或者要求两个类型相同,或者要求类继承某个父类.

　　func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, .GeneratorType.Element == U.GeneratorType.Element> 　　(lhs: T, rhs: U) -> Bool {

 　　   for lhsItem in lhs {

      　　  for rhsItem in rhs {

         　　   if lhsItem == rhsItem {

               　　     return true

            　　}

       　　 }

   　　 }

   　　 return false

　　}

　　anyCommonElements([1, 2, 3], [3])

　　EXPERIMENT // 练习题

　　Modify the anyCommonElements function to make a function that returns an array of the elements that any two sequences have in common.

        // 修改 anyCommonElements函数,让它返回一个数组,数组的元素任何的两个序列都相同.(此句翻译可能有误)

在上面的例子中,你可以忽略 where ,在冒号后面只写协议名或者类名.写法 <T: Equatable>与写法<T where T: Equatable>作用是相同的.

                     (本章完)