Classes statiques en Java

Y a-t-il quelque chose comme static classen java?

Quel est le sens d'une telle classe. Toutes les méthodes de la classe statique doivent-elles l'être staticégalement?

Est-il obligatoire dans l'autre sens, que si une classe contient toutes les méthodes statiques, la classe doit-elle aussi être statique?

À quoi servent les classes statiques?

Java a des classes imbriquées statiques , mais il semble que vous recherchiez une classe statique de niveau supérieur. Java n'a aucun moyen de rendre statique une classe de niveau supérieur, mais vous pouvez simuler une classe statique comme celle-ci:

• Déclarez votre classe final- Empêche l'extension de la classe car l'extension d'une classe statique n'a aucun sens
• Make the constructor private- Empêche l'instanciation par le code client car cela n'a aucun sens d'instancier une classe statique
• Créer tous les membres et fonctions de la classe static- Étant donné que la classe ne peut pas être instanciée, aucune méthode d'instance ne peut être appelée ni aucun champ d'instance accessible
• Notez que le compilateur ne vous empêchera pas de déclarer un membre d'instance (non statique). Le problème n'apparaîtra que si vous essayez d'appeler le membre de l'instance

Exemple simple par suggestions ci-dessus:

public class TestMyStaticClass {
     public static void main(String []args){
        MyStaticClass.setMyStaticMember(5);
        System.out.println("Static value: " + MyStaticClass.getMyStaticMember());
        System.out.println("Value squared: " + MyStaticClass.squareMyStaticMember());
        // MyStaticClass x = new MyStaticClass(); // results in compile time error
     }
}

// A top-level Java class mimicking static class behavior
public final class MyStaticClass {
    private MyStaticClass () { // private constructor
        myStaticMember = 1;
    }
    private static int myStaticMember;
    public static void setMyStaticMember(int val) {
        myStaticMember = val;
    }
    public static int getMyStaticMember() {
        return myStaticMember;
    }
    public static int squareMyStaticMember() {
        return myStaticMember * myStaticMember;
    }
}

À quoi servent les classes statiques? Une bonne utilisation d'une classe statique consiste à définir des classes ponctuelles, utilitaires et / ou de bibliothèque où l'instanciation n'aurait pas de sens. Un bon exemple est la classe Math qui contient des constantes mathématiques telles que PI et E et fournit simplement des calculs mathématiques. Exiger l'instanciation dans un tel cas serait inutile et déroutant. Voir la Mathclasse et le code source . Notez que c'est le cas finalet que tous ses membres le sont static. Si Java permettait de déclarer des classes de niveau supérieur, staticla classe Math serait en effet statique.

Eh bien, Java a des "classes imbriquées statiques", mais elles ne sont pas du tout les mêmes que les classes statiques de C #, si c'est de là que vous veniez. Une classe imbriquée statique n'est qu'une classe qui n'a pas implicitement une référence à une instance de la classe externe.

Les classes imbriquées statiques peuvent avoir des méthodes d'instance et des méthodes statiques.

Il n'y a rien de tel qu'une classe statique de niveau supérieur en Java.

Il existe une classe imbriquée statique , cette classe [imbriquée statique] n'a pas besoin d'une instance de la classe englobante pour être instanciée elle-même.

Ces classes [celles qui sont imbriquées statiques] ne peuvent accéder qu'aux membres statiques de la classe englobante [car elles n'ont aucune référence aux instances de la classe englobante ...]

exemple de code:

public class Test { 
  class A { } 
  static class B { }
  public static void main(String[] args) { 
    /*will fail - compilation error, you need an instance of Test to instantiate A*/
    A a = new A(); 
    /*will compile successfully, not instance of Test is needed to instantiate B */
    B b = new B(); 
  }
}

Oui, il existe une classe imbriquée statique en java. Lorsque vous déclarez une classe imbriquée statique, elle devient automatiquement une classe autonome qui peut être instanciée sans avoir à instancier la classe externe à laquelle elle appartient.

Exemple:

public class A
{

 public static class B
 {
 }
}

Parce que class Best déclaré statique, vous pouvez explicitement instancier:

B b = new B();

Notez que s'il class Bn'a pas été déclaré statique pour le rendre autonome, un appel d'objet d'instance aurait ressemblé à ceci:

A a= new A();
B b = a.new B();

Que se passe-t-il lorsqu'un membre à l'intérieur d'un classest déclaré comme static..? Les membres sont accessibles sans instancier le class. Par conséquent, créer une classe externe (classe de niveau supérieur) staticn'a aucun sens. Ce n'est donc pas autorisé.

