Introducción

Go, o Golang es un lenguaje de programación compilado. No tiene una forma de definir una clase (así como estamos acostumbrados por ejemplo en Java) pero sí podemos crear objetos.

¿Cómo declarar una clase en Go?

No declaramos una clase, declaramos un tipo. Por ejemplo, si yo quisiera declarar la clase Mascota, pondría esto:

type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

Declaramos variables de distintos tipos dentro de nuestro tipo.

¿Cómo crear un objeto en Go?

Tomando el ejemplo de arriba, podemos crear un objeto de la siguiente forma:

package main


import "fmt"


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

func main() {
 mascota := Mascota{1, "Maggie", "No sé", true}
 fmt.Println(mascota)
}

Podemos imprimirlo, se verá esto:

Instanciar un objeto

Podemos instanciar o crear un objeto de 2 maneras. En la primera, mandamos en orden los valores del objeto. Así:

mascota := Mascota{1, "Maggie", "No sé", true}

Pero no recomiendo esa forma, ya que no es expresiva y si el orden de los valores cambia dentro del tipo, tendremos que cambiar también las llamadas a la creación del mismo.

Recomiendo esto:

mascota := Mascota{
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }

Ahí definimos cuál variable estamos pasando. Además, el orden no importa (en este caso las mandé en el mismo orden pero fue coincidencia)

Métodos dentro de una clase

También podemos declarar métodos o funciones. Programemos la función ladrar, en donde imprimimos un mensaje y accedemos a algunas propiedades de nuestra mascota.

package main


import "fmt"


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

func (m *Mascota) ladrar() {
 fmt.Printf("¡guau! me llamo %s y tengo %d años", m.nombre, m.edad)
}

func main() {
 mascota := Mascota{
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }
 mascota.ladrar()
}

Vemos claramente que no definimos la función dentro de nuestro tipo, sino que la adjuntamos a un apuntador del mismo. Si yo ejecuto el programa, sale esto:

Modificando y obteniendo propiedades

Podemos modificarlas directamente, como se ve a continuación:

package main


import "fmt"


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

func (m *Mascota) ladrar() {
 fmt.Printf("¡guau! me llamo %s y tengo %d años\n", m.nombre, m.edad)
}

func main() {
 mascota := Mascota{
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }
 mascota.ladrar()
 /*
  Modificar su edad y luego ladrar de nuevo
 */ mascota.edad = 2
 mascota.ladrar()
}

Igualmente obtenerlas:

package main


import "fmt"


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

func (m *Mascota) ladrar() {
 fmt.Printf("¡guau! me llamo %s y tengo %d años\n", m.nombre, m.edad)
}

func main() {
 mascota := Mascota{
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }
 mascota.ladrar()
 /*
  Obtener su nombre y guardarlo en una variable
 */ nombre := mascota.nombre
 fmt.Println("La mascota se llama ", nombre)
}

Con este resultado:

Pero no es recomendado obtenerlas así. Eso sería dejar nuestras variables públicas, y generaría  (en la mayoría de los casos) muchos errores.

Setters y getters

Podemos crear getters y setters para obtener y establecer propiedades. Veamos por ejemplo el setter y getter de edad.

Para establecer su edad definimos otra función, igualmente para obtenerla.

package main


import "fmt"


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
}

func (m *Mascota) ladrar() {
 fmt.Printf("¡guau! me llamo %s y tengo %d años\n", m.nombre, m.edad)
}

func (m *Mascota) Edad() int{
 return m.edad
}

func (m *Mascota) SetEdad(nuevaEdad int) {
 m.edad = nuevaEdad
}

func main() {
 mascota := Mascota{
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }
 mascota.ladrar()

 //modificar edad
 mascota.SetEdad(2)

 mascota.ladrar()
}

El resultado al ejecutarlo sigue siendo el mismo, pero ahora ya hemos implementado getters y setters.

Objetos dentro de otras clases

Para terminar el post y no hacerlo muy largo, veamos que podemos tener objetos dentro de objetos.

Pongamos a nuestra mascota un dueño. Un dueño es del tipo Persona.

package main


import "fmt"



type Persona struct{
 edad int
 nombre, genero string
}


type Mascota struct{
 edad int
 nombre, raza string
 sana bool
 dueño Persona
}
/*
 Nuevo método
*/func (m *Mascota) saludar() {
 fmt.Printf("¡Hola %s! Bienvenido a casa\n", m.dueño.nombre)
}

func (m *Mascota) ladrar() {
 fmt.Printf("¡guau! me llamo %s y tengo %d años\n", m.nombre, m.edad)
}

func (m *Mascota) Edad() int{
 return m.edad
}

func (m *Mascota) SetEdad(nuevaEdad int) {
 m.edad = nuevaEdad
}


func main() {
 mascota := Mascota{
  dueño: Persona{
   nombre: "Luis",
   genero: "M",
   edad: 50,
  },
  edad: 10,
  nombre: "Guayaba",
  raza: "Tampoco la conozco",
  sana: true,
 }
 mascota.saludar()
 mascota.ladrar()
}

Al ejecutar, el resultado es este:

Con eso terminamos por hoy.