Interface

Interface is a reference type which contains some method definitions. Any type which implements all the methods defined by a reference type will satisfy this interface type automatically. Through interface, you can approach object-oriented programming. Check the following example: 

  1. package main
  3. import "fmt"
  5. type Foo interface {
  6.     foo()
  7. }
  9. type A struct {
  10. }
  12. func (a A) foo() {
  13.     fmt.Println("A foo")
  14. }
  16. func (a A) bar() {
  17.     fmt.Println("A bar")
  18. }
  20. func callFoo(f Foo) {
  21.     f.foo()
  22. }
  24. func main() {
  25.     var a A
  26.     callFoo(a)
  27. }

The running result is: 

  1. A foo

Let’s analyze the code detailedly:

(1) 

  1. type Foo interface {
  2.     foo()
  3. }

The above code defines a interface Foo which has only one method: foo().

(2) 

  1. type A struct {
  2. }
  4. func (a A) foo() {
  5.     fmt.Println("A foo")
  6. }
  8. func (a A) bar() {
  9.     fmt.Println("A bar")
  10. }

struct A has 2 methods: foo() and bar(). Since it already implements foo() method, it satisfies Foo interface.

(3) 

  1. func callFoo(f Foo) {
  2.     f.foo()
  3. }
  5. func main() {
  6.     var a A
  7.     callFoo(a)
  8. }

callFoo requires a variable whose type is Foo interface, and passing A is OK. The callFoo will use A‘s foo() method, and “A foo“ is printed.

Let’s change the main() function: 

  1. func main() {
  2.     var a A
  3.     callFoo(&a)
  4. }

This time, the argument of callFoo() is &a, whose type is *A. Compile and run the program, you may find it also outputs: “A foo“. So *A type has all the methods which A has. But the reverse is not true: 

  1. package main
  3. import "fmt"
  5. type Foo interface {
  6.     foo()
  7. }
  9. type A struct {
  10. }
  12. func (a *A) foo() {
  13.     fmt.Println("A foo")
  14. }
  16. func (a *A) bar() {
  17.     fmt.Println("A bar")
  18. }
  20. func callFoo(f Foo) {
  21.     f.foo()
  22. }
  24. func main() {
  25.     var a A
  26.     callFoo(a)
  27. }

Compile the program: 

  1. example.go:26: cannot use a (type A) as type Foo in argument to callFoo:
  2. A does not implement Foo (foo method has pointer receiver)

You can see also *A type has implemented foo() and bar() methods, it doesn’t mean A type has both methods by default.

BTW, every type satisfies the empty interface: interface{}.

The interface type is actually a tuple which contains 2 elements: <type, value>, type identifies the type of the variable which stores in the interface while value points to the actual value. The default value of an interface type is nil, which means both type and value are nil: <nil, nil>. When you check whether an interface is empty or not: 

  1. var err error
  2. if err != nil {
  3.     ...
  4. }

You must remember only if both type and value are nil means the interface value is nil.

Reference:
The Go Programming Language.