Protect "default" methods from overriding

Question

I'm looking for a solution, that allows to protect the default methods from inheritance. The easiest solution could be - extend from class and etc... but in my case it's not possible.

Can someone suggest how to solve this problem? Could there be any workarounds?

Atm I have following code, which needs to be reworked (if/any possible):

public interface MyInterface1 {
    default boolean isA(Object obj) {
         return (boolean) obj.equals("A") ? true : false;
    }

    default boolean isB(Object obj) {
         return (boolean) obj.equals("B") ? true : false;
    }
}

public class MyClass extends MyLogic implements MyInterface, MyInterface1 {
// this class allows to inherit methods from both interfaces,
// but from my perspective i'd like to use the methods from MyInterface1 as it is,
// with a 'protection' from inheritance. is that possible?
}

Answer 1

You can't. At least if you restrict yourself to a pure-java-compiler solution.

And the reason is because it was not designed to do that: the purpose is to add new methods to existing interface (like java.util.Collection) without breaking the implementations. That way, we have sort(), stream(), forEach() on Collection.

If you were to allow such thing (forbidding implementation), then it would means a change in the interface would result in a compilation error for implementation (because they would override the method, method that would been rendered final). That was not the purpose.

There are several other options to achieve that, depending on your need:

• Abstract class with final method being the previously default method.
• Testing the default behavior using unit testing.
• Testing the possible implementation and check they don't override it.

The last case can probably be done easily with Reflections: you would have to list all implementations, and check for each interface's default method that there is no overriding using Reflections.

Answer 2

You seem to want a way to write your interface so that implementing classes cannot provide their own implementations of its default methods. There is no way to do this, and indeed it runs counter to the purpose of interfaces in general and default members in particular.

The point of default methods is to provide a way to add methods to existing interfaces without instantly breaking all their existing implementations. Generally speaking, this is a binary compatibility issue, not a functionality issue. There's no particular reason to suppose in general that default implementations can provide the intended functionality, but without them, even old code that doesn't rely on the new methods at all is incompatible with interface revisions that add methods.

---

I think you have a factoring issue. Rather than trying to force classes to provide a specific implementation of a specific method -- which cannot even refer to that class's members, except possibly others defined by the same interface -- you should provide the common methods in a class of their own. After all, since you want all classes involved to provide identical implementations, it doesn't matter which class's implementations you actually use. Moreover, there is therefore no particular usefulness in marking any given class as providing implementations of the well-known methods.

Example:

public class MyImplementation1 {
    public static boolean isA(Object obj) {
         return obj.equals("A");
    }

    public static isB(Object obj) {
         return obj.equals("B");
    }
}

// Wherever needed, use as MyImplementation1.isA(o), etc.

You can do this even if you want these pre-baked implementations to operate in terms of the other methods of your interface. In that case, just add an argument to the fixed methods that provides the object to operate on. Perhaps that's what the obj arguments in your example were supposed to be; in that case, this may be closer to what you're after:

public interface MyInterface3 {
    public String someInterfaceMethod();
}

public class MyImplementation2 {

    public static boolean isA(MyInterface3 subject) {
         return subject.someInterfaceMethod().equals("A");
    }

    public static boolean isB(MyInterface3 subject) {
         return subject.someInterfaceMethod().equals("B");
    }
}

Answer 3

I take it you mean you want to write a class that uses the default methods of an interface, but does not inherit them.

In your example code, you attempted to use the default methods by implementing the interface. When you implement an interface, by design you also inherit all its methods. This is the Liskov Substitution Principle. By implementing the interface you are telling your users that all instances of your class are substitutable for instances of the interface. But if the interface default methods weren't inherited, this wouldn't be true, so you would be lying to users of your class.

To have your class use the interface's default methods without inheriting them, don't implement the interface! Instead, use a helper class that does:

public interface MyInterface1 {
    default boolean isA(Object obj) {
        return obj.equals("A");  // or "A".equals(obj) to avoid NullPointerException
    }

    default boolean isB(Object obj) {
        return obj.equals("B");
    }
}

public class MyClass extends MyLogic implements MyInterface {

    private static class Helper implements MyInterface1 {
        void doSomeWork() {
            // do something that calls isA() and isB()...
        }
    }

    public void someMethodOfMyClass() {
        // ...
        Helper.doSomeWork();
        // ...
    }
}

Answer 4

No, This is not possible due to the way java implements the interface (pun intended). For more information as to the reason for this, see the answers to this question Why is "final" not allowed in Java 8 interface methods?

However here are some other ways to guide a developer not to override a default method:

1. A source code comment

//Do not inherit please

2. A javadoc comment