# Go Programming Course
## Week 3: Custom Types and Interfaces
Version 1.0 - January 2025
## Table of Contents
1. Collection Types
- Arrays
- Slices
- Maps
2. Module 05: Structs
- Basic Concepts
- Methods
- Composition
- Tags and Serialization
3. Module 06: Interfaces
- Interface Basics
- Empty Interface
- Type Assertions
- Common Patterns
---
# Collection Types in Go
## Arrays
Arrays in Go provide fixed-size, ordered collections of elements. Understanding arrays is
fundamental to working with more complex data structures.
### Key Concepts
1. Fixed Size
2. Zero-based Indexing
3. Type Consistency
4. Value Semantics
### Basic Array Operations
```go
// Declaration and initialization
var numbers [5]int // Zero-valued array
cities := [4]string{
"New York",
"London",
"Tokyo",
"Paris",
}
// Accessing elements
firstCity := cities[0] // "New York"
cities[1] = "Berlin" // Modifying an element
// Array length
length := len(cities) // 4
```
## Slices
Slices provide dynamic, flexible views into arrays. They are the most commonly used
collection type in Go.
### Key Features
1. Dynamic Size
2. Reference Type
3. Built-in Append Function
4. Capacity Management
### Working with Slices
```go
// Creating slices
numbers := []int{1, 2, 3, 4, 5}
subset := numbers[1:4] // [2, 3, 4]
// Using make
dynamicSlice := make([]int, 3, 5) // Length 3, Capacity 5
// Appending elements
numbers = append(numbers, 6, 7)
```
## Maps
Maps implement key-value pair storage, providing fast lookups and flexible data
organization.
### Essential Operations
```go
// Map creation
ages := map[string]int{
"Alice": 30,
"Bob": 25,
}
// Adding and accessing
ages["Charlie"] = 35
aliceAge := ages["Alice"]
// Checking existence
value, exists := ages["David"]
if !exists {
fmt.Println("David not found")
}
```
---
# Module 05: Structs
## Basic Struct Concepts
### Definition and Creation
Structs group related data into a single unit, forming the basis for custom types in Go.
```go
type Person struct {
Name string
Age int
Address Address
}
type Address struct {
Street string
City string
Country string
}
// Creating instances
person := Person{
Name: "Alice Johnson",
Age: 30,
Address: Address{
Street: "123 Go Lane",
City: "Techville",
Country: "Gopher Land",
},
}
```
### Methods and Receivers
```go
// Value receiver
func (p Person) GetFullName() string {
return p.Name
}
// Pointer receiver
func (p *Person) Birthday() {
p.Age++
}
```
## Struct Composition
Go uses composition over inheritance, allowing for flexible type creation.
```go
type Employee struct {
Person // Embedded struct
Position string
Salary float64
}
func (e Employee) GetSalaryDetails() string {
return fmt.Sprintf("%s earns %.2f", e.Name, e.Salary)
}
```
---
# Module 06: Interfaces
## Interface Basics
Interfaces define behavior through method signatures, enabling polymorphic code design.
### Definition and Implementation
```go
type Writer interface {
Write([]byte) (int, error)
}
type FileWriter struct {
filename string
}
func (fw FileWriter) Write(data []byte) (int, error) {
return len(data), nil
}
```
## Empty Interface and Type Assertions
The empty interface (`interface{}`) can hold values of any type, requiring type assertions for
specific operations.
```go
func processValue(v interface{}) {
switch val := v.(type) {
case int:
fmt.Printf("Integer: %d\n", val)
case string:
fmt.Printf("String: %s\n", val)
default:
fmt.Printf("Unknown type\n")
}
}
```
## Best Practices
### Struct Best Practices
1. Keep structs focused and cohesive
2. Use pointer receivers for methods that modify state
3. Leverage composition for code reuse
4. Document exported fields and methods
### Interface Best Practices
1. Keep interfaces small and focused
2. Design interfaces for behavior, not data
3. Use composition to build larger interfaces
4. Implement interfaces implicitly
## Practice Exercises
### Struct Exercises
1. Create a Library Management System
- Design book and member structs
- Implement checkout system
- Handle due dates and fines
2. Build a Shape Calculator
- Define different shapes using structs
- Implement area and perimeter methods
- Use composition for complex shapes
### Interface Exercises
1. Implement a Logging System
- Define logger interface
- Create multiple logger implementations
- Support different output formats
2. Design a Payment System
- Create payment processor interface
- Implement different payment methods
- Handle transaction validation
## Additional Resources
1. Go Documentation: https://golang.org/doc/
2. Go by Example: https://gobyexample.com/
3. Effective Go: https://golang.org/doc/effective_go
4. Go Playground: https://play.golang.org/
---
© 2025 Go Programming Course. All rights reserved.
