Introducción
Un método es una función con un argumento receptor especial.
El receptor aparece en su propia lista de argumentos, entre la palabra clave func y el nombre del método.
func (receiver type) MethodName(parameters) (returnTypes) {
}
Solo puedes definir un método con un receptor cuyo tipo esté definido en el mismo paquete que el método.
package person
type Person struct {
Name string
}
func (p Person) Greetings() string {
return fmt.Sprintf("Welcome %s!", p.Name)
}
El método del struct se puede llamar con la notación de punto.
p := Person{Name: "Bronson"}
fmt.Println(p.Greetings())
// Output: Welcome Bronson!
Fíjate en la forma en que llamamos al método Greetings() sobre la instancia p de Person.
Es exactamente igual a como llamas a los métodos en un lenguaje de programación orientado a objetos.
Recuerda: un método es solo una función con un argumento receptor.
Los métodos ayudan a evitar conflictos de nombres: como un método está ligado a un tipo de receptor en particular, puedes tener el mismo nombre de método en tipos distintos.
import "math"
type rect struct {
width, height int
}
func (r rect) area() int {
return r.width * r.height
}
type circle struct {
radius int
}
func (c circle) area() float64 {
return math.Pow(float64(c.radius), 2) * math.Pi
}
Hay dos tipos de receptores: los receptores de valor y los receptores de puntero.
Todos los métodos que hemos visto hasta ahora tienen un receptor de valor, lo que significa que reciben una copia del valor que se pasa al método. Por eso, cualquier modificación que se haga al receptor dentro del método no es visible para quien lo llama.
Puedes declarar métodos con receptores de puntero para modificar el valor al que apunta el receptor.
Esto se hace anteponiendo un * al nombre del tipo.
Por ejemplo, con el tipo rect, un receptor de puntero se declararía como *rect.
Esas modificaciones también son visibles para quien llama al método.
type rect struct {
width, height int
}
func (r *rect) squareIt() {
r.height = r.width
}
r := rect{width: 10, height: 20}
fmt.Printf("Width: %d, Height: %d\n", r.width, r.height)
// Output: Width: 10, Height: 20
r.squareIt()
fmt.Printf("Width: %d, Height: %d\n", r.width, r.height)
// Output: Width: 10, Height: 10
Instrucciones
Nota: este ejercicio es una continuación del ejercicio need-for-speed.
En este ejercicio organizarás carreras entre distintos tipos de autos a control remoto.
Cada auto tiene sus propias características de velocidad y de drenaje de batería.
Los autos comienzan con la batería llena (100%).
Cada vez que conduces el auto con el control remoto, este recorre en metros su velocidad y reduce el porcentaje restante de batería según su drenaje de batería.
Si la batería de un auto está por debajo del porcentaje de su drenaje de batería, ya no puedes conducirlo.
El auto a control remoto tiene una elegante pantalla LED que muestra dos datos:
- La distancia total que ha recorrido, que se muestra así:
"Driven <METERS> meters".
- La carga de batería restante, que se muestra así:
"Battery at <PERCENTAGE>%".
Cada pista de carreras tiene su propia distancia.
Los autos se ponen a prueba comprobando si pueden terminar la pista sin quedarse sin batería.
1. Conduce el auto
Implementa el método Drive en el Car que actualiza la cantidad de metros recorridos según la velocidad del auto y reduce la batería de acuerdo con el drenaje de batería:
speed := 5
batteryDrain := 2
car := NewCar(speed, batteryDrain)
car.Drive()
// car is now Car{speed: 5, batteryDrain: 2, battery: 98, distance: 5}
Nota: no intentes conducir el auto si al hacerlo la batería del auto quedará por debajo de 0.
2. Muestra la distancia recorrida
Implementa un método DisplayDistance en Car que devuelva la distancia tal como se muestra en la pantalla LED, como un string:
speed := 5
batteryDrain := 2
car := NewCar(speed, batteryDrain)
fmt.Println(car.DisplayDistance())
// Output: "Driven 0 meters"
3. Muestra el porcentaje de batería
Implementa el método DisplayBattery en Car que devuelva el porcentaje de batería tal como se muestra en la pantalla LED, como un string:
speed := 5
batteryDrain := 2
car := NewCar(speed, batteryDrain)
fmt.Println(car.DisplayBattery())
// Output: "Battery at 100%"
4. Comprueba si un auto a control remoto puede terminar una carrera
Para terminar una carrera, un auto debe poder recorrer la distancia de la carrera.
Esto significa no agotar su batería antes de cruzar la línea de meta.
Implementa el método CanFinish que recibe un trackDistance int como parámetro y devuelve true si el auto puede terminar la carrera; de lo contrario, devuelve false:
speed := 5
batteryDrain := 2
car := NewCar(speed, batteryDrain)
trackDistance := 100
car.CanFinish(trackDistance)
// => true
Ejercicio de aprendizaje
