Struct
If you are coming from a OOP language like Java finding struct in Go might make you relieved. Although it is possible to do most OOP like things in Go. It is not the Go way. Structs are not objects. Structs are values. Struct are a collection of fields.
type Circle struct {
X float64
Y float64
Radius float64
}
Here we have defined a struct type Circle that has 3 fields. To use a struct we can declare a new Circle variable like any other type.
c1 := Circle{
X: 15.0,
Y: 12.0,
Radius: 8.5,
}
c2 := Circle{15.0, 12.0, 8.5}
These two are identical definition. Notice in c1 we put the field name and in c2 we omit it. We can only omit field names if a) we initialize all the fields and b) we omit all the fields. For example this is illegal
c2 := Circle{15.0, Y: 18.0, 8.5} // This will not compile
Accessing Fields
If a struct has exported fields and methods, we can use it in any other package after importing the package. We can not use unexported method or fields outside the package. To use a field or a method on a struct type we can use the . notation.
fmt.Println(c1.X, c1.Y, c1.Radius)
Methods
We talked about function in a previous post. Methods are just like functions but with a receiver argument.
func (c Circle) Area() float64 {
return c.Radius * c.Radius * math.Pi
}
func Area(c Circle) float64 {
return c.Radius * c.Radius * math.Pi
}
You can think of func (c Circle) Area() float64 as the same as func Area(c Circle) float64. In the Area method we will have a variable c of type Circle in scope, so we can use the value.
Receiver vs Pointer Receiver
We can declare methods with pointer receivers. Pointer receivers can be a bit confusing at times. You may think if you have a pointer receiver method defined you won’t be able to use that method on the value of the struct. That is not the case. One of the main reasons you would want to use the pointer receiver is to mutate the value the other would be if the value is two large and value receiver would have to make a big copy operation. This StackOverflow Answer outlines it in much more details.
func (c *Circle) Area() float64 {
return c.Radius * c.Radius * math.Pi
}
func (c Circle) Area2() float64 {
return c.Radius * c.Radius * math.Pi
}
We can use the function as such
fmt.Println(c1.Area() == c1.Area2())
Embedded Structs
In Go we usually do no promote the idea of inheritance . In OOP inheritance is the concept of one type inheriting its methods and fields from another type. Instead what we do have is embedded structs. In Go we try to compose as much as possible. We embed a struct in another by not adding a name to it.
type Wheel struct {
Circle
Material string
Color string
X float64
}
With struct embedding we can use the methods and fields of Circle type from Wheel as if they were defined on the Wheel type.
w1 := Wheel{
Circle: Circle{
Radius: 10.0,
X: 15.0,
},
Material: "Rubber",
Color: "Black",
X: 5.0,
}
fmt.Println(w1.Area())
Shadowing Embedded Structs
Let’s take another look at our Wheel type.
type Wheel struct {
Circle
Material string
Color string
X float64
}
We have a field X of type float64 defined on Wheel. We also have a embedded struct Circle which also have field X defined. What would happen if we tried to print w1.X. Would it print 15 from the embedded Circle type or 5 from X defined on Wheel type.
fmt.Println(w1.X) // 5
This will print 5. X in Wheel shadows the X field in Circle. We can still access the X in Circle by accessing fields using the . notation.
fmt.Println(w1.Circle.X) // 15
We can also shadow methods from embedded structs. We can embed any number of structs. Although this will make it harder to read our code.
The main difference between this type of composition and inheritance is that inheritance tries create a is relationship where composition create a has relationship.
Next Steps
This is Part 9 of this Go crash course series.