Go Language Object Oriented Programming
External
Internal
Overview
Go is an object-oriented language, but the object orientation programming model is relatively simple, compared with other object-oriented languages. It has been said about Go that is "weakly" object-oriented. Go does not use the term "class", there is no class keyword in the language. However, Go allows associating data with methods, which what a class in other programming languages really is.
Go provides syntax to associate an arbitrary local type with arbitrary functions, turning them into methods of that type. The local type can be a type alias, a struct or a function. In this context, "local" means a type that is defined in the same package as the function. That is why a programmer cannot add new methods to built-in types.
The most common pattern for implementing object-orientation is to use a struct as data encapsulation mechanism, optionally declaring fields as unexported, thus preventing direct access to them from outside the package, and then associating the struct with functions, by declaring the struct type as the receiver type for the function and the functions into methods of the type. This construct is the closest equivalent to a class in other programming languages. The standard dot notation is then used to call a method on the instance of the receiver type.
Go does not have formal inheritance, constructors or generics. Inheritance can be replaced to a certain extent by composition, struct field embedding and interfaces, which support code reuse and polymorphism.
Methods
A method of a type is a function that was associated with the type, by declaring the type to be a receiver type for that function, with the special syntax described below. If a method name starts with an uppercase character it is automatically exported.
Receiver Type
A receiver type for a function is a type that is associated with the function with dedicated syntax:
func (<receiver_type_parameter_name> <receiver_type|receiver_type_pointer>) function_name(...) ... {
...
}
The receiver type syntax is the logical equivalent of the self function parameter in Python and the implicit method parameter this in Java.
Declaring a receiver type turns the function into a method of the type. Depending on whether we want to be able to modify the receiver type instance in the method or not, the receiver type can be declared as a pointer receiver type or a value receiver type.
Regardless of whether we use a pointer or a value receiver type, the function gets an implicit parameter, which is a pointer to the instance in case of a pointer receiver type, and a value of the type in case of a value recover type:
func function_name(<implicit_parameter> <receiver_type|receiver_type_pointer>, ...) ... {
...
}
Value Receiver Type
The syntax to declare a value receiver type for a function is:
func (<receiver_type_parameter_name> <receiver_type>) <function_name>(...) ... {
...
}
Example:
type Color struct {
color string
}
func (c Color) SomeMethod() string {
return "dark " + c.color
}
In the example above, Color is the receiver type, and c is the variable that refers to the particular receiver type value the method was invoked on. The invocation target is passed as value inside the function.
The method is invoked on the receiver type instances with the usual dot notation syntax:
color := Color{"blue"}
result := color.SomeMethod() // the method will return "dark blue"
The invocation copies the color value into in the c variable inside the function, making c an implicit parameter of the method. There is no formal c function parameter in the signature, yet the method body has access to c, which behaves similarly to any other function parameter.
Because the receiver instance is passed by value, hence a copy of that value is passed inside the function, the method cannot modify the invocation target instance. A pointer receiver type must be used if instead to modify the target.
Pointer Receiver Type
To modify the receiver instance, use a pointer receiver type.
func (<receiver_type_parameter_name> *<receiver_type>) <function_name>(...) ... {
...
}
Example:
func (c *Color) Darken() {
c.color = "dark " + c.color
// (*c).color = "dark" + (*c).color is technically what we should have used, but the compiler can allow for the above, simpler, syntax
}
...
c := Color{"blue"}
c.Darken()
// equivalent (&c).Darken()
fmt.Println(c) // will print "{dark blue}"
Note that the Go compiler knows how to use the dot notation with both values and pointers, so in the above example, (*c).color and c.color are equivalent. In other words, there is no need to dereference the pointer inside the method. The compiler knows to dereference the pointer automatically. The reverse is also true, there is no need to reference the instance variable when used to invoke a method on it. Even though (&c).Darken() would work in the example above, there is no need for it, c.Darken() works equally well because the compiler knows what we mean.
The simpler syntax should be preferred.
Mixing Value and Pointer Receiver Types
The dot notation works with both values and pointers. The compiler knows how to transparently handle these two cases.
When using pointer receivers, it is good programming practice to have all method use pointer receivers, or none of them use pointer receivers. If we mix value and pointer receivers, the IDE would detect that as static check warning: "Struct Color has methods on both value and pointer receivers. Such usage is not recommended by the Go Documentation."
Structs as Receiver Types
It is very common to use structs as receiver types. You can take a struct, define it as a type, associate methods with that type, by declaring the type as receiver type on functions, and you would get what you normally think as a class in other programming languages.
Functions as Receiver Types
TODO, example here: https://go.dev/blog/error-handling-and-go#simplifying-repetitive-error-handling
Encapsulation
Encapsulation in this context is giving access to data, but intermediated by the public methods that are defined with the data. This way, access to data is controlled.
Encapsulation can be implemented with package data.
Encapsulation can also be implemented with structs, where the "private" fields are declared using identifiers that start with lower cap letters, so they are not visible outside the package. Controlled access to them is given via accessor and mutator methods, which are functions that have been declared to use the struct as a receiver type:
type Color struct {
color string
}
func (c *Color) Init(color string) {
c.SetColor(color)
}
func (c *Color) GetColor() string {
return (*c).color
}
func (c *Color) SetColor(color string) {
(*c).color = color
}
...
var c Color
c.Init("blue")
fmt.Println(c.GetColor()) // prints blue
c.SetColor("red")
fmt.Println(c.GetColor()) // prints red
Polymorphism
Polymorphism is available in Go, but it is implemented a bit differently than in other object-oriented languages, in that it does not imply inheritance, which is not available in Go. Polymorphism in Go is implemented using interfaces.
For a generic discussion on polymorphism, see:
Interfaces
Overriding
Inheritance
TO DEPLETE
Read and merge into document: