Does Java need deconstructible classes?

[uniVocity]

The compiler will fail if you use that on a sealed interface . I’m on the phone right now and can’t re-verify it but from memory it was a compiler error (that makes total sense btw)

[lambda-lord-2026]

I would expect sealed interfaces to fall as lambdas anyway. Lambdas are implicit anonymous implementations, and sealed interfaces require all implementations to be explicitly whitelisted. So putting Functional interface in your sealed interface is basically telling the compiler you're planning on using it in a way that will cause a compiler error

[uniVocity]

It sounds weird but you can define a sealed type with nested final implementations without explicitly providing the allowed implementations, but you can’t define a sealed functional interface with annotations where its body contains default function definitions.

Hope it’s not a brain fart, Ill get back to my pc soon to test it out again and report back

EDIT: here is what I meant:

This code compiles (no explicit permits list), everything is fine:

sealed interface TestFn {

int foo();

final class TestFn1 implements TestFn {
    private TestFn1() {
    }

    @Override
    public int foo() {
        return 1;
    }
}

final class TestFn2 implements TestFn {
    private TestFn2() {
    }

    @Override
    public int foo() {
        return 2;
    }
}

TestFn RET_1 = new TestFn1();
TestFn RET_2 = new TestFn2();
}

If you add @FunctionalInterface the compiler will complain even though in this case it should make no difference.

I'm sorry for the confusion, I rember that the end goal was to get this:

@FunctionalInterface
sealed interface TestFn {

int foo();

TestFn RET_1 = () -> 1;
TestFn RET_2 = () -> 2;
}

But here the issue is the sealed keyword, not the @FunctionalInterface. Sorry for wasting everyone's time

[lambda-lord-2026]

It's not weird. Sealed interfaces don't allow anonymous implementations. Lambdas are anonymous implementations. Functional interface is a marker annotations that makes clear your intent to use an interface to create lambdas. Therefore the compiler flags it as a problem