Est-ce qu'un Nested statique de classe instancier plusieurs fois?

Question

Étant donné ce que je sais de tout autre type de fonction statique de la programmation - Je pense que la réponse est « non ». Cependant, voir des déclarations comme OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); me demande.

Answer 1

Oui, il n'y a rien dans la sémantique d'un type imbriqué static qui vous empêche de le faire. Cet extrait de fin fonctionne.

public class MultipleNested {
    static class Nested {
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Nested();
        }
    }
}

Voir aussi

• public static interface Map.Entry<K,V>
  • public static class AbstractMap.SimpleEntry<K,V>
    • Probablement le type imbriqué le plus connu. De toute évidence instancié plusieurs fois.

---

Maintenant, bien sûr, le type imbriqué peut faire son propre contrôle d'instance (par exemple private des constructeurs, singleton, etc), mais cela n'a rien à voir avec le fait que c'est un type imbriqué. En outre, si le type imbriqué est un static enum, bien sûr, vous ne pouvez pas instancier du tout.

Mais en général, oui, un type imbriqué static peut être instancié plusieurs fois.

Notez que sur le plan technique, un type imbriqué static est pas un type "intérieur".

JLS 8.1.3 classes internes et Enclosing Les instances

  

Une interne classe est une classe imbriquée non déclarée explicitement ou implicitement static.

C'est, selon la terminologie JLS, une intérieure classe est celui qui ne static. Si elle est static, il est juste un type imbriqué.

---

Alors, que signifie le mot de static?

static signifie simplement que le type imbriqué n'a pas besoin d'une instance de type enfermant à instancier.

Voir aussi

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

Answer 2

  

@polygenelubricants:   Mais en général, oui, statique imbriquée   type peut être instancié multiples   fois.

Juste pour être sûr à 100% que j'étendu votre extrait:

public class MultipleInner {
    static class Inner {
        private int state;
        public int getState() { return state; }
        public void setState(int state) { this.state = state; }
    }

    public static void main(String[] args) {
        List<Inner> inners = new ArrayList<Inner>();
        for (int i = 0; i < 100; i++) {
            Inner inner = new Inner();
            inner.setState(i);
            inners.add(inner);
        }
        for (Inner inner : inners) {
            System.out.println(inner.getState());
        }
    }
}

Et bien sûr, le résultat est:

0
1
2
3
.
.
.
97
98
99

Answer 3

Il est légal. Le fait que la classe interne est statique vous donne un avantage ici; ses instances ne sont pas liés à une instance de la classe contenant, de sorte qu'ils peuvent être instanciés librement (à condition que le qualificatif d'accès le permet).

Le prix, cependant, est que la classe interne ne peut pas utiliser les membres non statiques / méthodes de la classe contenant.

Answer 4

Oui, vous pouvez faire des cas de celui-ci autant de fois que vous le souhaitez.

Peut-être la raison pour laquelle vous voyez que, parce que le programme a pensé à stocker un endroit de référence. Bien que je suis d'accord avec vous semble étrange: S

Answer 5

Classe interne peut utiliser des membres non statiques / méthodes de classe contenant. Il peut les utiliser que par une référence d'objet de la classe englobante -

     public class MultipleInner {
      private int outerstate =10;
      static class Inner {
        private int state;
        public int getState() { return state; }
        public void setState(int state) { this.state = state; }
      }

     public static void main(String[] args) {       
        Inner inner = new Inner();
        inner.setState(new MultipleInner().outerstate);
        System.out.println(inner.getState());        
     }

}

Alors, classe interne ne doit pas payer le prix de ne pas pouvoir accéder aux membres non statiques de la classe englobante.

Answer 6

classes imbriquées statiques sont en effet instanciés - ils sont, comme on dit, des classes de haut niveau qui vivent dans l'espace de la classe « externe », et respecter les consignes de la sémantique statique concernant les références à la classe « extérieure ». Cet exemple de code montre:

public class OuterClass {
    String outerStr = "this is the outer class!!" ;
    public static class StaticNestedClass {
        String innerStr = "default / first instance" ;      
    }

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nestedObject1 = new OuterClass.StaticNestedClass();        
        OuterClass.StaticNestedClass nestedObject2 = new OuterClass.StaticNestedClass();
        nestedObject2.innerStr = "second instance" ;
        System.out.println(nestedObject1.innerStr) ;
        System.out.println(nestedObject2.innerStr) ;
    }
}

output:

default / first instance 
second instance