Methods and Interfaces

# CHAPTER 15

Methods and Interfaces #

1. Introduction #

2. Learning Objectives #

• Define Methods using Receiver Functions.

• Understand Value Receivers vs Pointer Receivers.

• Define an Interface.

• Understand implicit Interface implementation.

• Use Interfaces to achieve Polymorphism.

3. Methods (Receiver Functions) #

package main
import "fmt"

type Circle struct {
    Radius float64
}

// Method with a Receiver of type Circle
// 'c' is the variable name representing the specific struct instance
func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func main() {
    myCircle := Circle{Radius: 5}
    
    // We call the method using dot notation!
    fmt.Println("Area:", myCircle.Area()) 
}

4. Value vs Pointer Receivers (CRITICAL) #

• Value Receiver (func (c Circle)): The method receives a *copy* of the struct. If the method changes a field, the original struct is NOT modified.

• Pointer Receiver (func (c *Circle)): The method receives a *pointer* to the struct. The method CAN modify the original struct.

*Rule of Thumb: Almost always use Pointer Receivers.*

type User struct {
    Name string
    Age  int
}

// Pointer Receiver: Can modify the original User
func (u *User) HaveBirthday() {
    u.Age++ 
}

func main() {
    u := User{Name: "Alice", Age: 20}
    u.HaveBirthday()
    fmt.Println(u.Age) // Prints 21! 
}

5. Interfaces (The Magic of Go) #

// 1. Define the Interface
type Animal interface {
    Speak() string
}

// 2. Create Structs
type Dog struct{}
type Cat struct{}

// 3. Attach Methods
func (d Dog) Speak() string { return "Woof!" }
func (c Cat) Speak() string { return "Meow!" }

// 4. Polymorphism in Action
// This function accepts ANY struct that implements the Animal interface
func MakeSound(a Animal) {
    fmt.Println(a.Speak())
}

func main() {
    d := Dog{}
    c := Cat{}

    // Both can be passed into MakeSound because both have a Speak() method!
    MakeSound(d) 
    MakeSound(c) 
}

6. The Empty Interface interface{} #

// Accepts int, string, struct, anything!
func PrintAnything(v interface{}) {
    fmt.Println("You passed:", v)
}

*(Note: In modern Go 1.18+, the keyword any was introduced as an exact alias for interface{} to make code cleaner).*

7. Common Mistakes #

• Mixing Value and Pointer Receivers: If you use a Pointer Receiver for one method of a struct, you should use Pointer Receivers for ALL methods of that struct to maintain consistency.

• Overusing Interfaces: Don't create interfaces for everything. Go philosophy: "Return concrete types, accept interfaces." Only create an interface when you actually have multiple different structs that need to be passed into the same function.

8. Best Practices #

• Keep Interfaces Small: In Go, the best interfaces have only 1 or 2 methods. The standard library is full of tiny interfaces like Reader (has 1 method) and Writer (has 1 method).

9. Exercises #

1. 1. Create a Rectangle struct with Width and Height.

1. 2. Create a Pointer Receiver method Scale(factor int) that multiplies the width and height by the factor.

1. 3. Call it in main() and print the new dimensions.

10. MCQs with Answers & Explanations #

11. Interview Preparation #

1. 1. Explain the difference between a Value Receiver and a Pointer Receiver. When would you use each?

1. 2. How does Go achieve Polymorphism without Inheritance?

1. 3. What is an Empty Interface, and what is the modern alias for it?

12. Summary #

13. Next Chapter Recommendation #