Static et non static. Comment faire?

bonjour,

J'ai un code on ne peux plus simple (simplifié au minimum)

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class MyLNReader2 { public class LineCounter { LineCounter (String f){ } }   public static void main(String[] args) { new LineCounter("abc"); } }

---

J'ai un problème suivant :
MyLNReader2.java:17: non-static variable this cannot be referenced from a static context
new LineCounter("abc");
^
1 error


1/ Pourquoi?
2/ Comment faire pour créer autant de LineCounter que args.legth et passer des [I]args à la place de "abc" ?

Merci

Bonjour,

La méthode main est statique donc elle ne peut pas contenir de référence faire des attributs non statiques.

Tu as donc deux solutions pour résourdre ton problème :
- Soit tu déclares la classe LineCounter en tant que membre statique de la MyLNReader2.

- Soit extrais la classe LineCounter de la classe MyLNReader2 pour en faire une classe non membre (une classe normale). Pour cela tu crée un nouveau fichier :
Fichier LineCounter.java :

Code:

---

1 2 3 4 5

public class LineCounter { public LineCounter (String f){ } }

---

Fichier MyLNReader2.java :

Code:

---

1 2 3 4 5 6

public class MyLNReader2 { public static void main(String[] args) { new LineCounter("abc"); } }

---

Pour ton second problème, tu peux faire une boucle for dans la méthode main :
Fichier MyLNReader2.java :

Code:

---

1 2 3 4 5 6 7 8

public class MyLNReader2 { public static void main(String[] args) { for (int i = 0; i < args.length; i++) { new LineCounter(args[i]); } } }

---

A+
Gronono

Citation:

---

Envoyé par gronono

Bonjour,

La méthode main est statique donc elle ne peut pas contenir de référence faire des attributs non statiques.

Tu as donc deux solutions pour résourdre ton problème :
- Soit tu déclares la classe LineCounter en tant que membre statique de la MyLNReader2.

- Soit extrais la classe LineCounter de la classe MyLNReader2 pour en faire une classe non membre (une classe normale). Pour cela tu crée un nouveau fichier :
Fichier LineCounter.java :

Code:

---

1 2 3 4 5

public class LineCounter { public LineCounter (String f){ } }

---

Fichier MyLNReader2.java :

Code:

---

1 2 3 4 5 6

public class MyLNReader2 { public static void main(String[] args) { new LineCounter("abc"); } }

---

A+
Gronono

---

