Does Java support dynamic method invocation?

Question

class A           { void F() { System.out.println("a"); }}
class B extends A { void F() { System.out.println("b"); }}

public class X {
    public static void main(String[] args) {
        A objA = new B();
        objA.F();
    }
}

Here, F() is being invoked dynamically, isn't it?

This article says:

... the Java bytecode doesn’t support dynamic method invocation. There are three supported invocations modes : invokestatic, invokespecial, invokeinterface or invokevirtual. These modes allows to call methods with known signature. We talk of strongly typed language. This allows to to make some checks directly at compile time.

On the other side, the dynamic languages use dynamic types. So we can call a method unknown at the compile time, but that’s completely impossible with the Java bytecode.

What am I missing?

What happens when you run the program? – Dave Jarvis Apr 09 '10 at 16:46 — Dave Jarvis, Apr 09 '10 at 16:46
The author of that article needs a lesson in counting. – Syntactic Apr 09 '10 at 16:56 — Syntactic, Apr 09 '10 at 16:56

Jack · Accepted Answer · 2010-04-09T16:57:04.970

You are confusing dynamic invocation with dynamic binding..

The first one allows the type checker to accept programs in which you are not sure if a method will be present on an object at run-time, while dynamic binding just chooses the right implementation according to the runtime type of the object but maintaining the statically type checking.

What does it mean?

It means that in your example, Java will call the implementation on object B because the runtime type of the objA variable is B; and it will compile because it knows that a B is a A so the method invocation won't fail at runtime (objA will have a F implementation for sure).

With dynamic invocation instead it won't check at compile time that the type of the object on which you are calling F contains that method, of course it will raise an exception if during execution the method won't be available on specified object.

Just for trivia: the invokedynamic feature will be added with Java7 because many scripting languages have been written to work on top of JVM and the lack of a dynamic invocation feature forced the developers of these languages to add a middle layer between the script and the real JVM that cares about dynamic invocation using the reflection. Of course this approach causes a lot of overhead (think about Grovvy's MetaClass), that's why Sun decided to give them a help..

score 1 · Answer 2 · answered Apr 09 '10 at 16:49

In your example the correct method is called because polymorphically the instance of B appears like an instance of A. The method can be located by examining the runtime type of the object; that is, B; as opposed to the compile-time type of the object reference, A. The other important part is the signature of method - these must always match (polymorphically of course).

This differs from dynamic languages because in those there is essentially no compile-time for the object - and everything must be resolved at runtime.

score 1 · Answer 3 · answered Apr 09 '10 at 16:50

1

In fact, what you're missing is that this is the part of 'invokevirtual' which is explained in the article.

You're simply overriding the method and that uses a virtual method table to invoke the correct method.

answered Apr 09 '10 at 16:50

Sebastian P.R. Gingter

5,955
3
31
73

score 0 · Answer 4 · answered Apr 09 '10 at 16:54

I wouldn't call your example "dynamic", rather virtual. Because at compile time the method name and signature is known (and its existence is checked by the compiler). The only that is resolved at runtime is the concrete implementation to be used for that method.

A more proper example of "dynamic" method invocation would involve reflection, (see the Method class ). In that way, methods whose existence are unkown at compile type can be invoked in runtime (this is extensively used by frameworks, not so much by application code).

The article you mention seems a little misleading in that respect. But it's true that the signature of the methods you explicitly call must be known/checked in compile time, and so, in that sense, Java is not dynamic.

score 0 · Answer 5 · answered Nov 16 '15 at 00:32

You can make functional interfaces.

class Logger {
  private BiConsumer<Object, Integer> logger = null;

  // ...

  private Logger(Object logger) {
      this.akkaLogger = (LoggingAdapter) logger;
      this.logger = (message, level) -> {
          switch (level) {
              case INFO:  akkaInfo(message);
                          break;
              case DEBUG: akkaDebug(message);
                          break;
              case ERROR: akkaError(message);
                          break;
              case WARN:  akkaWarn(message);
                          break;
          }
      };
  }

  private Logger() {
      this.logger = (message, level) -> System.out.println(message);
  }

  // ...
}

Does Java support dynamic method invocation?

5 Answers5