Java: pourquoi la déclaration n'est pas suffisante dans l'interface?

Question

La grande classe contient Format-interfcase et Format-class. La classe Format contient les méthodes et l'interface a les valeurs des champs. Je pourrais avoir les champs dans le format de la classe mais le but est avec l'interface. Alors, est-ce que je crée juste des varses factices pour éliminer les erreurs, les problèmes de conception ou quelque chose d'ÉLÉMENT?

CLÉ: Déclaration VS Initialiser

1. Expliquer les termes, pourquoi vous avez à init dans l'interface.
2. Quelle est la logique derrière tout cela?
3. À quel type de problèmes cela conduit-il l'utilisation de l'interface?

Exemple de code ayant la init-interface problème

import java.util.*; 
import java.io.*; 

public class FormatBig 
{ 

     private static class Format implements Format 
     { 
       private static long getSize(File f){return f.length();} 
       private static long getTime(File f){return f.lastModified();} 
       private static boolean isFile(File f){if(f.isFile()){return true;}} 
       private static boolean isBinary(File f){return Match.isBinary(f);} 
       private static char getType(File f){return Match.getTypes(f);} 
       private static String getPath(File f){return getNoErrPath(f);} 
       //Java API: isHidden, --- SYSTEM DEPENDED: toURI, toURL 


       Format(File f) 
       { 
        // PUZZLE 0: would Stack<Object> be easier? 
         size=getSize(f); 
         time=getTime(f); 
         isfile=isFile(f); 
         isBinary=isBinary(f); 
         type=getType(f); 
         path=getPath(f); 

        //PUZZLE 1: how can simplify the assignment? 
         values.push(size); 
         values.push(time); 
         values.push(isfile); 
         values.push(isBinary); 
         values.push(type); 
         values.push(path); 
       } 
     } 

     public static String getNoErrPath(File f) 
     { 
       try{return f.getCanonicalPath(); 
       }catch(Exception e){e.printStackTrace();} 
     } 

     public static final interface Format 
     { 
       //ERR: IT REQUIRES "=" 
       public long size; 
       public long time; 
       public boolean isFile=true; //ERROR goes away if I initialise wit DUMMY 
       public boolean isBinary; 
       public char type; 
       public String path; 
       Stack<Object> values=new Stack<Object>(); 
     } 

     public static void main(String[] args) 
     { 
       Format fm=new Format(new File(".")); 
       for(Object o:values){System.out.println(o);} 
     } 
} 

Answer 1

@Tom a répondu à votre question directe. Fondamentalement, vous ne pouvez pas déclarer les attributs au niveau de l'instance (ou les variables de niveau classe) dans une interface. Les attributs de niveau d'instance doivent être déclarés dans une classe.

Si vous souhaitez que plusieurs classes partagent les mêmes déclarations d'attribut, vous pouvez les mettre dans une superclasse abstraite. Mais la meilleure pratique consiste à déclarer les attributs private et à y accéder via des getters et setters.

Il y a deux autres problèmes avec votre code:

• Vous ne pouvez pas déclarer une classe et une interface avec le même nom dans le même espace. Vous avez une classe appelée Format qui implémente une interface appelée Format, toutes deux déclarées dans l'espace de noms du FormatBig. Et même si vous le pouvez (par exemple parce qu'ils ont été déclarés dans des espaces de noms différents), ceci est une mauvaise pratique. Attribuez des noms distincts à la classe et à l'interface.

• Vous devez utiliser les classes imbriquées avec parcimonie. Il me semble que vous pourriez avoir imbriqué la classe Format et l'interface à l'intérieur FormatBig pour que vous ayez seulement à éditer et à compiler un fichier. C'est paresseux. Alternativement, si vous le faites pour organiser votre code, apprenez comment utiliser les paquets Java.

Answer 2

Les champs dans les interfaces sont implicitement public final static.

static signifie qu'ils sont indépendants des instances. Ce n'est probablement pas ce que vous voulez.

final signifie qu'ils doivent être affectés une seule fois lors de l'initialisation de classe, car les champs sont également static. Cela signifie généralement assigner dans la déclaration, mais pourrait utiliser un initialiseur statique. S'il s'agissait de champs d'instance (non static), ils devraient être assignés soit dans la déclaration, soit dans les constructeurs (qui implicitement ou explicitement appellent super plutôt qu'un constructeur "this") ou dans un initialiseur d'instance.

Vous devez probablement déplacer les champs d'instance dans la classe d'implémentation et les marquer final.