Effectivement avec 2 fichiers séparés ça marche. Mais je ne comprends pas trop pourquoi.
1/ Quelle est la difference avec une classe séparée et une classe interne (à part l'accès)?

2/ Si je déclare ma classe LineCounter interne static dans ce cas là je ne dois pas l'appeler avec new LineCounter("abc"); ?

Salut,

Citation:

---

Envoyé par cmako

1/ Quelle est la difference avec une classe séparée et une classe interne (à part l'accès)?

---

Une classe interne non-static est lié à une instance de la classe parente, c'est ce qui te permet d'appeler la classe parente en utilisant "NomDeLaClasse.this". Ce lien implique qu'on ne puisse créer de classe Fille que depuis une instance de la classe Parent (et donc pas depuis une méthode static comme main()) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class Parent {   public class Fille { public Parent getParent() { // retourne l'instance de la classe // parente lié à cette classe : return Parent.this; } }     public Fille createFille() { // Crée une classe fille lié à cette instance : return new Fille(); }   }

---

Par contre si la classe interne est static, elle n'est lié à aucune instance de la classe parente et peut être utilisé normalement comme toutes les autres classes (mais elle conserve des relations privilégié avec sa classe parente en ce qui concerne la visibilité des attributs et méthodes).

Citation:

---

Envoyé par cmako

2/ Si je déclare ma classe LineCounter interne static dans ce cas là je ne dois pas l'appeler avec new LineCounter("abc"); ?

---

Si justement...

a++

En déclarant une classe à l'intérieur d'une autre, tu fais d'elle une classe membre. Elle n'est accessible que par la classe dans laquelle elle a été déclaré (comme pour les attributs).
A chaque nouvelle instance de ta classe correspond alors une déclaration de la classe incluse.

Si tu déclare la classe interne statique, alors elle est déclaré une et une fois pour toutes les instances de la classe englobante.

Si tu déclare la classe dans un autre fichier, alors ta classe est partagé par les autres classes et n'existe qu'une seule déclaration.

Le choix de l'emplacement de la déclaration est une question de visibilité vis à vis des autres classes.
Si une classe doit être utilisée par plusieurs autres classes, alors elle sera placé dans un fichier externe.
Par contre si la classe n'est utilisée que dans une autre classe, elle peut être déclarée en classe interne. Le plus souvent elle sera statique pour éviter d'avoir une déclaration par instance de la classe englobante.


En espérant avoir était clair.
A+
Gronono

Edit : Grilled par adiGuba

Bonjour,
Si tu préfères garder ta classe interne non-static, voici la syntaxe pour en créer une instance depuis une classe externe ou une méthode static :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public class MyLNReader2 { public class LineCounter { LineCounter (String f){ } } public static void main(String[] args) { MyLNReader2.LineCounter lc = new MyLNReader2().new LineCounter("abc"); } }

---

Une instance de la classe interne non-static doit toujours être liée à une instance de la classe englobante.

Citation:

---

Envoyé par gronono

En déclarant une classe à l'intérieur d'une autre, tu fais d'elle une classe membre. Elle n'est accessible que par la classe dans laquelle elle a été déclaré (comme pour les attributs).

---

Heu... Non cela dépend de la visibilité que tu lui donnes (public, protected, package ou private). Le fait qu'elle soit interne ou pas n'a aucune incidence là dessus (si ce n'est qu'une classe interne peut être déclaré protected ou private).

Citation:

---

Envoyé par gronono

A chaque nouvelle instance de ta classe correspond alors une déclaration de la classe incluse.

Si tu déclare la classe interne statique, alors elle est déclaré une et une fois pour toutes les instances de la classe englobante.

---

Non : la déclaration des classes est bien unique dans les deux ! Il n'y a qu'un lien entre les instances créées dans le cas d'une classe interne non-static...

Citation:

---

Envoyé par gronono

Le choix de l'emplacement de la déclaration est une question de visibilité vis à vis des autres classes.
Si une classe doit être utilisée par plusieurs autres classes, alors elle sera placé dans un fichier externe.
Par contre si la classe n'est utilisée que dans une autre classe, elle peut être déclarée en classe interne. Le plus souvent elle sera statique pour éviter d'avoir une déclaration par instance de la classe englobante.

---

Une classe interne permet d'avoir des relations privilégié avec la classe parente, comme l'accès aux attributs et méthodes private, ce qui peut être intéressant...

Mais dans tous les cas il n'y a pas de déclaration multiple...

Citation:

---

Envoyé par manblaizo

Code:

---

MyLNReader2.LineCounter lc = new MyLNReader2().new LineCounter("abc");

---

---

Argh cette syntaxe est vraiment affreuse :aie:

Franchement c'est à éviter : si tu te retrouves à faire des choses comme cela c'est que ta classe interne ne devrait pas avoir de liens aussi fort avec la classe parente... bref il faudrait qu'elle soit static !

a++

Citation:

---

Envoyé par adiGuba

Argh cette syntaxe est vraiment affreuse :aie:

Franchement c'est à éviter : si tu te retrouves à faire des choses comme cela c'est que ta classe interne ne devrait pas avoir de liens aussi fort avec la classe parente... bref il faudrait qu'elle soit static !

---

Je ne suis pas d'accord. La relation privilégiée de la classe interne avec sa classe englobante c'est justement qu'elle peut accéder à toutes les variables et méthodes d'instance de la classe parente (même celles qui sont private). Alors quelle que soit la syntaxe utilisée pour en obtenir une instance, elle ne perd pas son lien avec l'instance de la classe englobante. Et la déclarer static ne serait pas une meilleure chose, car dans ce cas il n'y a plus de relation avec la classe englobante, sauf simplement dans la façon de nommer la classe en précédant son nom par celui de la classe englobante. Un peu comme si on la mettait dans un autre package. D'ailleurs une classe interne static n'est pas une vraie classe interne, au sens de lien privilégié avec une instance de la classe parente.
Bref, il n'y a rien d'affreux dans cette syntaxe et on peut la retrouver souvent dans du code bien conçu.

Merci de m'avoir repris adiGuba.

C'est vrai que j'utilise pas beaucoup les classes internes; mise à part quelques classes anonymes pour implémenter rapidement des interfaces.

Je vais essayer de me mieux comprendre les différents concepts des classes internes avant de répondre à post :oops:.

A+
Gronono

Citation:

---

Envoyé par manblaizo

Et la déclarer static ne serait pas une meilleure chose, car dans ce cas il n'y a plus de relation avec la classe englobante, sauf simplement dans la façon de nommer la classe en précédant son nom par celui de la classe englobante. Un peu comme si on la mettait dans un autre package.

---

Une classe interne static conserve la même visibilité qu'une classe interne non-static. La seule différence étant qu'on n'est pas lié à une instance précise.

Citation:

---

Envoyé par manblaizo

Bref, il n'y a rien d'affreux dans cette syntaxe et on peut la retrouver souvent dans du code bien conçu.

---

Cela m'a toujours fait mal aux yeux quand je vois ca... j'ai du mal à comprendre l'intérêt de faire cela : si la classe interne est lié à une instance de la classe parente, je préfère que ce soit cette dernière qui l'instancie ce qui évite tout ceci ;)

a++

J'aurais raté quelque chose sur les classes internes ?
A ma connaissance, une classe ne peut pas être static, c'est pour les méthodes, propriétés et initialisateurs (il y a autre chose ?)
La différence fondamentale étant que ces "éléments" sont liés à la classe et non aux instances...

Citation:

---

Envoyé par adiGuba

Une classe interne static conserve la même visibilité qu'une classe interne non-static. La seule différence étant qu'on n'est pas lié à une instance précise.

---

Ben non justement, une classe interne static n'a pas la même visibilité qu'une classe interne non-static concernant les variables et méthodes membres de la classe englobante. La classe interne static n'a accès qu'au variables et méthodes static de la classe englobante, et dans ce cas elle n'a pas plus de visibilité qu'une autre classe non interne, donc pas véritablement de lien privilégié avec la classe parente.

Citation:

---

Envoyé par OButterlin

J'aurais raté quelque chose sur les classes internes ?
A ma connaissance, une classe ne peut pas être static, c'est pour les méthodes, propriétés et initialisateurs (il y a autre chose ?)

---

Les classes (et tous les types en général) peuvent être static lorsqu'ils sont déclaré à l'intérieur d'une autre classes


Je viens de jeter un coup d'oeil dans les specs : http://java.sun.com/docs/books/jls/t...l/classes.html

Et on y trouve trois grand types de classes :

• Les "top level class", c'est à dire les classes de base (qui ne sont à l'intérieur d'aucune autre).
• Les "Inner class", qui sont déclaré à l'intérieur d'une autre classe et lié à une instance particulière de cette dernière.
• Les "Nested class", qui sont déclarée à l'intérieur d'une autre classe sans être lié à une instance. Elles sont explicitement ou implicitement déclaré static

Pour info, lorsqu'ils sont déclarés dans une classe, les interfaces/enum/annotation sont implicitement static :

Code:

---

1 2 3 4 5 6 7

class Parent { public class InnerClass {} public static class NestedClass {} public interface Interface {} public enum Enumeration {} public @interface Annotation {} }

---

On peut le vérifier avec ce code :

Code:

---

1 2 3

for (Class c : Parent.class.getDeclaredClasses()) { System.out.println(c + " : " + Modifier.isStatic(c.getModifiers()) ); }

---

Ce qui donne :

Code:

---

1 2 3 4 5

class Parent$InnerClass : false class Parent$NestedClass : true interface Parent$Interface : true class Parent$Enumeration : true interface Parent$Annotation : true

---

a++

Citation:

---

Envoyé par manblaizo

Ben non justement, une classe interne static n'a pas la même visibilité qu'une classe interne non-static concernant les variables et méthodes membres de la classe englobante. La classe interne static n'a accès qu'au variables et méthodes static de la classe englobante, et dans ce cas elle n'a pas plus de visibilité qu'une autre classe non interne, donc pas véritablement de lien privilégié avec la classe parente.

---

Non les classes statics ont bien accès à tous les champs et méthodes de la classes parente. Comme je l'ai dit la seule différence est qu'on n'est pas lié à une instance de la classe parente, instance que l'on accède explicitement via Parent.this :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class Parent { private int value;   public class Inner { public void method() { // On accède à la référence de l'instance lié : Parent p = Parent.this;   // On récupère la valeur de l'attribut de l'instance lié : int v1 = value; // Ce qui est strictement égal à : int v2 = Parent.this.value; } } }

---

Tout ceci n'est pas possible dans une classe interne static car les instances ne sont pas lié (et donc on n'a pas accès à Parent.this). Par contre elles conservent les mêmes règles de visibilités sur les autres instances de la classe. On peut prendre en exemple les Comparator :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class MyObject {   private int value;     public static class NestedComparator implements Comparator<MyObject> { public int compare(MyObject o1, MyObject o2) { if (o1.value==o2.value) { return 0; } return (o1.value<o2.value) ? -1 : 1; } }   }

---

:arrow: On accède bien aux attributs privé de la classe parente...

a++

OK, tu as raison adiGuba, vu sous cet angle la classe interne static (ou nested class) conserve donc quand même certains privilèges vis-à-vis de sa classe parente. Par contre, ce qu'elle ne peut pas faire c'est d'accéder directement à la variable non-static, en faisant par exemple :

Code:

---

1 2 3 4 5 6 7 8 9

public int compare(MyObject o1, MyObject o2) { int tempVar = value; if (o1.value==o2.value) { return 0; } return (o1.value<o2.value) ? -1 : 1; }

---

Mais bien entendu, ceci est valable aussi pour les méthodes static et tout autre bloc static de la classe, comme on le sait...
a++

Citation:

---

Envoyé par adiGuba

Les classes (et tous les types en général) peuvent être static lorsqu'ils sont déclaré à l'intérieur d'une autre classes


Je viens de jeter un coup d'oeil dans les specs : http://java.sun.com/docs/books/jls/t...l/classes.html

---

Merci pour le lien, très intéressant...
A+

Citation:

---

Envoyé par adiGuba

Code:

---

MyLNReader2.LineCounter lc = new MyLNReader2().new LineCounter("abc");

---

Argh cette syntaxe est vraiment affreuse :aie:

Franchement c'est à éviter : si tu te retrouves à faire des choses comme cela c'est que ta classe interne ne devrait pas avoir de liens aussi fort avec la classe parente... bref il faudrait qu'elle soit static !

a++

---

Affreuse ou pas affreuse, je ne sais plus quoi penser. Mais, moi je trouve cette syntaxe plus compréhensible. J'ai compris ce qui me manquait.

MERCI A TOUS.
:merci: