<p>From <a href="http://learnxinyminutes.com/docs/go/">http://learnxinyminutes.com/docs/go/</a></p>
<pre><code>// Define Stringer as an interface type with one method, String.
type Stringer interface {
String() string
}
// Define pair as a struct with two fields, ints named x and y.
type pair struct {
x, y int
}
// Define a method on type pair. ****Pair now implements Stringer.****
func (p pair) String() string { // p is called the "receiver"
// Sprintf is another public function in package fmt.
// Dot syntax references fields of p.
return fmt.Sprintf("(%d, %d)", p.x, p.y)
}
</code></pre>
<p>My problem is the part inside ****. </p>
<p>How does pair implement <strong>Stringer</strong>?<br/>
It's the first time I'm learning Go, and to me it looks like pair now implements String.</p>
<hr/>**评论：**<br/><br/>TheMerovius: <pre><blockquote>
<p>How does pair implement Stringer?
It's the first time I'm learning Go, and to me it looks like pair now implements String.</p>
</blockquote>
<p>pair get's the Method <code>String() string</code>. A <code>Stringer</code> is anything that has a method <code>String() string</code>. Thus, pair now implements the <code>Stringer</code> interface.</p>
<p>In go, that's just how interfaces work: You define a set of methods and you can then use it as a type (e.g. for a variable). Anything that has these methods with the correct <del>type</del> signature, will implement the interface.</p>
<p>You can also look at <a href="http://play.golang.org/p/tzP4mO14Gd">this</a> and play around a bit. When you remove or comment out lines 47 and 49 (and 33), it also compiles (but look at the compiler-error first).</p>
<p>[edit] s/numbers/methods/ weird freudian typo…</p></pre>drvd: <pre><p>Maybe you should take the Tour of Go (<a href="http://tour.golang.org/welcome/1">http://tour.golang.org/welcome/1</a>) first.</p></pre>bbrazil: <pre><p>The convention is that when you define such a method, you mention which interface it's part of. So by implementing String(), you're implementing (in this case all of) the Stringer interface.</p></pre>jerf: <pre><p>As an exercise, take this exact file, and:</p>
<ul>
<li>Add <code>var _ Stringer = pair{1, 2}</code> to the top level. This essentially creates an assertion that <code>pair</code> implements <code>Stringer</code>.</li>
<li>Compile to see that it's working.</li>
<li>Add another method to the Stringer interface, say, <code>NotImplemented()</code>.</li>
<li>Compile again. Observe the error message.</li>
<li>Now, fix it by adding something to <code>pair</code>.</li>
</ul>
<p>And, well, that's pretty much what it takes to implement interfaces in Go. The only slightly tricky thing is that you have to match pointer or non-pointer receivers on all the methods, and when directly assigning in to an interface, you have to match the correct level of pointerness. (Once it's "in" the interface, it's all opaque to you and you can stop thinking about it.)</p></pre>binaryblade: <pre><p>This is the fundamental nature of interfaces, you never have to declare that you support an interface. The fact that your "object" implements all the methods of the interface means that the object implements the interface. It is an automagic property. Pair implements a method called String() string. This is the only method required to satisfy the Stringer interface, therefore, pair can be a stringer. You can say, it walks like a duck, talks like a duck therefore it is a duck. </p></pre>umegastar: <pre><p>Thanks everybody, now I understand.</p></pre>dmikalova: <pre><p>By implementing String, pair satisfies the interface for Stringer, and thus implements Stringer.</p>
<p>It's that simple :)</p></pre>
