Pourquoi n'êtes-vous pas en mesure de déclarer une classe comme statique en Java?

Pourquoi n'êtes-vous pas en mesure de déclarer une classe comme statique en Java?

Seules les classes imbriquées peuvent être statiques. Ce faisant, vous pouvez utiliser la classe imbriquée sans avoir d'instance de la classe externe.

class OuterClass{
    public static class StaticNestedClass{
    }

    public class InnerClass{
    }

    public InnerClass getAnInnerClass(){
        return new InnerClass();
    }

    //This method doesn't work
    public static InnerClass getAnInnerClassStatically(){
        return new InnerClass();
    }
}

class OtherClass{
    //Use of a static nested class:
    private OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();

    //Doesn't work
    private OuterClass.InnerClass innerClass = new OuterClass.InnerClass();

    //Use of an inner class:
    private OuterClass outerclass= new OuterClass();
    private OuterClass.InnerClass innerClass2 = outerclass.getAnInnerClass();
    private OuterClass.InnerClass innerClass3 = outerclass.new InnerClass();
}

Sources :

• Tutoriel Oracle sur les classes imbriquées

Sur le même sujet:

• Java: classe interne statique vs non statique
• Classe interne Java et classe imbriquée statique

Les classes de niveau supérieur sont statiques par défaut. Les classes internes ne sont pas statiques par défaut. Vous pouvez modifier la valeur par défaut des classes internes en les marquant explicitement comme statiques. Les classes de niveau supérieur, en raison de leur niveau supérieur, ne peuvent pas avoir de sémantique non statique car il ne peut y avoir de classe parent à laquelle se référer. Par conséquent, il n'existe aucun moyen de modifier la valeur par défaut pour les classes de niveau supérieur.

Donc, je viens en retard à la fête, mais voici mes deux cents - ajoutant philosophiquement à la réponse de Colin Hebert.

À un niveau élevé, votre question porte sur la différence entre les objets et les types. Bien qu'il existe de nombreuses voitures (objets), il n'y a qu'une seule classe de voitures (type). Déclarer quelque chose comme statique signifie que vous travaillez dans l'espace "type". Il n'y a qu'un seul. Le mot-clé de classe de niveau supérieur définit déjà un type dans l'espace "type". Par conséquent, la «voiture de classe statique publique» est redondante.

La classe avec constructeur privé est statique.

Déclarez votre classe comme ceci:

public class eOAuth {

    private eOAuth(){}

    public final static int    ECodeOauthInvalidGrant = 0x1;
    public final static int    ECodeOauthUnknown       = 0x10;
    public static GetSomeStuff(){}

}

et vous pouvez utiliser sans initialisation:

if (value == eOAuth.ECodeOauthInvalidGrant)
    eOAuth.GetSomeStuff();
...

Bien sûr qu'ils le peuvent, mais uniquement les classes imbriquées internes . Là, cela signifie que les instances de la classe imbriquée ne nécessitent pas d'instance englobante de la classe externe.

Mais pour les classes de haut niveau, les concepteurs de langage ne pouvaient penser à rien d'utile à faire avec le mot-clé, donc ce n'est pas autorisé.

