如何调用实现接口的结构的特定方法

Question

I've got the following interface and a few structs which implement it:

package main

import "fmt"

type vehicle interface {
    vehicleType() string
    numberOfWheels() int
    EngineType() string
}

// -------------------------------------------

type truck struct {
    loadCapacity int
}

func (t truck) vehicleType() string {
    return "Truck"
}

func (t truck) numberOfWheels() int {
    return 6
}

func (t truck) EngineType() string {
    return "Gasoline"
}

// -------------------------------------------
type ev struct {
    capacityInKWh int
}

func (e ev) vehicleType() string {
    return "Electric Vehicle"
}

func (e ev) numberOfWheels() int {
    return 4
}

func (e ev) EngineType() string {
    return "Electric"
}

func (e ev) Capacity() int {
    return e.capacityInKWh
}

// -------------------------------------------

type dealer struct{}

func (d dealer) sell(automobile vehicle) {
    fmt.Println("Selling a vehicle with the following properties")
    fmt.Printf("Vehicle Type: %s \n", automobile.vehicleType())
    fmt.Printf("Vehicle Number of wheels: %d \n", automobile.numberOfWheels())
    fmt.Printf("Vehicle Engine Type: %s \n", automobile.EngineType())

    if automobile.EngineType() == "Electric" {
        fmt.Printf("The battery capacity of the vehicle is %d KWh", automobile.Capacity())
        //fmt.Printf("Here")
    }
}

func main() {

    volvoTruck := truck{
        loadCapacity: 10,
    }

    tesla := ev{
        capacityInKWh: 100,
    }

    myDealer := dealer{}
    myDealer.sell(volvoTruck)
    fmt.Println("---------------------------")
    myDealer.sell(tesla)

}

Sell method in my dealer{} struct receives an interface. In this method I want to call a method that exists only on one of the structs that implement the interface but not in the others:

if automobile.EngineType() == "Electric" {
            fmt.Printf("The battery capacity of the vehicle is %d KWh", automobile.Capacity())
        }

Notice that Capacity() exists only in ev{} but not in truck{} . Is there a way to do this without having to add this method to the interface forcing all implementations to use it?

Answer 1

You may check for the existence of a method using a type assertion . Check if the value (or more specifically its type) has the method you're looking for, and if it does, you may call it.

Checking for a method can be realized by checking if the value implements an interface with that single method:

if hc, ok := automobile.(interface {
    Capacity() int
}); ok {
    fmt.Printf("The battery capacity of the vehicle is %d KWh", hc.Capacity())
}

Then output will be (try it on the Go Playground ):

Selling a vehicle with the following properties
Vehicle Type: Truck 
Vehicle Number of wheels: 6 
Vehicle Engine Type: Gasoline 
---------------------------
Selling a vehicle with the following properties
Vehicle Type: Electric Vehicle 
Vehicle Number of wheels: 4 
Vehicle Engine Type: Electric 
The battery capacity of the vehicle is 100 KWh

It's nicer if you create a named interface type for it:

type HasCapacity interface {
    Capacity() int
}

And then:

if hc, ok := automobile.(HasCapacity); ok {
    fmt.Printf("The battery capacity of the vehicle is %d KWh", hc.Capacity())
}

Output will be the same, try this one on the Go Playground .