下面是一个接受任何类型的Callable对象的类示例，并且添加了一些限制条件：

from typing import Callable, Any


class CallableWrapper:
    def __init__(self, func: Callable[..., Any]):
        self.function = func

    def execute_callable(self, *args: Any, **kwargs: Any) -> Any:
        # 添加限制条件：只有当传入的对象是可调用的才执行
        if callable(self.function):
            return self.function(*args, **kwargs)
        else:
            raise TypeError("传入的对象不可调用")


# 示例用法
def add(a: int, b: int) -> int:
    return a + b


def multiply(a: int, b: int) -> int:
    return a * b


class DummyClass:
    def __call__(self, a: int, b: int) -> int:
        return a - b


def main():
    wrapper = CallableWrapper(add)
    result = wrapper.execute_callable(2, 3)
    print(result)  # 输出: 5

    wrapper = CallableWrapper(multiply)
    result = wrapper.execute_callable(2, 3)
    print(result)  # 输出: 6

    dummy = DummyClass()
    wrapper = CallableWrapper(dummy)
    result = wrapper.execute_callable(3, 2)
    print(result)  # 输出: 1

    wrapper = CallableWrapper("not callable")  # 传入一个不可调用的对象
    result = wrapper.execute_callable()  # 抛出TypeError异常


if __name__ == "__main__":
    main()

在这个示例中，我们定义了一个CallableWrapper类，它有一个function属性来存储传入的可调用对象。execute_callable方法用于执行传入的可调用对象，并传递任何参数。我们添加了限制条件，只有当传入的对象是可调用的时才执行，否则抛出TypeError异常。

在示例的最后，我们展示了如何使用CallableWrapper类来封装不同类型的可调用对象，并执行它们。