Vous pouvez créer une classe utilitaire (qui ne peut pas avoir d'instances créées) en déclarant un type enum sans instances. c'est-à-dire que vous déclarez spécifiquement qu'il n'y a pas d'instances.

public enum MyUtilities {;
   public static void myMethod();
}

public class Outer {
   public static class Inner {}
}

... il peut être déclaré statique - tant qu'il s'agit d'une classe membre.

Du JLS:

Les classes membres peuvent être statiques, auquel cas elles n'ont pas accès aux variables d'instance de la classe environnante; ou ils peuvent être des classes internes (§8.1.3).

et ici:

Le mot clé statique peut modifier la déclaration d'un type de membre C dans le corps d'une classe non interne T. Son effet est de déclarer que C n'est pas une classe interne. Tout comme une méthode statique de T n'a pas d'instance actuelle de T dans son corps, C n'a pas non plus d'instance actuelle de T, ni aucune instance lexicalement englobante.

Un mot clé statique n'aurait aucun sens pour une classe de niveau supérieur, simplement parce qu'une classe de niveau supérieur n'a pas de type englobant.

Comme expliqué ci-dessus, une classe ne peut être statique que si elle est membre d'une autre classe.

Si vous cherchez à concevoir une classe "dont il ne peut pas y avoir plusieurs instances", vous voudrez peut-être examiner le modèle de conception "Singleton".

Débutant Singleton info ici .

Caveat:

Si vous songez à utiliser le motif singleton, résistez de toutes vos forces. C'est l'un des DesignPatterns les plus faciles à comprendre, probablement le plus populaire et certainement le plus abusé. (source: JavaRanch comme indiqué ci-dessus)

En plus de la façon dont Java définit les classes internes statiques, il existe une autre définition des classes statiques selon le monde C # [1] . Une classe statique est une classe qui n'a que des méthodes (fonctions) statiques et qui est destinée à prendre en charge la programmation procédurale. De telles classes ne sont pas vraiment des classes dans la mesure où l'utilisateur de la classe ne s'intéresse qu'aux fonctions d'assistance et non à la création d'instances de la classe. Bien que les classes statiques soient prises en charge en C #, aucune prise en charge directe n'existe en Java. Vous pouvez cependant utiliser des énumérations pour imiter les classes statiques C # en Java afin qu'un utilisateur ne puisse jamais créer d'instances d'une classe donnée (même en utilisant la réflexion) [2] :

public enum StaticClass2 {
    // Empty enum trick to avoid instance creation
    ; // this semi-colon is important

    public static boolean isEmpty(final String s) {
        return s == null || s.isEmpty();
    }
}

Tout ce que nous codons en java va dans une classe. Chaque fois que nous exécutons une classe, la JVM instancie un objet. JVM peut créer un certain nombre d'objets, par définition statique signifie que vous avez le même jeu de copie pour tous les objets.

Ainsi, si Java aurait permis à la classe supérieure d'être statique chaque fois que vous exécutez un programme, il crée un objet et continue de remplacer le même emplacement mémoire.

Si vous remplacez simplement l'objet à chaque fois que vous l'exécutez, quel est l'intérêt de le créer?

C'est donc la raison pour laquelle Java s'est débarrassé de la statique pour la classe de niveau supérieur.

Il pourrait y avoir des raisons plus concrètes, mais cela avait beaucoup de sens logique pour moi.

Les seules classes qui peuvent être statiques sont les classes internes. Le code suivant fonctionne très bien:

public class whatever {
    static class innerclass {
    }
}

Le point des classes internes statiques est qu'elles n'ont pas de référence à l'objet de classe externe.

Je pense que c'est aussi simple que de boire un verre de café!. Jetez un coup d'oeil à cela. Nous n'utilisons pas explicitement de mot clé statique lors de la définition de classe.

public class StaticClass {

    static private int me = 3;
    public static void printHelloWorld() {
       System.out.println("Hello World");
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

N'est-ce pas une définition de la classe statique? Nous utilisons simplement une fonction liée à une seule classe. Attention, dans ce cas, nous pouvons utiliser une autre classe dans celle imbriquée. Regarde ça:

class StaticClass1 {

    public static int yum = 4;

    static void  printHowAreYou() {
        System.out.println("How are you?");
    }
}

public class StaticClass {

    static int me = 3; 
    public static void printHelloWorld() {
       System.out.println("Hello World");
       StaticClass1.printHowAreYou();
       System.out.println(StaticClass1.yum);
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

On peut regarder PlatformUIdans Eclipse pour une classe avec des méthodes statiques et un constructeur privé lui-même étant final.

public final class <class name>
{
   //static constants
   //static memebers
}

si l'avantage d'utiliser une classe statique n'était pas d'instancier un objet et d'utiliser une méthode, il suffit de déclarer la classe comme publique et cette méthode comme statique.