Mais vous pouvez définir des classes internes comme statiques (car c'est un membre de la classe de niveau supérieur). Ensuite, cette classe est accessible sans instancier la classe de niveau supérieur. Prenons l'exemple suivant.

public class A {
    public static class B {

    }
}

Maintenant, à l'intérieur d'une classe différente C, la classe Best accessible sans créer d'instance de classe A.

public class C {
    A.B ab = new A.B();
}

staticles classes peuvent aussi avoir des non-staticmembres. Seule la classe devient statique.

Mais si le staticmot-clé est supprimé de la classe B, il n'est pas accessible directement sans créer une instance de A.

public class C {
    A a = new A();
    A.B ab = a. new B();
}

Mais nous ne pouvons pas avoir de staticmembres à l'intérieur d'une non-staticclasse intérieure.

Étant donné que c'est le meilleur résultat sur Google pour "java de classe statique" et que la meilleure réponse n'est pas ici, j'ai pensé que je l'ajouterais. J'interprète la question d'OP comme concernant les classes statiques en C #, qui sont connues sous le nom de singletons dans le monde Java. Pour ceux qui ne le savent pas, en C # le mot-clé "statique" peut être appliqué à une déclaration de classe ce qui signifie que la classe résultante ne peut jamais être instanciée.

Extrait de "Effective Java - Second Edition" de Joshua Bloch (largement considéré comme l'un des meilleurs guides de style Java disponibles):

Depuis la version 1.5, il existe une troisième approche pour implémenter les singletons. Créez simplement un type enum avec un élément:

// Enum singleton - the preferred approach
public enum Elvis {
    INSTANCE;
    public void leaveTheBuilding() { ... }
}

Cette approche est fonctionnellement équivalente à l'approche du domaine public, sauf qu'elle est plus concise, fournit gratuitement le mécanisme de sérialisation et fournit une garantie à toute épreuve contre les instanciations multiples, même face à des attaques sophistiquées de sérialisation ou de réflexion. Bien que cette approche n'ait pas encore été largement adoptée, un type d'énumération à un seul élément est le meilleur moyen d'implémenter un singleton. (souligné par l'auteur)

Bloch, Joshua (2008-05-08). Java efficace (série Java) (p. 18). Éducation Pearson.

Je pense que la mise en œuvre et la justification sont assez explicites.

Une classe peut-elle être statique en Java?

La réponse est OUI , nous pouvons avoir une classe statique en java. En java, nous avons des variables d'instance statiques ainsi que des méthodes statiques et également un bloc statique . Les classes peuvent également être rendues statiques en Java.

En java, nous ne pouvons pas rendre la classe de niveau supérieur (externe) statique. Seules les classes imbriquées peuvent être statiques.

classe imbriquée statique vs classe imbriquée non statique

1) La classe statique imbriquée n'a pas besoin d'une référence de classe externe, mais la classe imbriquée non statique ou la classe interne nécessite une référence de classe externe.

2) La classe interne (ou classe imbriquée non statique) peut accéder aux membres statiques et non statiques de la classe externe. Une classe statique ne peut pas accéder aux membres non statiques de la classe Outer. Il ne peut accéder qu'aux membres statiques de la classe Outer.

voir ici: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

Les classes externes ne peuvent pas être statiques, mais les classes imbriquées / internes peuvent l'être. Cela vous aide essentiellement à utiliser la classe imbriquée / interne sans créer d'instance de la classe externe.

En termes simples, Java prend en charge la déclaration d'une classe comme étant statique uniquement pour les classes internes mais pas pour les classes de niveau supérieur.

classes de niveau supérieur: un projet java peut contenir plusieurs classes de niveau supérieur dans chaque fichier source java, l'une des classes étant nommée d'après le nom du fichier. Il n'y a que trois options ou mots-clés autorisés devant les classes de niveau supérieur, public, abstrait et final .

Classes internes : les classes qui se trouvent à l'intérieur d'une classe de niveau supérieur sont appelées classes internes, ce qui est essentiellement le concept de classes imbriquées. Les classes internes peuvent être statiques . L'idée de rendre les classes internes statiques, est de profiter de l'instanciation des objets des classes internes sans instancier l'objet de la classe de niveau supérieur. C'est exactement de la même manière que les méthodes et variables statiques fonctionnent à l'intérieur d'une classe de niveau supérieur.

Par conséquent, Java prend en charge les classes statiques au niveau de la classe interne (dans les classes imbriquées)

Et Java ne prend pas en charge les classes statiques aux classes de niveau supérieur.

J'espère que cela donne une solution plus simple à la question de la compréhension de base des classes statiques en Java.

Java a des méthodes statiques qui sont associées aux classes (par exemple java.lang.Math n'a que des méthodes statiques), mais la classe elle-même n'est pas statique.

Vous ne pouvez pas utiliser le mot clé statique avec une classe sauf s'il s'agit d'une classe interne. Une classe interne statique est une classe imbriquée qui est un membre statique de la classe externe. Il est accessible sans instancier la classe externe, en utilisant d'autres membres statiques. Tout comme les membres statiques, une classe imbriquée statique n'a pas accès aux variables d'instance et aux méthodes de la classe externe.

public class Outer {
   static class Nested_Demo {
      public void my_method() {
          System.out.println("This is my nested class");
      }
   }
public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();
      nested.my_method();
   }
}

Une méthode statique signifie qu'elle est accessible sans créer d'objet de la classe, contrairement à public:

public class MyClass {
   // Static method
   static void myStaticMethod() {
      System.out.println("Static methods can be called without creating objects");
   }

  // Public method
  public void myPublicMethod() {
      System.out.println("Public methods must be called by creating objects");
   }

  // Main method
  public static void main(String[ ] args) {
      myStaticMethod(); // Call the static method
    // myPublicMethod(); This would output an error

    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method
  }
}

Toutes les bonnes réponses, mais je n'ai pas vu de référence à java.util.Collections qui utilise des tonnes de classe interne statique pour leurs méthodes de facteur statique. Donc, en ajoutant la même chose.

Ajout d'un exemple de java.util.Collections qui a plusieurs classes internes statiques. Les classes internes sont utiles pour regrouper le code qui doit être accessible via la classe externe.

/**
 * @serial include
 */
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
                             implements Set<E>, Serializable {
    private static final long serialVersionUID = -9215047833775013803L;

    UnmodifiableSet(Set<? extends E> s)     {super(s);}
    public boolean equals(Object o) {return o == this || c.equals(o);}
    public int hashCode()           {return c.hashCode();}
}

Voici la méthode du facteur statique dans la classe java.util.Collections

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
    return new UnmodifiableSet<>(s);
}