Go Language Object Oriented Programming: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
 
(157 intermediate revisions by the same user not shown)
Line 5: Line 5:
* [[Go_Language#Object_Oriented_Programming|Go Language]]
* [[Go_Language#Object_Oriented_Programming|Go Language]]
* [[Go Functions]]
* [[Go Functions]]
* [[Go_Interfaces#Overview|Go Interfaces]]
* [[Object-Oriented_Programming#Overview|Object-Oriented Programming]]
* [[Object-Oriented_Programming#Overview|Object-Oriented Programming]]


=Overview=
=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 "[[Object-Oriented_Programming#Class|class]]". There is no <code>class</code> keyword in Go. However, Go allows associating data with methods, which what a class in other programming languages really is.  
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 "[[Object-Oriented_Programming#Class|class]]", there is no <code>class</code> keyword in the language. However, Go allows associating data with methods, which what a class in other programming languages really is.  


Go uses <code>struct</code> instead, which is the encapsulation of data and methods, so the <code>struct</code> ends being equivalent to a class. To associate data with methods, we use Go functions and we give the a '''receiver type''', which is the type that function - now becoming a method - is associated with. When calling a method on an instance of the receiver type, the standard dot notation is used.
Go provides syntax to associate an arbitrary [[Go_Language#Local_Type|local type]] with arbitrary functions, turning them into [[#Method|methods]] of that type. The local type can be a [[Go_Language#Type_Alias|type alias]], a <code>[[Go_Structs#Overview|struct]]</code> or a [[#Functions_as_Receiver_Types|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.


Go does not have inheritance, constructors or generics. Inheritance can be replaced to a certain extent by composition, embedding and interface, which support code reuse and [[Object-Oriented_Programming#Polymorphism|polymorphism]].
<span id='Structs_as_Receiver_Types'></span><span id='Structs_as_Receiver_Type'></span>The most common pattern for implementing object-orientation is to use a <code>struct</code> as data encapsulation mechanism, optionally declaring fields as [[Go_Packages#Unexported_Members|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|receiver type]] for those functions. The functions become [[#Method|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.


=Methods=
Go does offer inheritance, overriding and polymorphism in the language syntax the same way other OOP languages do, but these features are available and can be implemented with a combination of [[Go_Structs#Embedded_Fields|struct field embedding]] and [[Go_Interfaces#Overview|interfaces]]. See: {{Internal|Go_Inheritance_and_Polymorphism#Overview|Go Inheritance and Polymorphism}}


Functions can be associated with a type, turning them into methods of that type, by declaring a [[#Receiver_Type|receiver type]] on the function.
=<span id='Method'></span>Methods=
 
{{Internal|Go_Methods#Overview|Go Methods}}
==Receiver Type==
 
Receiver types are declared with a special syntax on functions. This turns the function declared as such into methods of the type, and makes the receiver types analogous to "classes". Depending on whether we want to be able to modify the receiver type instance in the method, the receiver type can be declared as [[#Value_Receiver_Type|value receiver type]] or [[#Pointer_Receiver_Type|pointer receiver type]].
 
Methods can only be associated with receiver types that are defined in the same package as the method. That is why a programmer cannot add new methods to built-in types.
===Value Receiver Type===
The syntax to declare a value receiver type for a method is:
<syntaxhighlight lang='go'>
func (<receiver_type_parameter_name> <receiver-type>) <function-name>(...) ... {
  ...
}
</syntaxhighlight>
Example:
<syntaxhighlight lang='go'>
type Color struct {
  color string
}
 
func (c Color) GetADarkerShade() string {
  return "dark " + c.color
}
</syntaxhighlight>
 
In the example above, <code>Color</code> is the receiver type, and <code>c</code> is the variable that refers to the particular receiver type instance the method was invoked on.
 
The invocation of the method on the receiver type instance is done with the usual '''dot notation''':
<syntaxhighlight lang='go'>
color := Color{"blue"}
result := color.GetADarkerShade() // result will be assigned with "dark blue"
</syntaxhighlight>
 
The invocation with the dot notation makes the instance being invoked on (<code>color</code>) an '''implicit argument''' (<code>c</code>) of the method: there is no parameter in the <code>GetADarkerShade</code> method signature, yet the method body has access to <code>c</code>. This  makes <code>c</code> an implicit argument of the method.
 
The dot notation works with both values and pointers. The compiler knows how to handle that transparently.
 
In the example above, the receiver instance is passed by value. The instance the method is invoked on cannot be modified in the method, because the method gets a copy of the receiver type instance. To be able to modify the instance, it has to be passed as a [[#Pointer_Receiver_Type|pointer receiver type]].
 
===Pointer Receiver Type===
To modify the receiver instance, use a pointer receiver type.
 
<syntaxhighlight lang='go'>
func (<receiver_type_parameter_name> *<receiver_type>) <function_name>(...) ... {
  ...
}
</syntaxhighlight>
 
Example:
<syntaxhighlight lang='go'>
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}"
</syntaxhighlight>
 
Note that the Go compiler knows how to use the dot notation with both values and pointers, so in the above example, <code>(*c).color</code> and <code>c.color</code> 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 <code>(&c).Darken()</code> would work in the example above, there is no need for it, <code>c.Darken()</code> works equally well because the compiler knows what we mean.
 
The simpler syntax should be preferred.
 
===Mixing Value and Pointer Receiver Types===
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."
 
=<span id='Structs_as_Receiver_Type='></span>Structs as Receiver Types=
 
It is very common to use [[Go_Structs#Overview|structs]] as [[#Receiver_Type|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.


=Encapsulation=
=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 in this context is giving access to private data, such as package-internal data or private struct fields, via public methods. This way, access to data is controlled.


Encapsulation can be implemented with [[Go_Language_Modularization#Encapsulation|package]] data.
Encapsulation can be implemented with [[Go_Language_Modularization#Encapsulation|package]] data and with structs, where the [[Go_Structs#Encapsulation_and_Private_Fields|"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, or [[Go_Style#Getters_and_Setters|getters and setters]], which are functions that have been declared to use the struct as a receiver type:
 
Encapsulation can also be implemented with structs, where the [[Go_Structs#Encapsulation_and_Private_Fields|"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:


<syntaxhighlight lang='go'>
<syntaxhighlight lang='go'>
Line 106: Line 35:
}
}


func (c *Color) GetColor() string {
func (c *Color) Color() string {
return (*c).color
return (*c).color
}
}
Line 118: Line 47:
var c Color
var c Color
c.Init("blue")
c.Init("blue")
fmt.Println(c.GetColor()) // prints blue
fmt.Println(c.Color()) // prints blue
c.SetColor("red")
c.SetColor("red")
fmt.Println(c.GetColor()) // prints red
fmt.Println(c.Color()) // prints red
</syntaxhighlight>
</syntaxhighlight>
 
=<span id='Interface'></span>Interfaces=
=Polymorphism=
{{Internal|Go_Interfaces#Internal|Go Interfaces}}
 
=<span id='Inheritance'></span><span id='Polymorphism'></span><span id='Overriding'></span>Inheritance and Polymorphism=
=TO DEPLETE=
{{Internal|Go_Inheritance_and_Polymorphism#Overview|Go Inheritance and Polymorphism}}
 
<font color=darkkhaki>
 
Read and merge into document:
 
* https://go.dev/doc/faq#Is_Go_an_object-oriented_language
 
</font>

Latest revision as of 00:08, 2 September 2024

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 those functions. The functions become 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 offer inheritance, overriding and polymorphism in the language syntax the same way other OOP languages do, but these features are available and can be implemented with a combination of struct field embedding and interfaces. See:

Go Inheritance and Polymorphism

Methods

Go Methods

Encapsulation

Encapsulation in this context is giving access to private data, such as package-internal data or private struct fields, via public methods. This way, access to data is controlled.

Encapsulation can be implemented with package data and 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, or getters and setters, 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) Color() string {
	return (*c).color
}

func (c *Color) SetColor(color string) {
	(*c).color = color
}

...

var c Color
c.Init("blue")
fmt.Println(c.Color()) // prints blue
c.SetColor("red")
fmt.Println(c.Color()) // prints red

Interfaces

Go Interfaces

Inheritance and Polymorphism

Go Inheritance and Polymorphism
Retrieved from "https://kb.novaordis.com/index.php?title=Go_Language_Object_Oriented_Programming&oldid=112732"