通过签名推断的Java 8方法参考解析，这是坏的吗？

Question

A class implements a functional interface. This class has multiple methods with similar signatures, ie. they have an empty parameter list. A method that accepts this functional interface as an argument will accept any of those methods, even though they are not defined in the interface.

public class Frogs {
    public static void main(String[] args) {
        Froggo frog = new Froggo();
        moveTheFrog(frog::move);
        moveTheFrog(frog::jump);
        moveTheFrog(frog::swim);
        moveTheFrog(frog::croak);
        }
    static void moveTheFrog(Froginetic froginetic) {
        froginetic.move();
        }
    @FunctionalInterface
    interface Froginetic {
        void move();
        }
    static class Froggo implements Froginetic {
        @Override
        public void move() { System.out.println("move"); }
        void swim() { System.out.println("swim"); }
        void jump() { System.out.println("jump"); }
        void croak() { 
            System.out.println("croak"); 
            System.exit(2460); // bucks}
            }
        }
    }

Can't the compiler see that frog::jump is not defined in Froginetics? The designer of the moveTheFrog method would definitely not expect, nor account for, the effects of frog::croak.

It looks like good old fashioned C function ptrs are now a part of Java.

Is this broke? Or is this by design?

Answer 1

As we know from the Java tutorials

moveTheFrog(frog::move);

is more or less equivalent to

moveTheFrog(() -> from.move());

Because the target type of the argument is a functional interface, the body of the lambda expression becomes the body of the interface method. Similarly for method references, the body of the interface method becomes the body of the referenced method.

This is a feature of the language and doesn't have anything to do with the method being defined in one class or another. It's about compatibility between method signatures.

Froginetic doesn't know anything about Froggo .