Pouvez-vous écrire une interface qui ne peut pas être implémentée?

Question

Ceci est en relation avec final interface in java. Parmi les discussions il y avait que le concept de final par rapport aux interfaces est ambigu. Est-ce qu'une interface finale signifierait qu'elle ne peut pas avoir de sous-interfaces? Cela voudrait-il dire qu'il ne peut pas avoir des implémentations?

Cette question est la première: pouvez-vous écrire une interface finale telle que le compilateur vous empêchera de l'implémenter?

Answer 1

Comme je le montrerai, il est possible d'implémenter l'interface ci-dessus en utilisant un proxy. La question la plus significative est, pourquoi essaieriez-vous de faire une interface non implémentable? Même en tant que point philosophique, il semble plutôt superficiel.

import java.lang.reflect.Proxy; 
import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 

class NoFinal 
{ 
    public static void main(String[] a) throws Throwable 
    { 
     FinalInterface o = (FinalInterface) Proxy.newProxyInstance(FinalInterface.class.getClassLoader(), new Class[]{FinalInterface.class}, new InvocationHandler() 
     { 
      public Object invoke(Object proxy, Method method, Object[] args) 
      { 
       System.out.println(method); 
       return null; 
      } 
     }); 
     Method[] methods = FinalInterface.class.getDeclaredMethods(); 
     methods[0].invoke(o, new Object[]{null}); 
     methods[1].invoke(o, new Object[]{null}); 
    } 
} 

Cela ne donnera pas une erreur lors de la compilation ou de l'exécution, et il montre que vous pouvez faire une véritable instance de cette interface avec les deux méthodes appelables.

Answer 2

Je propose ce qui suit en tant qu'interface, de sorte que l'implémentation sera évitée lors de la compilation.

interface FinalInterface 
{ 
    class Types 
    { 
     private class Alpha { } 

     private class Beta { } 
    } 

    void method (Types . Alpha param) ; 

    void method (Types . Beta param) ; 
} 

Answer 3

Techniquement, vous pouvez, en spécifiant des paramètres qui ne sont pas accessibles à implementors - par exemple dans le même paquet que l'interface, avec la visibilité du paquet-privé.

Mais cela n'a aucun sens. Cette interface est complètement inutile dans ce cas.

Mise à jour: Une utilisation me vient à l'esprit, mais cela ne devrait pas être fait. Si vous voulez utiliser des interfaces pour les définitions constantes, afin d'épargner le tas de modificateur qu'une interface assume, mais vous ne voulez pas utiliser l'anti-pattern de l'implémentation d'une interface constantes uniquement.