Final de l'interface en Java?

Interfaces sont 100% abstrait, et le seul moyen de créer une instance de l'interface est d'instancier une classe qui l'implémente. Permettant les interfaces final est complètement inutile.

MODIFIER La questions n'est pas aussi carrément scandaleux que je ne le pensais. Une interface finale est celle qui ne peut pas être prolongé par d'autres interfaces, mais peut être mis en œuvre en apparence, fait sens.

Je pouvais penser a une différence entre une classe finale et une finale de l'interface. Extension d'une classe peut compromettre son intégrité, car il contient de l'état. Extension d'une interface ajoute simplement des opérations et ne peuvent pas compromettre l'intégrité de la mise en œuvre parce que l'interface est apatrides sur son propre.

Pas. Le Langage Java Specification section 9.1.1. Interface Modificateurs les états suivants:

Une déclaration d'interface peuvent inclure l'interface de modificateurs.

InterfaceModifier:
  (one of)
  Annotation public protected private
  abstract static strictfp

Comme on peut le voir, la liste ne comprend pas final.

Pourquoi le langage conçu de cette façon?

Si une interface a été déclaré final je suppose qu'il aurait pu signifier que

• Aucune autre interface pourrait l'étendre

  Ce serait un non-sens de la restriction. Les raisons pour lesquelles il peut être utile de déclarer un classe final, est de protéger l'état des invariants, d'interdire primordial de toutes les méthodes à la fois, etc. Aucune de ces restrictions de sens que pour les interfaces. (Il n'y a pas d'état, et toutes les méthodes doit être remplacé.)

• Pas de classe peut implémenter l'interface

  Évidemment, défaites le but d'une interface complètement.

Je l'ai essayé et apparemment, vous pouvez créer une interface finale en java. Je n'ai aucune idée de pourquoi vous voulez faire cela, mais vous pouvez. C'est la façon dont je l'ai fait.

1. Compiler un non définitif de l'interface. J'ai sauvé le code ci-dessous dans FinalInterface.java. Puis j'ai compilé.

   interface FinalInterface
   {
   }

2. Exécuter BCELifier sur elle. Cela a créé un fichier appelé FinalInterfaceCreator.java

3. De le modifier. Recherchez une ligne similaire à ci-dessous et ajouter ACC_FINAL.

   _cg = new ClassGen("FinalInterface", "java.lang.Objet", "FinalInterface.java", ACC_INTERFACE | ACC_ABSTRACT | ACC_FINAL , new String[] { });

4. Compiler et exécuter le fichier FinalInterfaceCreator.java. Cela devrait remplacer l'original FinalInterface.class fichier avec un nouveau qui est similaire, mais la finale.

Pour le tester, j'ai créé deux nouveaux fichiers java TestInterface et TestClass. TestInterface est une interface qui étend FinalInterface et TestClass est une classe qui implémente FinalInterface. Le compilateur refuse de compiler soit parce que FinalInterface est définitive.

TestClass.java:2: cannot inherit from final FinalInterface
class TestClass implements FinalInterface

TestInterface.java:2: cannot inherit from final FinalInterface
interface TestInterface extends FinalInterface

En plus, j'ai essayé de créer une instance de FinalInterface en utilisant des proxies dynamiques

class Main
{
    public static void main ( String [ ] args )
    {
    Class < ? > ntrfc = FinalInterface . class ;
    ClassLoader classLoader = ntrfc . getClassLoader ( ) ;
    Class < ? > [ ] interfaces = { ntrfc } ;
    java . lang . reflect . InvocationHandler invocationHandler = new java . lang . reflect . InvocationHandler ( )
        {
        public Object invoke ( Object proxy , java . lang . reflect . Method method , Object [ ] args )
        {
            return ( null ) ;
        }
        } ;
    FinalInterface fi = ( FinalInterface ) ( java . lang . reflect . Proxy . newProxyInstance ( classLoader , interfaces , invocationHandler ) ) ;
    }
}

Ce un compilé, mais n'a pas couru

Exception in thread "main" java.lang.ClassFormatError: Illegal class modifiers in class FinalInterface: 0x610
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:632)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
at java.net.URLClassLoader.defineClass(URLClassLoader.java:277)
at java.net.URLClassLoader.access$000(URLClassLoader.java:73)
at java.net.URLClassLoader$1.run(URLClassLoader.java:212)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
at java.lang.ClassLoader.loadClass(ClassLoader.java:319)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:294)
at java.lang.ClassLoader.loadClass(ClassLoader.java:264)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:332)
at Main.main(Main.java:6)

Ainsi, la preuve suggère que vous pouvez créer une interface finale en java, mais pourquoi voudriez-vous?

Lors de la conception d'Api dans Java je trouve parfois dans une situation où un type dans l'API doit être Java interface, mais le nombre de sa mise en application devrait être limitée, par exemple, seule l'Api internes de la mettre en oeuvre, pas quelqu'un d'autre.

J'ai réalisé que je peux maintenant (depuis Java 1.6) restreindre qui implémente une interface avec l'aide de l'annotation processors (l'article sur apidesign.org). C'est le code:

package org.apidesign.demo.finalinterface;
import java.util.Collection;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.tools.Diagnostic;
import org.openide.util.lookup.ServiceProvider;
@ServiceProvider(service = Processor.class)
@SupportedAnnotationTypes("*")
public final class FinalEnforcingProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
checkForViolations(roundEnv.getRootElements());
return true;
}
private void checkForViolations(Collection<? extends Element> all) {
for (Element e : all) {
if (e instanceof TypeElement) {
TypeElement te = (TypeElement) e;
/* exception for the only known implementation:
if ("org.apidesign.demo.finalinterface.AllowedImplementationTest".equals(
te.getQualifiedName().toString())
) continue;
*/
for (TypeMirror m : te.getInterfaces()) {
if (FinalInterface.class.getName().equals(m.toString())) {
processingEnv.getMessager().printMessage(
Diagnostic.Kind.ERROR, "Cannot implement FinalInterface", e
);
}
}
}
checkForViolations(e.getEnclosedElements());
}
}
}

Chaque fois que quelqu'un comprend votre API JAR au classpath et essaie de compiler contre elle, la Javac compilateur appelle votre processeur d'annotation et de l'échec de la compilation si il détecte quelqu'un d'autre est en train d'essayer de mettre en œuvre votre interface.

Je préfère encore l'utilisation de classe finale pour Client API - p. ex. un API que d'autres sont seulement autorisés à appeler, mais quand il n'est pas possible, le truc avec processeur d'annotation est solution de rechange acceptable.

Au lieu de Déclarer l'Interface Finale, Nous pouvons éviter de Créer un objet de l'Interface.

Point de Création d'Interface met en œuvre ses méthodes par sa sous-classe. Si nous voulons vaincre cet effet, puis je sens sa une sans fondement.

Si quelqu'un a d'autres suggestions, merci de nous le faire savoir