Interface definition in Go - Step-by-Step Execution

Concept Flow - Interface definition

Define interface with method signatures

↓

Create struct type

↓

Implement methods on struct matching interface

↓

Assign struct instance to interface variable

↓

Call interface methods

↓

Use polymorphism

This flow shows how to define an interface, implement it with a struct, assign the struct to the interface, and call its methods.

Execution Sample

Go

package main
import "fmt"
type Speaker interface {
    Speak() string
}
type Person struct {
    Name string
}
func (p Person) Speak() string {
    return "Hello, " + p.Name
}
func main() {
    var s Speaker
    s = Person{Name: "Alice"}
    fmt.Println(s.Speak())
}

This code defines an interface Speaker with one method Speak, implements it with Person struct, assigns a Person to Speaker, and calls Speak.

Execution Table

Step	Action	Evaluation	Result
1	Define interface Speaker with method Speak()	Speaker interface created	Interface ready to use
2	Define struct Person with field Name	Person struct created	Struct ready to use
3	Implement Speak() method on Person	Method matches Speaker interface	Person implements Speaker
4	Declare variable s of type Speaker	s is nil interface variable	s ready to hold Speaker
5	Assign Person{Name: "Alice"} to s	Person instance assigned to s	s holds Person as Speaker
6	Call s.Speak()	Calls Person.Speak()	Returns "Hello, Alice"
7	Print output	Output printed to console	Hello, Alice
8	Program ends	No more code	Execution stops

💡 Program ends after printing the greeting from the interface method

Variable Tracker

Variable	Start	After Step 5	After Step 6	Final
s	nil	Person{Name: "Alice"}	Person{Name: "Alice"}	Person{Name: "Alice"}

Key Moments - 3 Insights

Why can we assign a Person struct to a Speaker interface variable?

Because Person has a method Speak() with the same signature as the Speaker interface requires, so Go treats Person as implementing Speaker (see execution_table step 5).

What happens when we call s.Speak() if s holds a Person?

The Speak() method of Person is called, returning the greeting string (see execution_table step 6).

Why is the interface variable s initially nil?

