Can the same Object interface be different type?

I saw this code and wonder why object can be both Service and Pod type?

The code is in the same function's body.

    serviceCreateHook := func(_ context.Context, client *MockClient, object ctrlClient.Object) error {
		svc, isSvc := object.(*corev1.Service)
		if !isSvc {
			return nil
		}

		return nil
	}

	podCreateHook := func(_ context.Context, client *MockClient, object ctrlClient.Object) error {
		pod, isPod := object.(*corev1.Pod)
		if !isPod {
			return nil
		}

		return nil
	}

ctrlClient.Object is k8s client Object interface defined below:

type Object interface {
	metav1.Object
	runtime.Object
}

I think object.(*corev1.Pod) is using the type assertion to get the underlying object of the interface object. But why the same interface can be both types?

Follow-up question: Given an object, can both of the following be true? i.e., can the counter value ever be 2?

{
    counter := 0
    pod, isPod := object.(*corev1.Pod)
    		if !isPod {
    			return nil
    		} else {
              counter++
            }
    node, isNode := object.(*corev1.Node)
    		if !isNode {
    			return nil
    		} else {
              counter++
            }
}

TL;DR:

A ctrlClient.Object cannot be both types (at the same time), but any one instance of a ctrlClient.Object could be either type.

It could also be any other type that also implements that interface.

Expansion

ctrlClient.Object is an interface type. An interface is merely a contract that can be implemented by any number of different types.

The two "Hook" funcs that you show both accept any implementation of that interface, but in each case they apparently have (or will have) behaviours that depend on the specific underlying type of that implementation (the funcs appear to be incomplete as posted, but this would seem to be the intent).

Hence, each function initially performs a type assertion on the interface.

If the underlying implementation is not of the required/expected type then the function has some alternate flow compared to when it is.