Go is a statically typed language that supports object-oriented programming(OOP) concepts, but is not an OOP programming language.

One of the key features of Go is its support for struct types and interfaces. A struct is similar to a class in object-oriented languages. Go structs allow mimicking OOP features such as Encapsulation, Abstraction and Inheritance.

• Encapsulation: Go structs can be used to encapsulate data and methods together.

• Inheritance: A struct can contain fields of other structs, which can be used to achieve composition and code reuse.

• Polymorphism: Go doesn't have traditional polymorphism like inheritance-based languages, but it provides interface-based polymorphism.*

• Abstraction: By grouping related data and methods in a struct, the rest of the program can interact with it through a simple interface without knowing the underlying implementation details.

In this blog post, we will discuss Go structs and their usage in the language.

Structs are user-defined types that group together zero or more values under a single name. In Go, a struct is defined using the type keyword followed by the name of the struct and the keyword struct.

type Person struct {
    name string 
    age int 
    netIncome int
    debt int
}

type Employee struct {
    Person
    salary int
}

In the above example, we created Person and Employee structs. Note that the Employee struct implements the Person struct but also has an additional field, salary. We can create a new Person object by initializing its fields with values.

p := Person{name: "John", age: 30, netIncome: 50000, debt: 10000}

Here, we created a Person p and populated the fields with values. We can now have p as an Employee with a salary of ₹60,000.

e := Employee{Person: p, salary: 60000}

Structs can also have methods associated with them, which can be defined as regular functions, with additional receiver arguments.

func (p Person) NetWorth() int {
    return p.netIncome - p.debt
}

In the above example, we defined a method NetWorth() that calculates the net worth of p. By defining the method with p as receiver argument, we can access the fields of p.

In this blog post, we explored the basics of defining and using Go structs by creating a Person and Employee struct with fields and methods, and initializing their values. We also briefly touched on receiver arguments, which are used in defining methods associated with structs.

* Interfaces and Receivers will be covered in detail in future blog posts.