Components are not a replacement for Interfaces. Components provide extra reusable functionality and are really good at that, too. Components also support both inheritance and can implement interfaces.
but you will not have to repeat the same code
You will not need to repeat anything; base actor implements an interface, shared variables and functionality. Children override it as they see fit. You call an Interface Function on an actor and if the child of the base class happens to implement a function for that, that function will be called. And you can optionally call parent’s version, too.
You combine inheritance with interfaces and top it up with actor components where & when it makes sense. For as long as it’s clear in your head and the solution is working, you’re golden. There are scenarios where Interfaces shine.
There will be situations where Interface are not necessary - when classes are known or you’re working within the same class. Or when you’re using direct comms.
If the goal is to avoid casting and make several completely unrelated (or related) classes to talk to each other, Interfaces provide the means for very clear and effortless communication.
For a child inheriting an interface, you can:
Write your stuff in the parent once, children get to call that and then add something extra for themselves (perhaps they have an actor component that parents don’t).
You can execute the above without casting once.