Pourquoi ne pouvez-vous pas déclarer une classe statique en Java?
Pourquoi ne pouvez-vous pas déclarer une classe 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:
Sur le même sujet:
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 pour les classes internes en les marquant explicitement de manière statique. Les classes de niveau supérieur, du fait qu'elles sont de niveau supérieur, ne peuvent pas avoir de sémantique non statique car il ne peut y avoir de classe parente à 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, j'arrive en retard à la fête, mais voici mes deux sous - ajouter 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 y ait beaucoup de voitures (objets), il n'y a qu'une seule classe de voiture (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, "public static class Car" est redondant.
La classe avec le 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, ils peuvent, mais seulement interne classes imbriquées. Là, cela signifie que les instances de la classe imbriquée ne nécessitent pas d'instance englobante de la classe externe.
Toutefois, pour les classes de niveau supérieur, les concepteurs de langage ne trouvaient rien d’utile à faire avec le mot clé. Ce n’est donc pas autorisé.
Vous pouvez créer une classe d'utilitaire (dans laquelle aucune instance ne peut être créée) en déclarant un type enum sans instance. c'est-à-dire que vous déclarez spécifiquement qu'il n'y a pas d'instance.
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 intérieures (§8.1.3).
et ici:
Le mot clé static peut modifier la déclaration d'un membre de type C dans le corps d'une classe non-interne T. Son effet est de déclarer que C n'est pas une classe interne. Exactement 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 d’instances englobant lexicalement.
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 envisagez de concevoir une classe "dont il ne peut y avoir plusieurs instances", vous pouvez consulter le modèle de conception "Singleton".
Débutant Singleton info ici .
Caveat:
Si vous envisagez d'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 maltraité. (source: JavaRanch comme lié ci-dessus)
Outre 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 ne comporte que des méthodes statiques (fonctions) et qui est conçue pour prendre en charge la programmation procédurale. De telles classes ne sont pas vraiment des classes en ce sens que l'utilisateur de la classe n'est intéressé que par les fonctions d'assistance et non par la création d'instances de la classe. Bien que les classes statiques soient prises en charge en C #, aucune telle prise en charge directe n'existe en Java. Vous pouvez toutefois utiliser des énumérations pour imiter les classes statiques C # dans Java de sorte qu'un utilisateur ne puisse jamais créer d'instances d'une classe donnée (même à l'aide de 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();
}
}
Les seules classes pouvant être statiques sont les classes internes. Le code suivant fonctionne très bien:
public class whatever {
static class innerclass {
}
}
L'intérêt des classes internes statiques est de ne pas avoir de référence à l'objet de classe externe.
Tout ce que nous codons dans Java entre dans une classe. Chaque fois que nous exécutons une classe, la machine virtuelle Java instancie un objet. La machine virtuelle Java peut créer un certain nombre d'objets. Par définition, statique signifie que vous disposez du 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écuterez un programme, il créera un objet et continuera à se substituer au 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 la raison pour laquelle Java s’est débarrassé de la valeur statique pour la classe de niveau supérieur.
Il y a peut-être des raisons plus concrètes, mais cela me semble très logique.
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 le mot clé statique lors de la définition de la 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 classe statique? Nous utilisons simplement une fonction liée à une classe. Veillez à ce que dans ce cas, nous puissions utiliser une autre classe 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 PlatformUI dans Eclipse pour une classe avec méthodes statiques et 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'est pas d'instancier un objet et d'utiliser une méthode, il suffit de déclarer la classe publique et cette méthode statique.