Understanding Golang Object Oriented Programming (OOP) with Examples
Tags: go, programming, learning
Published: 2023-05-18 03:45:37

### Introduction 
 Object-oriented programming (OOP) is a popular programming paradigm that emphasizes the use of objects and their interactions to design and build applications. Go is not a pure object-oriented language like Java or Python, but it does support many OOP concepts like encapsulation, abstraction, inheritance, and polymorphism. In this article, we will explore how to write object-oriented programs in Go. 
### Defining a Class 
 In Go, we define classes as structures. A class is a collection of attributes (fields) and behaviors (methods). Here's an example of a class representing a  Person :

```
type Person struct {
    Name   string
    Age    int
    Gender string
}
```
This defines a class  Person  with the three fields  Name ,  Age , and  Gender . 

### Creating an Object 
 In Go, we create an object by instantiating a structure. We can create an object of class  Person  like this:

```
person := Person{Name: "John Doe", Age: 30, Gender: "Male"}
```
This creates an object  person  with the values  "John Doe" ,  30 , and  "Male" . 
### Encapsulation 
 Encapsulation is the concept of wrapping data and methods inside a single unit. In Go, encapsulation is achieved by using a naming convention for fields and methods: Private fields and methods start with a lowercase letter, while public fields and methods start with an uppercase letter. 
 Here's an example of a  Person  class with private fields and public methods:

```
type Person struct {
    name   string
    age    int
    gender string
}
func (p *Person) SetName(name string) {
    p.name = name
}
func (p *Person) GetName() string {
    return p.name
}
```
In this example, we've made the fields  name ,  age , and  gender  private by using lowercase letters. We've also defined two public methods  SetName()  and  GetName()  to access and modify the value of the  name  field. 
### Abstraction 
 Abstraction is the process of hiding implementation details while showing only the necessary information to the user. In Go, we can achieve abstraction by using interfaces. An interface specifies a set of methods that a struct must implement to satisfy the interface. 
 Here's an example:

```
type Animal interface {
    Speak() string
}
type Dog struct {
    Name string
}
func (d Dog) Speak() string {
    return "Woof!"
}
type Cat struct {
    Name string
}
func (c Cat) Speak() string {
    return "Meow!"
}
func main() {
    animals := []Animal{Dog{Name: "Fido"}, Cat{Name: "Fluffy"}}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}
```
In this example, we've defined an interface  Animal  with a single method  Speak() . We've also defined two implementations of this interface:  Dog  and  Cat . We can now create a list of  Animal  objects and call the  Speak()  method on each of them to get their respective sounds. 
### Inheritance 
 Inheritance is the concept of creating a new class from an existing class. In Go, we achieve inheritance using composition. Composition is the process of combining different structures to create a new one. 
 Here's an example:

```
type Animal struct {
    Name   string
    Origin string
}
type Bird struct {
    Animal
    SpeedKPH float32
    CanFly   bool
}
```
In this example, we've defined a class  Animal  with two fields  Name  and  Origin . We've also defined a class  Bird  that "inherits" all of the fields and methods from  Animal  using composition. In addition,  Bird  has two additional fields  SpeedKPH  and  CanFly . 
### Polymorphism 
 Polymorphism is the concept of using a single interface to represent multiple classes. In Go, we achieve polymorphism using interfaces and method overriding. 
 Here's an example:

```
type Shape interface {
    Area() float64
}
type Rectangle struct {
    Width  float64
    Height float64
}
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
func main() {
    shapes := []Shape{Rectangle{2, 3}, Circle{4}}
    for _, shape := range shapes {
        fmt.Println("Area =", shape.Area())
    }
}
```
In this example, we've defined an interface  Shape  with a single method  Area() . We've also defined two implementations of this interface:  Rectangle  and  Circle . We can now create a list of  Shape  objects and call the  Area()  method on each of them to get the area of the shape, regardless of whether it's a rectangle or a circle. 

### Conclusion 
 In this article, we've explored how to write object-oriented programs in Go. We've covered defining a class, creating an object, encapsulation, abstraction, inheritance, and polymorphism. By using these concepts, you can write well-organized, modular code that is easy to maintain and extend.