How does Go handle object-oriented programming?

Go is not a pure object-oriented programming language, but it does support some of the key features of object-oriented programming, such as encapsulation, abstraction, and polymorphism, through the use of structs and interfaces.

In Go, structs are used to define custom data types that can contain fields and methods. Methods can be defined for a struct by associating a function with the struct using the **func** keyword and a receiver type. For example:

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

This code defines a **Rectangle** struct that has a **Width** and **Height** field, and an **Area** method that calculates the area of the rectangle. The **Area** method is associated with the **Rectangle** struct using the **(r Rectangle)** syntax, which specifies that the **Area** method has a receiver of type **Rectangle**.

Interfaces in Go are used to define a set of methods that a type must implement in order to satisfy the interface. This allows for polymorphism, where a single variable can hold values of multiple different types that satisfy the same interface. For example:

type Shape interface {
    Area() float64
}

func PrintArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

r := Rectangle{Width: 10, Height: 5}
PrintArea(r)

In this code, we define a **Shape** interface that has an **Area** method, and a **PrintArea** function that takes a **Shape** as its parameter and prints its area. We then create a **Rectangle** and pass it to the **PrintArea** function. Since the **Rectangle** struct has an **Area** method that satisfies the **Shape** interface, it can be passed to the **PrintArea** function.

Overall, while Go does not have some of the more advanced features of object-oriented programming, such as inheritance, it does provide a flexible and powerful set of tools for structuring code using structs and interfaces.