Because declaring var s Speaker creates an interface variable with no value until assigned (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of variable s after step 5?

A Person{Name: "Alice"}

B nil

C Speaker interface type

D Empty struct

💡 Hint

Check variable_tracker column 'After Step 5' for s value

At which step does the program call the Speak() method?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

See execution_table row where Action is 'Call s.Speak()'

If Person did not implement Speak(), what would happen when assigning to s?

A s would hold a nil value

B Assignment would fail with a compile error

C Program would panic at runtime

D Assignment would succeed but method call fail

💡 Hint

Interfaces require matching methods; see key_moments about assignment

Concept Snapshot

Interface definition in Go:
- Use 'type Name interface { MethodSignatures }'
- Any type with matching methods implements the interface
- Assign instances to interface variables
- Call methods via interface for polymorphism
- No explicit 'implements' keyword needed

Full Transcript

This example shows how to define an interface named Speaker with one method Speak. Then we create a struct Person with a Name field. We implement the Speak method on Person to return a greeting string. In main, we declare a variable s of type Speaker, initially nil. We assign a Person instance with Name 'Alice' to s. Because Person implements Speak, this assignment works. Calling s.Speak() calls Person's method and returns 'Hello, Alice'. Finally, we print the result. The program ends after printing. This demonstrates Go's interface definition and usage with method implementation and polymorphism.

Practice

1. What does an interface in Go define?

easy

A. A concrete type with fields and methods

B. A variable that holds data

C. A set of method signatures without implementation

D. A function that returns multiple values

Solution

1. Step 1: Understand what an interface is

   An interface in Go specifies method signatures but does not provide their implementation.

2. Step 2: Differentiate from other types

   Concrete types have fields and method implementations, unlike interfaces.

3. Final Answer:

   A set of method signatures without implementation -> Option C

4. Quick Check:

   Interface = method signatures only [OK]

Hint: Interfaces list methods only, no code inside [OK]

Common Mistakes:

• Thinking interfaces hold data
• Confusing interfaces with structs
• Assuming interfaces implement methods

2. Which of the following is the correct syntax to define an interface named Shape with a method Area() returning a float64?

easy

A. func Shape interface { Area() float64 }

B. interface Shape { func Area() float64 }

C. type Shape struct { Area() float64 }

D. type Shape interface { Area() float64 }

Solution

1. Step 1: Recall Go interface syntax

   Interfaces are defined with the keyword type, name, then interface and method signatures inside braces.

2. Step 2: Check each option

   type Shape interface { Area() float64 } matches correct syntax. Options B, C, and D misuse keywords or structure.

3. Final Answer:

   type Shape interface { Area() float64 } -> Option D

4. Quick Check:

   Correct interface syntax = type Shape interface { Area() float64 } [OK]

Hint: Use 'type Name interface { methods }' for interfaces [OK]

Common Mistakes:

• Using 'interface' keyword alone without 'type'
• Defining methods inside struct instead of interface
• Placing 'func' keyword inside interface method

3. What will be the output of this Go code?

package main
import "fmt"
type Printer interface {
    Print()
}
type Document struct {
    content string
}
func (d Document) Print() {
    fmt.Println(d.content)
}
func main() {
    var p Printer
    d := Document{"Hello, Go!"}
    p = d
    p.Print()
}

medium

A. Runtime panic: nil pointer dereference

B. Hello, Go!

C. Compilation error: cannot assign Document to Printer

D. No output

Solution

1. Step 1: Check interface implementation

   Document has a method Print() matching Printer interface, so Document implements Printer.

2. Step 2: Assign and call method

   Variable p of type Printer is assigned d (Document), then p.Print() calls Document.Print(), printing content.

3. Final Answer:

   Hello, Go! -> Option B

4. Quick Check:

   Interface method calls concrete method [OK]

Hint: Assign concrete type with matching methods to interface [OK]

Common Mistakes:

• Thinking interface needs explicit implementation declaration
• Expecting compile error on assignment
• Assuming interface variable is nil

4. Identify the error in this Go code snippet:

type Reader interface {
    Read(p []byte) (n int, err error)
}
type File struct {}
func (f File) Read() (int, error) {
    return 0, nil
}

medium

A. Method Read has wrong signature, missing parameter

B. File does not implement Reader because it lacks Read method

C. Interface Reader cannot have methods with parameters

D. No error, code is correct

Solution

1. Step 1: Compare method signatures

   Reader interface expects Read with parameter []byte and two return values.

2. Step 2: Check File's Read method

   File's Read method has no parameters, so signature does not match interface.

3. Final Answer:

   Method Read has wrong signature, missing parameter -> Option A

4. Quick Check:

   Method signature must match interface [OK]

Hint: Method signatures must exactly match interface methods [OK]

Common Mistakes:

• Ignoring method parameters in implementation
• Assuming method name alone is enough
• Thinking interface methods can't have parameters

5. Given these interfaces and types:

type Reader interface {
    Read(p []byte) (n int, err error)
}
type Writer interface {
    Write(p []byte) (n int, err error)
}
type ReadWriter interface {
    Reader
    Writer
}
type MyFile struct {}
func (f MyFile) Read(p []byte) (int, error) {
    return len(p), nil
}
func (f MyFile) Write(p []byte) (int, error) {
    return len(p), nil
}

Which statement is true about MyFile and ReadWriter?

hard

A. MyFile implements ReadWriter because it has both Read and Write methods

B. MyFile only implements Reader, not ReadWriter

C. MyFile does not implement any interface

D. ReadWriter cannot embed other interfaces

Solution

1. Step 1: Understand interface embedding

   ReadWriter embeds Reader and Writer, so it requires both methods.

2. Step 2: Check MyFile methods

   MyFile has both Read and Write methods matching signatures.

3. Step 3: Confirm implementation

   Since MyFile has all required methods, it implements ReadWriter.

4. Final Answer:

   MyFile implements ReadWriter because it has both Read and Write methods -> Option A

5. Quick Check:

   Embedded interfaces require all methods [OK]

Hint: Embedded interfaces combine methods; implement all to satisfy [OK]

Common Mistakes:

• Thinking embedding interfaces is invalid
• Assuming partial method implementation suffices
• Confusing interface embedding with inheritance