Swift 面试题及其答案
笔试问题
初学者
问题1、（Swift 1.0及其之后的版本的问题）有什么更好的方法来写下面的for循环？
|
1
2
3
|
for
var
i = 0; i < 5; i++ {
print(
"Hello!"
)
}
|
答案：
|
1
2
3
|
for
_
in
0...4 {
print(
"Hello!"
)
}
|
Swift 实现了两个数组运算符closed operator 和 half-operator.前者包含数组中得所有值。例如：下面的例子包含从0到4得所有整数：
|
1
|
0...4
|
half-operator不包含数组中的最后一个元素，下面的例子会得到的结果和上面的一样：
|
1
|
0..<5
|
问题2– Swift 1.0 or later
思考下面的问题：
|
1
2
3
4
5
6
7
|
struct Tutorial {
var
difficulty: Int = 1
}
var
tutorial1 = Tutorial()
var
tutorial2 = tutorial1
tutorial2.difficulty = 2
|
tutorial1.difficulty 和 tutorial2.difficulty的值分别是多少？假如Tutorial是一个类，会有什么不同？并说明原因。
答案：tutorial1.difficulty 的值是1，然而tutorial2.difficulty的值是2.
在Swift中结构体是值类型，他们的值是复制的而不是引用的。下面的一行代码意思是复制了tutorial1的值并把它赋值给tutorial2：
|
1
|
var
tutorial2 = tutorial1
|
从这一行开始，tutorial2值得改变并不影响tutorial1的值。
假如Tutorial是一个类，tutorial1.difficulty和tutorial2.difficulty的值将都会是2.在Swift中类对象都是引用类型。tutorial1属性的任何改变将会反应到tutorial2上，反之亦然。
问题3 – Swift 1.0 or later
view1声明成var类型，view2声明let类型。这里有什么区别吗？下面的最后一行代码能编译吗？
|
1
2
3
4
5
6
7
|
import UIKit
var
view1 = UIView()
view1.alpha = 0.5
let view2 = UIView()
view2.alpha = 0.5
// Will this line compile?
|
答案：view1是个变量可以重新赋值给一个新的实例化的UIView对象。使用let你只赋值一次，所以下面的代码是不能编译的：
|
1
|
view2 = view1
// Error: view2 is immutable
|
但是UIView是一个引用类型的类，所以你可以改变view2的属性，也就是说最后一行代码是可以编译的：
|
1
2
|
let view2 = UIView()
view2.alpha = 0.5
// Yes!
|
问题4 – Swift 1.0 or later
下面的代码是把数组里面的名字按字母的顺序排序，看上去比较复杂。尽最大的可能简化闭包里的代码。
|
1
2
3
4
|
let animals = [
"fish"
,
"cat"
,
"chicken"
,
"dog"
]
let sortedAnimals = animals.sort { (one: String, two: String) -> Bool
in
return
one < two
}
|
答案：
第一个简化的是参数。系统的参数类型推断功能，可以计算出闭包里面参数的类型，所以你不必定义参数的类型：
|
1
|
let sortedAnimals = animals.sort { (one, two) -> Bool
in
return
one < two }
|
函数返回值也可以被推断出来，所以简化掉，代码变为：
|
1
|
let sortedAnimals = animals.sort { (one, two)
in
return
one < two }
|
这个$i 符号可以代替参数名字，代码进一步简化为：
|
1
|
let sortedAnimals = animals.sort {
return
$0 < $1 }
|
在一个独立的闭包内，return这个关键字是可以省略的。最后声明的返回值就是闭包的返回值：
|
1
|
let sortedAnimals = animals.sort { $0 < $1 }
|
这简化很多了，但是我们不能止步于此！
对于字符串，有一个定义如下的比较函数：
|
1
|
func Bool
|
这个简单的小函数可以使你的代码简洁如下：
|
1
|
let sortedAnimals = animals.sort(<)
|
注意每一步的编译结果都相同，但是最后一步你的闭包里只有一个字符。
问题5 – Swift 1.0 or later
下面的代码创建了两个类Address和Person,并且创建了两个实例对象分别代表Ray和Brain.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class Address {
var
fullAddress: String
var
city: String
init(fullAddress: String, city: String) {
self.fullAddress = fullAddress
self.city = city
}
}
class Person {
var
name: String
var
address: Address
init(name: String, address: Address) {
self.name = name
self.address = address
}
}
var
headquarters = Address(fullAddress:
"123 Tutorial Street"
, city:
"Appletown"
)
var
ray = Person(name:
"Ray"
, address: headquarters)
var
brian = Person(name:
"Brian"
, address: headquarters)
|
假设Brain搬家到街对面的建筑物里，那么你会这样更新他的地址：
|
1
|
brian.address.fullAddress =
"148 Tutorial Street"
|
这样做将会发生什么？错误出在什么地方呢？
答案：Ray同样会搬家到新的建筑物里面。Address是一个引用类型类，所以无论你是通过ray或者brain访问headquarters，访问都是同一个实例化对象。headquarters对象的变化也会引起ray和brain的变化。你能想象如果Brain收到Ray的邮件或者相反Ray收到Brain的邮件，将会发生什么？解决方案是创建一个新的Address对象赋值给Brain或者把Address声明成为结构体而不是一个类。
中级
问题1– Swift 2.0 or later
思考下面的代码：
|
1
2
|
var
optional1: String? = nil
var
optional2: String? = .None
|
nil 和 .None有什么不同？optional1和optional2有什么不同？
答案：两者没有什么不同。Optional.None（简称.None）是optional变量值初始化的标准方法，而nil只是.None语法的一种修饰。事实上下面语句输出是正确的：
|
1
2
|
nil == .None
// On Swift 1.x this doesn't compile. You need Optional
.None
|
记住枚举类型的Optional下的None:
|
1
2
3
4
|
enum Optional{
case
None
case
Some(T)
}
|
问题2-Swift 1.0 or later
下面是thermometer作为类和结构体的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class ThermometerClass {
private(set)
var
temperature: Double = 0.0
public func registerTemperature(temperature: Double) {
self.temperature = temperature
}
}
let thermometerClass = ThermometerClass()
thermometerClass.registerTemperature(56.0)
public struct ThermometerStruct {
private(set)
var
temperature: Double = 0.0
public mutating func registerTemperature(temperature: Double) {
self.temperature = temperature
}
}
let thermometerStruct = ThermometerStruct()
thermometerStruct.registerTemperature(56.0)
|
但是这段代码编译失败了，请问哪里报错，出错的原因是什么。
建议：在使用Playground之前，认真阅读代码并思考。
答案：代码的最后一行不会被编译通过。ThermometerStruct结构体中正确的声明了一个mutating属性函数，它是用来改变结构体内部temperature属性的值的，但是编译器不通过的原因是，通过let创建的不可变的registerTemperature结构体调用了registerTemperature函数。
问题3– Swift 1.0 or later
下面的代码输出是什么？并说明理由。
|
1
2
3
4
5
6
7
8
9
|
var
thing =
"cars"
let closure = { [thing]
in
print(
"I love \(thing)"
)
}
thing =
"airplanes"
closure()
|
答案：输出的是：I love cars。当闭包被声明的时候，抓捕列表就复制一份thing变量，所以被捕捉的值并没有改变，即使你给thing赋了一个新值。
如果你要忽视闭包中捕捉列表的值，那么编译器引用那个值而不是复制。这种情况下，被引用变量的值的变化将会反映到闭包中，正如下面的代码所示：
|
1
2
3
4
5
6
7
8
9
|
var
thing =
"cars"
let closure = {
print(
"I love \(thing)"
)
}
thing =
"airplanes"
closure()
// Prints "I love airplanes"
|
问题4– Swift 2.0 or later
下面是一个全局函数,这个函数的功能是计算数组中特殊值得个数。（待校验）
|
1
2
3
4
5
6
|
func countUniques(array: Array) -> Int {
let sorted = array.sort(<)
let initial: (T?, Int) = (.None, 0)
let reduced = sorted.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) }
return
reduced.1
}
|
它使用了< 和==运算符，他们限制着T（占位类型）的实际类型，也就是说T必须遵循Comparable协议。你可以这样使用它：
|
1
|
countUniques([1, 2, 3, 3])
// result is 3
|
现在要求你重写上面的方法作为Array的扩展方法，然后你就可以这样写代码：
|
1
|
[1, 2, 3, 3].countUniques()
// should print 3
|
如何实现？
答案：在Swift 2.0 中，泛类型可以使用类型约束条件被强制扩展。但是假如这个泛类型不满足这个类型的约束条件，那么这个扩展方法既不可见也无法调用。
所以countUniques全局函数可以作为Array的扩展方法被重写如下：
|
1
2
3
4
5
6
7
8
|
extension Array where Element: Comparable {
func countUniques() -> Int {
let sorted = sort(<)
let initial: (Element?, Int) = (.None, 0)
let reduced = sorted.reduce(initial) { ($1, $0.0 == $1 ? $0.1 : $0.1 + 1) }
return
reduced.1
}
}
|
注意：只有元类型实现了Comparable协议新的方法才可以被使用。例如，如果你在全部是UIView对象的数组中调用countUniques，编译器将会报错。
|
1
2
3
|
import UIKit
let a = [UIView(), UIView()]
a.countUniques()
// compiler error here because UIView doesn't implement Comparable
|
问题5- Swift 2.0 or later
下面一个函数的功能是计算两个double（optional）类型的数的相除的结果。在执行除法之前，必须提前满足三个条件：
被除数必须包含nil值
除数必须为包含nil值
除数不能为零
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
func divide(dividend: Double?, by divisor: Double?) -> Double? {
if
dividend == .None {
return
.None
}
if
divisor == .None {
return
.None
}
if
divisor == 0 {
return
.None
}
return
dividend! / divisor!
}
|
上面的函数可以正常使用，但是会存在两个问题：
那些前提条件可以利用guard语句。
使用了强制拆包。
请使用guard语句和避免使用强制拆包来优化这个函数。
答案：guard语句是在Swift 2.0中引进的，它是用途是在未满足某个条件时，提供一个退出的路径。对于检查是否满足先决条件来说，它是非常有用的。因为它可以使你更清晰的表达逻辑——而不是像i各种f语句嵌套实现那么复杂。下面就是一个例子：
|
1
|
guard dividend != .None
else
{
return
.None }
|
它也可以在optional binding（可选绑定）中使用。使用guard语句之后，使拆包后的变量可以被访问。
|
1
|
guard let dividend = dividend
else
{
return
.None }
|
所以divide函数被重写如下：
|
1
2
3
4
5
6
|
func divide(dividend: Double?, by divisor: Double?) -> Double? {
guard let dividend = dividend
else
{
return
.None }
guard let divisor = divisor
else
{
return
.None }
guard divisor != 0
else
{
return
.None }
return
dividend / divisor
}
|
我们发现隐身的可拆包的运算在代码的最后一行，因为dividend和divisor这两个参数已经被拆包并且以分别以一个常量来存储。
因此，你可以再次使用guard语句，使上面的函数更简洁：
|
1
2
3
4
|
func divide(dividend: Double?, by divisor: Double?) -> Double? {
guard let dividend = dividend, divisor = divisor where divisor != 0
else
{
return
.None }
return
dividend / divisor
}
|
上面的函数中使用了两个guard语句，因为使用了where语句指定了divisor不能为0的条件。
高级
问题1- Swift 1.0 or later
下面是thermometer作为结构体的例子：
|
1
2
3
4
5
6
|
public struct Thermometer {
public
var
temperature: Double
public init(temperature: Double) {
self.temperature = temperature
}
}
|
创建一个thermometer实例对象，你可以使用下面的代码：
|
1
|
var
t: Thermometer = Thermometer(temperature:56.8)
|
但是像下面的代码那样初始化对象是否会更好：
|
1
|
var
thermometer: Thermometer = 56.8
|
能这样做吗？如果可以，怎么做？提示：it has to do with convertibles, but not convertibles like Camaros and Mustangs
答案：Swift 定义了下面的协议，这些协议可以使一种类型通过字面量的方式来初始化并赋值。
|
1
2
3
4
5
6
7
8
9
|
NilLiteralConvertible
BooleanLiteralConvertible
IntegerLiteralConvertible
FloatLiteralConvertible
UnicodeScalarLiteralConvertible
ExtendedGraphemeClusterLiteralConvertible
StringLiteralConvertible
ArrayLiteralConvertible
DictionaryLiteralConvertible
|
采用相应的协议并且提供一个允许字面量初始化的公用方法。在Thermometer类型的例子下，我们需要实现FloatLiteralConvertible协议，代码如下：
|
1
2
3
4
5
|
extension Thermometer : FloatLiteralConvertible {
public init(floatLiteral value: FloatLiteralType) {
self.init(temperature: value)
}
}
|
那么现在，你就可以通过一个简单的float数字创建一Thermometer对象，代码如下：
|
1
|
var
thermometer: Thermometer = 56.8
|
问题2 - Swift 1.0 or later
Swift 拥有一系列预定义的运算符，这些运算符执行不同类型的操作，例如算术运算符和逻辑运算符。它甚至允许创建自定义的运算符，无论是一元运算符还是二元运算符。自定义一个满足一下规格的幂运算符：
以两个整数作为参数
返回第一个参数的第二个参数次方的值
忽略潜在溢出错误
答案：创建一个自定义的运算符需要两个步骤：声明它和实现它。
使用operator关键字来声明指定的类型（一元或者二元）、组成这个运算符字符的顺序已经它的优先级和关联性。
在这中情况下，运算符是^^,类型是infix（二进制），关联性是right，优先级设置成为155，原因是乘法和除法的优先级是150.下面就是具体的声明代码：
|
1
|
infix operator ^^ { associativity right precedence 155 }
|
代码实现如下：
|
1
2
3
4
5
6
|
func ^^(lhs: Int, rhs: Int) -> Int {
let l = Double(lhs)
let r = Double(rhs)
let p = pow(l, r)
return
Int(p)
}
|
值得注意的是，它并不需要溢出考虑；如果操作产生的结果int不能代表，如大于int.max，就会发生运行时错误。
问题3 - Swift 1.0 or later
你能像下面的代码一样使用原始值定义一个枚举类型吗？如果不行，说明原因。
|
1
2
3
4
5
6
|
enum Edges : (Double, Double) {
case
TopLeft = (0.0, 0.0)
case
TopRight = (1.0, 0.0)
case
BottomLeft = (0.0, 1.0)
case
BottomRight = (1.0, 1.0)
}
|
答案：不行。原始值得类型必须满足一下条件
遵守Equatable协议
满足能转换成下列类型中的任何一个类型：
|
1
2
3
|
a.Int
b.String
c. Character
|
在上面的代码中，原始值即使是独立的个体值，但是它仍然是一个不兼容的元组。
问题4- Swift 2.0 or later
下面的代码定义了一个结构体Pizza和一个协议Pizzeria，这个协议有一个包含makeMargherita()函数的扩展。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
struct Pizza {
let ingredients: [String]
}
protocol Pizzeria {
func makePizza(ingredients: [String]) -> Pizza
func makeMargherita() -> Pizza
}
extension Pizzeria {
func makeMargherita() -> Pizza {
return
makePizza([
"tomato"
,
"mozzarella"
])
}
}
|
现在你将要定义一个如下的Lombardi的餐馆：
|
1
2
3
4
5
6
7
8
|
struct Lombardis: Pizzeria {
func makePizza(ingredients: [String]) -> Pizza {
return
Pizza(ingredients: ingredients)
}
func makeMargherita() -> Pizza {
return
makePizza([
"tomato"
,
"basil"
,
"mozzarella"
])
}
}
|
下面的代码创建了Lombardis类型的两个实例对象，哪一个对象会产生一个带有basil的margherita披萨？
|
1
2
3
4
5
|
let lombardis1: Pizzeria = Lombardis()
let lombardis2: Lombardis = Lombardis()
lombardis1.makeMargherita()
lombardis2.makeMargherita()
|
答案：两个都可以。Pizzeria协议声明了makeMargherita()方法并且提供了一个默认的实现，而且它又在Lombardis的实现中被重写。在这两种情况下，由于这个方法在协议中被声明，那么在运行时相应的实现就会被调用。
假如Pizzeria协议没有声明makeMargherita()方法，但是扩展中仍然提供了如下的代码的这个方法默认的实现，会发生什么？
|
1
2
3
4
5
6
7
8
9
|
protocol Pizzeria {
func makePizza(ingredients: [String]) -> Pizza
}
extension Pizzeria {
func makeMargherita() -> Pizza {
return
makePizza([
"tomato"
,
"mozzarella"
])
}
}
|
这种情况下，只有lombardis2会产生一个带有basil的pizza,而lombardis1将会产生一个不带basil的pizza，原因是它会调用扩展中定义的那个方法。
问题5- Swift 2.0 or later
下面的代码有一个编译错误，请指出来并说明原因。
|
1
2
3
4
5
6
7
8
9
10
|
struct Kitten {
}
func showKitten(kitten: Kitten?) {
guard let k = kitten
else
{
print(
"There is no kitten"
)
}
print(k)
}
|
提示：有三种方法修复它。
答案：guard语句中得else语句必须需要一个返回路径，你可以使用return ,抛出异常或者调用@noreturn.最简单的解决方法是添加一个return语句，代码如下：
|
1
2
3
4
5
6
7
|
func showKitten(kitten: Kitten?) {
guard let k = kitten
else
{
print(
"There is no kitten"
)
return
}
print(k)
}
|
下面是抛出异常的版本：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
enum KittenError: ErrorType {
case
NoKitten
}
struct Kitten {
}
func showKitten(kitten: Kitten?) throws {
guard let k = kitten
else
{
print(
"There is no kitten"
)
throw
KittenError.NoKitten
}
print(k)
}
try
showKitten(nil)
|
最后，调用一个@noreturn功能函数 fatalError( ) 解决方案：
|
1
2
3
4
5
6
7
8
9
10
|
struct Kitten {
}
func showKitten(kitten: Kitten?) {
guard let k = kitten
else
{
print(
"There is no kitten"
)
fatalError()
}
print(k)
}
|
面试试题
你很棒，但是你还没达到绝地武士的要求。任何人都可以写出代码，但是你如何处理理论和实践相结合的开放式问题？
为了解决这些问题，你仍然需要使用Playgroud写代码来验证一些问题。
初级
问题1- Swift 1.0 or later
什么是optional类型，它是用来解决什么问题的？
答案：optional类型被用来表示任何类型的变量都可以表示缺少值。在Objective-C中，引用类型的变量是可以缺少值得，并且使用nil作为缺少值。基本的数据类型如int 或者float没有这种功能。
Swift用optional扩展了在基本数据类型和引用类型中缺少值的概念。一个optional类型的变量，在任何时候都可以保存一个值或者为nil。
问题2- Swift 1.0 or later
在Swfit中,什么时候用结构体，什么时候用类？
答案：一直都有这样的争论：到底是用类的做法优于用结构体，还是用结构体的做法优于类。函数式编程倾向于值类型，面向对象编程更喜欢类。
在Swift 中，类和结构体有许多不同的特性。下面是两者不同的总结：
类支持继承，结构体不支持。
类是引用类型，结构体是值类型
并没有通用的规则决定结构体和类哪一个更好用。一般的建议是使用最小的工具来完成你的目标，但是有一个好的经验是多使用结构体，除非你用了继承和引用语义。
想要了解更多，点击这里。
注意：在运行时，结构体的在性能方面更优于类，原因是结构体的方法调用是静态绑定，而类的方法调用是动态实现的。这就是尽可能得使用结构体代替类的又一个好的原因。
问题3- Swift 1.0 or later
什么是泛型？泛型是用来解决什么问题的？
答案：泛型是用来使类型和算法安全的工作的一种类型。在Swift中，在函数和数据结构中都可以使用泛型，例如类、结构体和枚举。
泛型一般是用来解决代码复用的问题。常见的一种情况是，你有一个函数，它带有一个参数，参数类型是A，然而当参数类型改变成B的时候，你不得不复制这个函数。
例如，下面的代码中第二个函数就是复制第一个函数——它仅仅是用String类型代替了Integer类型。
|
1
2
3
4
5
6
7
8
9
10
|
func areIntEqual(x: Int, _ y: Int) -> Bool {
return
x == y
}
func areStringsEqual(x: String, _ y: String) -> Bool {
return
x == y
}
areStringsEqual(
"ray"
,
"ray"
)
// true
areIntEqual(1, 1)
// true
|
Objective-C开发人员可能想到用NSObject类来解决这个问题，代码如下：
|
1
2
3
4
5
6
7
8
|
import Foundation
func areTheyEqual(x: NSObject, _ y: NSObject) -> Bool {
return
x == y
}
areTheyEqual(
"ray"
,
"ray"
)
// true
areTheyEqual(1, 1)
// true
|
这个代码会按照预期的方式工作,但是它在编译时不安全。它允许字符串和整数相比较,像这样:
|
1
|
areTheyEqual(1,
"ray"
)
|
应用程序不会崩溃,但是允许字符串和整数相比较可能不是预想的结果。
通过采用泛型,可以合并这两个函数为一个并同时保持类型安全。下面是代码实现:
|
1
2
3
4
5
6
|
func areTheyEqual(x: T, _ y: T) -> Bool {
return
x == y
}
areTheyEqual(
"ray"
,
"ray"
)
areTheyEqual(1, 1)
|
上面的例子是测试两个参数是否相等，这两个参数的类型受到约束都必须遵循Equatable协议。上面的代码达到预想的结果,并且防止了传递不同类型的参数。
问题4- Swift 1.0 or later
哪些情况下你不得不使用隐式拆包？说明原因。
答案：对optional变量使用隐式拆包最常见的原因如下：
1、对象属性在初始化的时候不能nil,否则不能被初始化。典型的例子是Interface Builder outlet类型的属性，它总是在它的拥有者初始化之后再初始化。在这种特定的情况下，假设它在Interface Builder中被正确的配置——outlet被使用之前，保证它不为nil。
2、解决强引用的循环问题——当两个实例对象相互引用，并且对引用的实例对象的值要求不能为nil时候。在这种情况下，引用的一方可以标记为unowned,另一方使用隐式拆包。
建议：除非必要，不要对option类型使用隐式拆包。使用不当会增加运行时崩溃的可能性。在某些情况下,崩溃可能是有意的行为,但有更好的方法来达到相同的结果,例如,通过使用fatalError( )函数。
问题5- Swift 1.0 or later
对一个optional变量拆包有多少种方法？并在安全方面进行评价。
答案：
-
强制拆包 ！操作符——不安全
-
隐式拆包变量声明——大多数情况下不安全
-
可选绑定——安全
-
自判断链接（optional chaining）——安全
-
nil coalescing 运算符（空值合并运算符）——安全
-
Swift 2.0 的新特性 guard 语句——安全
-
Swift 2.0 的新特性optional pattern（可选模式） ——安全（@Kametrixom支持）
中级
问题1- Swift 1.0 or later
Swift 是面向对象编程语言还是函数式编程语言？
答案：Swift是一种混合编程语言，它包含这两种编程模式。它实现了面向对象的三个基本原则:
-
封装
-
继承
-
多态
说道Swift作为一种函数式编程语言，我们就不得不说一下什么是函数式编程。有很多不同的方法去定义函数式编程语言，但是他们表达的意义相同。
最常见的定义来自维基百科：...它是一种编程规范…它把电脑运算当做数学函数计算，避免状态改变和数据改变。
很难说Swift是一个成熟的函数式语言，但是它已经具备了函数式语言的基础。
问题2- Swift 1.0 or later
下面的功能特性都包含在Swift中吗？
1、泛型类
2、泛型结构体
3、泛型协议
答案：
-
Swift 包含1和2特性。泛型可以在类、结构体、枚举、全局函数或者方法中使用。
-
3是通过typealias部分实现的。typealias不是一个泛型类型,它只是一个占位符的名字。它通常是作为关联类型被引用，只有协议被一个类型引用的时候它才被定义。
问题3- Swift 1.0 or later
在Objective-C中，一个常量可以这样定义：
|
1
|
const int number = 0;
|
类似的Swift是这样定义的：
|
1
|
let number = 0
|
两者之间有什么不同吗？如果有，请说明原因。
答案：const常量是一个在编译时或者编译解析时被初始化的变量。通过let创建的是一个运行时常量，是不可变得。它可以使用stattic 或者dynamic关键字来初始化。谨记它的的值只能被分配一次。
问题4- Swift 1.0 or later
声明一个静态属性或者函数，我们常常使用值类型的static修饰符。下面就是一个结构体的例子：
|
1
2
3
|
struct Sun {
static func illuminate() {}
}
|
对类来说,使用static 或者class修饰符，都是可以的。它们使用后的效果是一样的，但是本质上是不同的。能解释一下为什么不同吗？
答案：
static修饰的属性或者修饰的函数都不可以重写。但是使用class修饰符，你可以重写属性或者函数。
当static在类中应用的时候，static就成为class final的一个别名。
例如，在下面的代码中，当你尝试重写illuminate()函数时，编译器就会报错：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Star {
class func spin() {}
static func illuminate() {}
}
class Sun : Star {
override class func spin() {
super
.spin()
}
override static func illuminate() {
// error: class method overrides a 'final' class method
super
.illuminate()
}
}
|
问题5- Swift 1.0 or later
你能通过extension(扩展)保存一个属性吗？请解释一下原因。
答案：不能。扩展可以给当前的类型添加新的行为，但是不能改变本身的类型或者本身的接口。如果你添加一个新的可存储的属性，你需要额外的内存来存储新的值。扩展并不能实现这样的任务。
高级
问题1- Swift 1.2
在Swift1.2版本中，你能解释一下用泛型来声明枚举的问题吗？拿下面代码中Either枚举来举例说明吧，它有两个泛型类型的参数T和V，参数T在关联值类型为left情况下使用，参数V在关联值为rihgt情况下使用，代码如下：