Quelles sont les règles qui dictent l'héritage de la statique des variables en Java?

J'ai une classe, Super:

public class Super {
    public static String foo = "foo";
}

J'ai aussi une autre classe, Sub qui s'étend Super:

public class Sub extends Super {
    static {
        foo = "bar";
    }

    public static void main (String[] args) {
        System.out.println(Super.foo);
    }
}

Quand je le lance, il imprime bar.

Mon troisième (et dernier) de la classe est Testing:

public class Testing {
    public static void main (String[] args) {
        System.out.println(Super.foo);
        System.out.println(Sub.foo);
        System.out.println(Super.foo);
    }
}

Cette affiche:

foo
foo
foo

Je ne comprends pas pourquoi le contenu de foo varier en fonction de la catégorie à laquelle vous accédez à partir de. Quelqu'un peut-il m'expliquer?

Ce que je voulais dire par cette déclaration a été que quand j'y accéder à partir de Testing il renvoie à quelque chose de différent que quand j'y accéder à partir de Sub.
@jmgrosen: Ah, maintenant avec vous.
FWIW, note la distinction importante entre ce que vous avez ci-dessus et ce que vous auriez si Sub contenues public static String foo = "bar"; (après quoi, vous obtenez "foo", "bar", "toto" comme vous l'avez sans doute s'attendre).
Je ne suis pas sûr si le comportement de ce code est un argument contre le fait d'avoir des variables statiques qui ne sont ni privés ni définitif, ou à l'encontre de laisser les initialiseurs statiques (même implicitement) mess avec d'autres classes de variables statiques. Sans doute les deux.

InformationsquelleAutor jmgrosen | 2012-03-27

inheritance java

42

Je ne comprends pas pourquoi le contenu de foo varier en fonction de la catégorie à laquelle vous accédez à partir de.

En gros, c'est une question de type d'initialisation. La valeur de foo est fixé à "bar" quand Sub est initialisé. Cependant, dans votre Testing classe, la référence à Sub.foo est effectivement compilé dans une référence à Super.foo, afin de ne pas finir l'initialisation Sub, donc foo ne devient jamais "bar".

Si vous modifiez votre code de Test pour:
```
public class Testing {
    public static void main (String[] args) {
        Sub.main(args);
        System.out.println(Super.foo);
        System.out.println(Sub.foo);
        System.out.println(Super.foo);
    }
}
```
Alors il serait imprimer "de la barre" quatre fois, car la première instruction de la force Sub être initialisé, ce qui permettrait de modifier la valeur de foo. Ce n'est pas une question de l'endroit où il est accessible à partir de tous.

Noter que ce n'est pas seulement à propos de la classe chargement - c'est à propos de la classe initialisation. Les Classes peuvent être chargés sans être initialisé. Par exemple:
```
public class Testing {
    public static void main (String[] args) {
        System.out.println(Super.foo);
        System.out.println(Sub.class);
        System.out.println(Super.foo);
    }
}
```
Qui imprime toujours "foo" par deux fois, en montrant que Sub n'est pas initialisée, mais il est certainement chargé, et à l'échec, si vous supprimez le Sub.class fichier avant de l'exécuter, par exemple.
- Cela semble correct, mais savez-vous pourquoi Sub.foo est compilé dans Super.foo?
- Oui - parce qu'il y a une seule variable, déclaré par Super. Comme maerics dit, il est accessible via Sub, mais cela ne veut pas dire que c'est une variable différente.
- est le même cas pour la finale de membres également
- Je ne suis pas sûr exactement ce que vous demandez sur, pour être honnête... un dernier membre ne peut être attribuée qu'une fois de toute façon.
- Ainsi, si nous avions une variable statique défini dans Sub il serait forcer pour initialiser le Sub classe et exécuter le bloc statique?
- Seulement si vous vous référez à cette variable. Ce n'est pas tout à fait clair ce que vous demandez, mais il semble que vous devriez être en mesure de le tester par vous-même.
- Yep, je l'ai juste testé. Merci! Une dernière chose: le fait que Sub.foo est compilé dans une référence à Super.foo et il n'a pas d'initialiser le Sub classe a un nom?
- Non pas que je suis au courant de.
- "Fondamentalement, c'est une question de type d'initialisation" Non, vraiment, c'est une question de chargement de classe. Blocs statiques exécuter lorsque la classe est chargée, première instanciation(ou l'appel d'une méthode statique) d'être une cause de la classe en cours de chargement
- Benetatos , Exactement, dans ce cas Sous-classe n'est jamais chargé, car il n'est jamais mentionné.
- Le Sous-type n'est pas en cours d'initialisation, car c'est de ne jamais être chargé, car il n'est jamais fait référence. Si une classe pourrait être chargé sans être initialisé (par exemple, par la réflexion), puis foo ne serait pas encore mis à "bar". Chargement de classe est ce qui déclenche habituellement le type d'initialisation, mais je maintiens que c'est le type d'initialisation qui est important ici.
- Et, en fait, à l'aide de Sub.class est charger la classe sans l'initialiser, ce qui prouve que c'est vraiment le type d'initialisation plutôt que de classe de chargement qui est important. Modifier la note que la.
InformationsquelleAutor Jon Skeet

Il n'importe pas où vous modifiez la valeur d'une variable statique, c'est la même variabile foo, dans Sub ou Super. Il n'est pas question ni combien de new Sub ou new Super les objets que vous créez et modifiez ensuite. Le changement sera vu partout depuis Super.foo, Sub.foo, obj.foo partager la même pièce de stockage.Cela fonctionne avec les types primitifs également:

class StaticVariable{
public static void main(String[] args){
System.out.println("StaticParent.a = " + StaticParent.a);//a = 2
System.out.println("StaticChild.a = " + StaticChild.a);//a = 2
StaticParent sp = new StaticParent();
System.out.println("StaticParent sp = new StaticParent(); sp.a = " + sp.a);//a = 2
StaticChild sc = new StaticChild();
System.out.println(sc.a);//a = 5
System.out.println(sp.a);//a = 5
System.out.println(StaticParent.a);//a = 5
System.out.println(StaticChild.a);//a = 5
sp.increment();//result would be the same if we use StaticParent.increment(); or StaticChild.increment();
System.out.println(sp.a);//a = 6
System.out.println(sc.a);//a = 6
System.out.println(StaticParent.a);//a = 6
System.out.println(StaticChild.a);//a = 6
sc.increment();
System.out.println(sc.a);//a = 7
System.out.println(sp.a);//a = 7
System.out.println(StaticParent.a);//a = 7
System.out.println(StaticChild.a);//a = 7
}
}
class StaticParent{
static int a = 2;
static void increment(){
a++;
}
}
class StaticChild extends StaticParent{
static { a = 5;}
}

Vous pouvez faire référence à une variable statique, de méthode, de par l'objet (comme sc.a) ou via c'est un nom de classe (comme StaticParent.a). Il est préférable d'utiliser le ClassName.staticVariable de souligner la nature statique de la variable, de méthode, et pour donner le compilateur de meilleures possibilités d'optimisation.

InformationsquelleAutor Dragos Papp

-3

Membres statiques ne sont pas héréditaire en java, car ils sont les propriétés de la classe et ils sont chargés dans l'espace de la classe. ils n'avaient rien à voir avec la création de l'objet. toutefois, seuls les enfants des classes peuvent accéder à la statique des membres de leur parent classes.
- Cela est vrai (ils ne sont pas "hérité" d'autant que "partagé"), les devinettes c'est-voté parce qu'il ne répond pas à la question.
InformationsquelleAutor SIKANDAR

Vous devez vous connecter pour publier un commentaire.