Lets say you have interface definition.
That interface can be Operation.
Then you have two applications running in different JVMs and communicating somehow remotely by exchanging Operation instances.
Lets call them application A and application B.
If application A implements Operation with the class that is not available in the classpath of the application B, will application B still be able to handle that implementation of interface? Even when B is in different JVM?
As long as it only tries to reference it by the common Interface, it should be able to handle it. The actual implementation doesn't matter as long as they both implement the same version of the Interface.
It depends on what you mean by "communicating somehow remotely". If application A actually just hands application B some sort of token which is built into a proxy such that calls to the Operation interface are proxied back to application A, then it may be okay. If the idea is for application B to create a local instance of the implementation class, then that's not going to work because it won't know what the object looks like.
It depends on the magic that happens in your "somehow communicate remotely" part.
If this communication is done via RMI or a similar technology, then this will be fine. Application B will create a remote proxy to the Operation object in JVM A, and calling methods on this proxy generate HTTP requests to JVM A, which are resolved against the actual object living in that JVM (which has access to the implementing class).
If this communication is done by serialising objects and sending them over the wire, then it will not work. When the object from application A arrives in JVM B, the deserialisation will fail (with a ClassNotFoundException or similar).
There could well be other remoting technologies, in which case things are implementation dependent. I know that Classloaders can load classes from byte arrays, and thus it's conceptually very possible to have such classloaders that would be able to load classes from remote sources. The networking library could in theory serialise the actual class across the wire this way, I believe, so while JVM B would not natively know about the implementing class, its classloader would be provided with the class' bytecode as required.