andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update new articles

Browse Source
This commit is contained in:
numbbbbb
2014-06-10 15:57:35 +08:00
parent 0778a2e5fc
commit f6c0a09e6e
41 changed files with 408 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
chapter2/11_Methods.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.11" data-basepath=".." data-revision="1402386668059">
<div class="book" data-level="2.11" data-basepath=".." data-revision="1402387034522">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,15 +587,15 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_415">
<section class="normal" id="section-gitbook_33">
<h1 id="-methods-">方法(Methods)</h1>
<p><strong>方法</strong>是与某些特定类型相关联的功能/函数。类、结构体、枚举都可以定义实例方法；实例方法为指定类型的实例封装了特定的任务与功能。类、结构体、枚举也可以定义类(型)方法(type itself)；类型方法与类型自身相关联。类型方法与Objective-C中的类方法(class methods)相似。</p>
<p>在Swift中,结构体和枚举能够定义方法；事实上这是Swift与C/Objective-C的主要区别之一。在Objective-C中,类是唯一能定义方法的类型。在Swift中，你能够选择是否定义一个类/结构体/枚举，并且你仍然享有在你创建的类型(类/结构体/枚举)上定义方法的灵活性。</p>
<p><strong>方法</strong>是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型自身相关联。类型方法与Objective-C中的类方法(class methods)相似。</p>
<p>在Swift中,结构体和枚举能够定义方法；事实上这是Swift与C/Objective-C的主要区别之一。在Objective-C中,类是唯一能定义方法的类型。但在Swift中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型(类/结构体/枚举)上定义方法。</p>
<h3 id="-instance-methods-">实例方法(Instance Methods)</h3>
<p><strong>实例方法</strong>是某个特定类、结构体或者枚举类型的实例的方法。实例方法支撑实例的功能: 或者提供方法,以访问和修改实例属性;或者提供与实例的目的相关的功能。实例方法的语法与函数完全一致，参考<a href="functions.html" title="函数说明">函数说明</a>。</p>
<p>实例方法要写在它所属的类型的前后括号之间。实例方法能够访问他所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的特定实例调用。实例方法不能被孤立于现存的实例而被调用。</p>
<p>下面是定义一个很简单的类<code>Counter</code>的例子(<code>Counter</code>能被用来对一个动作发生的次数进行计数):</p>
<p><strong>实例方法</strong>是某个特定类、结构体或者枚举类型的实例的方法。实例方法支撑实例的功能: 或者提供方法,以访问和修改实例属性;或者提供与实例的目的相关的功能。实例方法的语法与函数完全一致，你可以参考<a href="../charpter2/06_Functions.html">函数</a>。</p>
<p>实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。</p>
<p>下面的例子，定义一个很简单的类<code>Counter</code>，<code>Counter</code>能被用来对一个动作发生的次数进行计数:</p>
<pre><code>class Counter {
var count = 0
func increment() {
@ -608,7 +608,7 @@
count = 0
}
}
</code></pre><p><code>Counter</code>类定理了三个实例方法：</p>
</code></pre><p><code>Counter</code>类定义了三个实例方法：</p>
<ul>
<li><code>increment</code>让计数器按一递增；</li>
<li><code>incrementBy(amount: Int)</code>让计数器按一个指定的整数值递增；</li>
@ -625,10 +625,9 @@
counter.reset()
// the counter&#39;s value is now 0
</code></pre><h3 id="-local-and-external-parameter-names-for-methods-">方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)</h3>
<p>函数参数有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用),参考<a href="external_parameter_names.html">External Parameter Names</a>。对于方法参数也是这样，因为方法就是函数(只是这个函数与某个类型相关联了)。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。</p>
<p>Swift中的方法和Objective-C中的方法极其相似。像在Objective-C中一样，Swift中方法的名称通常用一个介词指向方法的第一个参数，比如：<code>with</code>,<code>for</code>,<code>by</code>等等。前面的<code>Counter</code>类的例子中<code>incrementBy</code>方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。Swift这种方法命名约定很容易落实,因为它是用不同的默认处理方法参数的方式，而不是用函数参数(来实现的)。</p>
<p>具体来说，Swift默认仅给方法的第一个参数名称一个局部参数名称;但是默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。
这个约定与典型的命名和调用约定相匹配，这与你在写Objective-C的方法时很相似。这个约定还让expressive method调用不需要再检查/限定参数名。</p>
<p>函数参数可以同时有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用),参考<a href="../06_Functions.html">函数的外部参数名</a>。方法参数也一样(因为方法就是函数，只是这个函数与某个类型相关联了)。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。</p>
<p>Swift中的方法和Objective-C中的方法极其相似。像在Objective-C中一样，Swift中方法的名称通常用一个介词指向方法的第一个参数，比如：<code>with</code>,<code>for</code>,<code>by</code>等等。前面的<code>Counter</code>类的例子中<code>incrementBy</code>方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。Swift这种方法命名约定让书写代码更容易了,因为Swift依靠对方法参数不同的默认处理方式，而不是靠函数参数，来实现方法命名。</p>
<p>具体来说，Swift默认仅给方法的第一个参数名称一个局部参数名称;但是默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，这与你在写Objective-C的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。</p>
<p>看看下面这个<code>Counter</code>的替换版本（它定义了一个更复杂的<code>incrementBy</code>方法）：</p>
<pre><code>class Counter {
var count: Int = 0
@ -641,25 +640,23 @@
counter.incrementBy(5, numberOfTimes: 3)
// counter value is now 15
</code></pre><p>你不必为第一个参数值再定义一个外部变量名：因为从函数名<code>incrementBy</code>已经能很清楚地看出它的目的/作用。但是第二个参数，就要被一个外部参数名称所限定,以便在方法被调用时让他目的/作用明确。</p>
<p>这种默认的行为能够有效的检查方法，比如你在参数numberOfTimes前写了个井号( <code>#</code> )时:</p>
<p>这种默认的行为能够有效的处理方法，比如你在参数numberOfTimes前写了个井号( <code>#</code> )时:</p>
<pre><code>func incrementBy(amount: Int, #numberOfTimes: Int) {
count += amount * numberOfTimes
}
</code></pre><p>这种默认行为使上面代码意味着：在Swift中定义方法使用了与Objective-C同样的语法风格，并且方法将以自然表达式的方式被调用。</p>
<h3 id="-modifying-external-parameter-name-behavior-for-methods-">修改外部参数名称(Modifying External Parameter Name Behavior for Methods)</h3>
<p>有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个明确的外部名称;你也可以用一个hash符号作为第一个参数的前缀，然后用这个局部名字作为外部名字。</p>
<h3 id="-modifying-external-parameter-name-behavior-for-methods-">修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)</h3>
<p>有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称;你也可以用一个hash符号作为第一个参数的前缀，把这个局部名称呢更作为外部名称。</p>
<p>相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，你可以通过使用下划线(<code>_</code>)作为该参数的显式外部名称来覆盖默认行为。</p>
<h3 id="-self-the-self-property-"><code>self</code>属性(The self Property)</h3>
<p>类型的每一个实例都有一个隐含属性叫做<code>self</code>，它完全等同于这个实力变量本身。你可以在一个实例的实例方法中使用这个隐含的<code>self</code>属性来引用当前实例。</p>
<p>上面例子中的<code>increment</code>方法可以被写成这样：</p>
<p>类型的每一个实例都有一个隐含属性叫做<code>self</code>，<code>self</code>完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的<code>self</code>属性来引用当前实例。</p>
<p>上面例子中的<code>increment</code>方法还可以这样写：</p>
<pre><code>func increment() {
self.count++
}
</code></pre><p>实际上，你不必在你的代码里面经常写<code>self</code>。不论何时，在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写<code>self</code>，Swift假定你是指当前实例的属性或者方法。这种假定在上面的<code>Counter</code>中已经示范了：<code>Counter</code>中的三个实例方法中都使用的是<code>count</code>(而不是<code>self.count</code>)</p>
<p>这条规则的主要例外发生在当实例方法的某个参数名称与实例的某个属性名称相同时。
在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更恰当(被限定更严格)的方式。
你可以使用隐藏的<code>self</code>属性来区分参数名称和属性名称。</p>
<p>下面的例子演示了<code>self</code>消除方法参数<code>x</code>和实例属性<code>x</code>之间的歧义：</p>
<p>这条规则的主要例外发生在当实例方法的某个参数名称与实例的某个属性名称相同时。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更恰当(被限定更严格)的方式。你可以使用<code>self</code>属性来区分参数名称和属性名称。</p>
<p>下面的例子中，<code>self</code>消除方法参数<code>x</code>和实例属性<code>x</code>之间的歧义：</p>
<pre><code>struct Point {
var x = 0.0, y = 0.0
func isToTheRightOfX(x: Double) -&gt; Bool {
@ -673,8 +670,8 @@ if somePoint.isToTheRightOfX(1.0) {
// prints &quot;This point is to the right of the line where x == 1.0&quot;
</code></pre><p>如果不使用<code>self</code>前缀，Swift就认为两次使用的<code>x</code>都指的是名称为<code>x</code>的函数参数。</p>
<h3 id="-modifying-value-types-from-within-instance-methods-">在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)</h3>
<p>结构体和枚举是<strong>值类型</strong><a href="&quot;#&quot;">Structures and Enumerations Are Value Types</a>。一般情况下，值类型的属性不能在他的实例方法中被修改。</p>
<p>但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择<code>变异(mutating)</code>这个方法。方法可以从内部变异它的属性；并且它做的任何改变在方法结束时都会回写到原始结构。方法会给它隐含的<code>self</code>属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。</p>
<p>结构体和枚举是<strong>值类型</strong>。一般情况下，值类型的属性不能在它的实例方法中被修改。</p>
<p>但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择<code>变异(mutating)</code>这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时都会回写到原始结构。方法还可以给它隐含的<code>self</code>属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。</p>
<p>要<code>变异</code>方法, 将关键字<code>mutating</code> 放到方法的<code>func</code>关键字之前就可以了：</p>
<pre><code>struct Point {
var x = 0.0, y = 0.0
@ -687,8 +684,8 @@ var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveByX(2.0, y: 3.0)
println(&quot;The point is now at (\(somePoint.x), \(somePoint.y))&quot;)
// prints &quot;The point is now at (3.0, 4.0)&quot;
</code></pre><p>上面的Point结构体定义了一个变异方法(mutating method)<code>moveByX</code>，<code>moveByX</code>用来移动一个point。<code>moveByX</code>方法在被调用时修改了这个point,而不是返回一个新的point。方法定义是加上那个了<code>mutating</code>关键字,所以方法可以修改值类型的属性了。</p>
<p>注意：不能在结构体类型的常量上调用变异方法,因为常量的属性不能被改变,就算你想改变的是常量的可变属性也不行，参考<a href="&quot;#&quot;">Stored Properties of Constant Structure Instances</a></p>
</code></pre><p>上面的Point结构体定义了一个变异方法(mutating method)<code>moveByX</code>，<code>moveByX</code>用来移动一个point。<code>moveByX</code>方法在被调用时修改了这个point,而不是返回一个新的point。方法定义时加上<code>mutating</code>关键字,这才让方法可以修改值类型的属性了。</p>
<p>注意：不能在结构体类型的常量上调用变异方法,因为常量的属性不能被改变,就算你想改变的是常量的可变属性也不行，参考<a href="&quot;../10_Properties&quot;">存储属性和实例变量</a></p>
<pre><code>let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveByX(2.0, y: 3.0)
// this will report an error
@ -700,8 +697,8 @@ fixedPoint.moveByX(2.0, y: 3.0)
self = Point(x: x + deltaX, y: y + deltaY)
}
}
</code></pre><p>新版的变异方法<code>moveByX</code>创建了一个新的分支结构(他的x和y的值都被设定为目标值了)。调用这个版本的方法和调用上个版本的最终结果是一样的。</p>
<p>枚举的变异方法可以让<code>self</code>从相同的枚举设置为不同的成员。</p>
</code></pre><p>新版的变异方法<code>moveByX</code>创建了一个新的结构(它的x和y的值都被设定为目标值了)。调用这个版本的方法和调用上个版本的最终结果是一样的。</p>
<p>枚举的变异方法可以让<code>self</code>从相同的枚举设置为不同的成员：</p>
<pre><code>enum TriStateSwitch {
case Off, Low, High
mutating func next() {
@ -778,7 +775,7 @@ SomeClass.someTypeMethod()
player.completedLevel(1)
println(&quot;highest unlocked level is now \(LevelTracker.highestUnlockedLevel)&quot;)
// prints &quot;highest unlocked level is now 2&quot;
</code></pre><p>如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，你试图去设置玩家当前等级时会失败的：</p>
</code></pre><p>如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，当你试图去设置玩家当前等级时会失败的：</p>
<pre><code>player = Player(name: &quot;Beto&quot;)
if player.tracker.advanceToLevel(6) {
println(&quot;player is now on level 6&quot;)