Golang Tutorial
Fundamentals
Control Statements
Functions & Methods
Structure
Arrays & Slices
String
Pointers
Interfaces
Concurrency
In Go, it's possible for different types to have methods with the same name, as method names are scoped to the types they are associated with. However, a single type cannot have two methods with the same name and different parameters, as Go does not support method overloading.
Let's explore this concept in depth.
In Go, methods are attached to specific types, so two different types can have methods with the same name without conflict.
Example:
package main
import "fmt"
type Circle struct {
Radius float64
}
type Square struct {
Side float64
}
// Area method for Circle
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
// Area method for Square
func (s Square) Area() float64 {
return s.Side * s.Side
}
func main() {
circle := Circle{Radius: 5}
square := Square{Side: 4}
fmt.Println("Circle Area:", circle.Area()) // Circle Area: 78.5
fmt.Println("Square Area:", square.Area()) // Square Area: 16
}
In the above code, both Circle and Square types have an Area method. Since they're associated with different types, there's no conflict.
Go does not support method overloading, which means that you cannot have multiple methods with the same name on a single type, even if they have different parameters.
For example, this will not work:
type Rectangle struct {
Width, Height float64
}
// This is invalid Go code
func (r Rectangle) SetDimensions(w float64) {
r.Width = w
}
// Error: method redeclared: Rectangle.SetDimensions
func (r Rectangle) SetDimensions(w, h float64) {
r.Width = w
r.Height = h
}
If you attempt to declare the above in Go, you'll get a compilation error. Instead, you need to give methods different names, like SetWidth and SetDimensions.
When using embedded types, if the outer type and the embedded type have methods with the same name, the method of the outer type will "shadow" or take precedence over the method of the embedded type.
Example:
type Person struct {
Name string
}
func (p Person) Greet() {
fmt.Println("Hello from Person:", p.Name)
}
type Employee struct {
Person
Role string
}
// This Greet method shadows the Greet method from Person
func (e Employee) Greet() {
fmt.Println("Hello from Employee:", e.Name, "Role:", e.Role)
}
func main() {
emp := Employee{Person: Person{Name: "John"}, Role: "Engineer"}
emp.Greet() // Hello from Employee: John Role: Engineer
}
In this example, when Greet is called on an Employee, the Employee's Greet method is executed, not the Person's Greet method.
Understanding these aspects of method naming in Go can help avoid potential pitfalls and confusion when designing and working with custom types and their methods.
Method overloading in Golang:
Description: Golang does not support method overloading in the traditional sense. Methods with the same name must belong to different types or interfaces.
Code:
// Golang does not support traditional method overloading // Instead, use different types or interfaces for similar behavior
Same method name in different types Golang:
Description: Golang allows methods with the same name if they belong to different types.
Code:
package main
import "fmt"
type Square struct {
Side int
}
type Circle struct {
Radius int
}
// Method for Square type
func (s Square) Area() int {
return s.Side * s.Side
}
// Method for Circle type
func (c Circle) Area() int {
return 3 * c.Radius * c.Radius
}
func main() {
square := Square{Side: 5}
circle := Circle{Radius: 3}
fmt.Println("Square Area:", square.Area())
fmt.Println("Circle Area:", circle.Area())
}
Implementing methods with the same name for different interfaces in Golang:
Description: You can have methods with the same name for different interfaces.
Code:
package main
import "fmt"
type Shape interface {
Area() int
}
type Square struct {
Side int
}
type Circle struct {
Radius int
}
// Method for Square type implementing Shape interface
func (s Square) Area() int {
return s.Side * s.Side
}
// Method for Circle type implementing Shape interface
func (c Circle) Area() int {
return 3 * c.Radius * c.Radius
}
func main() {
square := Square{Side: 5}
circle := Circle{Radius: 3}
// Both Square and Circle can be used where Shape is expected
shapes := []Shape{square, circle}
for _, shape := range shapes {
fmt.Println("Shape Area:", shape.Area())
}
}
Using interfaces for polymorphism with methods in Golang:
Description: Golang promotes polymorphism through interfaces, allowing different types to implement the same method.
Code:
package main
import "fmt"
type Shape interface {
Area() int
}
type Square struct {
Side int
}
type Circle struct {
Radius int
}
// Method for Square type implementing Shape interface
func (s Square) Area() int {
return s.Side * s.Side
}
// Method for Circle type implementing Shape interface
func (c Circle) Area() int {
return 3 * c.Radius * c.Radius
}
func CalculateArea(shape Shape) {
fmt.Println("Shape Area:", shape.Area())
}
func main() {
square := Square{Side: 5}
circle := Circle{Radius: 3}
CalculateArea(square)
CalculateArea(circle)
}
Golang methods with identical names in different structs:
Description: Golang allows methods with identical names in different structs.
Code:
package main
import "fmt"
type Rectangle struct {
Width int
Height int
}
type Triangle struct {
Base int
Height int
}
// Method for Rectangle type
func (r Rectangle) Area() int {
return r.Width * r.Height
}
// Method for Triangle type
func (t Triangle) Area() int {
return (t.Base * t.Height) / 2
}
func main() {
rectangle := Rectangle{Width: 5, Height: 10}
triangle := Triangle{Base: 4, Height: 8}
fmt.Println("Rectangle Area:", rectangle.Area())
fmt.Println("Triangle Area:", triangle.Area())
}
Combining methods with the same name from different packages in Golang:
Description: Golang allows methods with the same name from different packages.
Code:
// Package "geometry"
package geometry
type Rectangle struct {
Width int
Height int
}
func (r Rectangle) Area() int {
return r.Width * r.Height
}
// Package "shapes"
package shapes
type Circle struct {
Radius int
}
func (c Circle) Area() int {
return 3 * c.Radius * c.Radius
}
Ambiguity resolution with methods in Golang:
Description: When using multiple methods with the same name, Golang requires explicit qualification to resolve ambiguity.
Code:
package main
import (
"fmt"
"yourpackage/geometry"
"yourpackage/shapes"
)
func main() {
rectangle := geometry.Rectangle{Width: 5, Height: 10}
circle := shapes.Circle{Radius: 3}
// Ambiguity resolution using package name
fmt.Println("Rectangle Area:", geometry.Area(rectangle))
fmt.Println("Circle Area:", shapes.Area(circle))
}
Overlapping method names in Golang interfaces:
Description: Interfaces in Golang can have overlapping method names, and a type can implement multiple interfaces.
Code:
package main
import "fmt"
type Logger interface {
Log(message string)
}
type Printer interface {
Print(message string)
}
type ConsoleLoggerPrinter struct{}
// Implementing Log method for Logger interface
func (clp ConsoleLoggerPrinter) Log(message string) {
fmt.Println("Log:", message)
}
// Implementing Print method for Printer interface
func (clp ConsoleLoggerPrinter) Print(message string) {
fmt.Println("Print:", message)
}
func main() {
clp := ConsoleLoggerPrinter{}
// Overlapping method names in interfaces
var logger Logger = clp
var printer Printer = clp
logger.Log("Logging message")
printer.Print("Printing message")
}
Working with methods and type hierarchy in Golang:
Description: Golang allows struct embedding and method promotion, creating a hierarchy of types with shared methods.
Code:
package main
import "fmt"
type Vehicle struct {
Brand string
}
// Method for Vehicle type
func (v Vehicle) Start() {
fmt.Println(v.Brand, "Vehicle started")
}
type Car struct {
Vehicle
Model string
}
func main() {
car := Car{Vehicle: Vehicle{Brand: "Toyota"}, Model: "Camry"}
// Accessing embedded type's method
car.Start()
}