Discussion :

[mesken]

Je comprend bien que :
1) Un objet private n'est qu'accessible à l'intérieur de la classe qui le contient
2) Un objet protected est accessible dans tout le package et dans les sous classes
3) Un object Public est bien sûr visible partout.
4) Je sais qu'un membre static appartient à la classe et non a l'instance de la classe par exemple

public class Animal {

int age;
boolean vivant;
static nbreDePate=4;
protected boolean queue=true;

}

Voici ma préocupation :

Par rapport à l'accessibilité quelle est la différence réelle entre un objet static (nbreDePate), un objet protected (queue) et un objet qui n'a pas de modificateur tel que (age), parce que tous sont accessibles dans tout le package, selon moi, ils ont presque le même rôle.

Merci

[SucreGlace]

Attention à ne pas faire de confusion entre le mot-clé static et les modificateurs d'accès.


Un membre d'une classe peut être :

• lié à la classe => static
• lié à l'instance => pas de mot clé

Un membre d'une classe peut également être :

• visible par la classe uniquement => private
• visible par tout le package => pas de mot-clé
• visible par tout le package, et par les sous-classes dans le cadre de l'héritage (*) => protected
• visible par tout le monde => public

(*) "dans le cadre de l'héritage" = une sous-classe peut accéder à un membre protected qu'elle a hérité d'une classe mère, mais elle ne peut pas accéder à un membre protected hérité par une autre sous-classe ; voir suite de la discussion


Les deux notions peuvent être combinées comme on veut:

• int a => lié à l'instance, visible par tout le package
• static int b => lié à la classe, visible par tout le package
• private int c => lié à l'instance, visible par la classe uniquement
• private static int d => lié à la classe, visible par la classe uniquement
• protected int e => lié à l'instance, visible par tout le package et par les sous-classes
• protected static int f => lié à la classe, visible par tout le package et par les sous-classes
• public int a => lié à l'instance, visible par tout le monde
• public static int g => lié à la classe, visible par tout le monde

[Hizin]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int age;

Pas de modificateur, donc visibilité package.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

boolean vivant;

Bis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static nbreDePate=4;

Ter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

protected boolean queue=true;

Protected, donc visibilité pour uniquement cette classe et ses filles éventuelles.

[michon]

Voici un petit exemple qui j'éspère, t'aidera à mieux voir le rôle du "Static".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
static int nombreStatic = 10
int nombre = 10
 
//Considérons une classe A qui possède une méthode Add() de la sorte :
 
void Add(){
    nombreStatic++;
    nombre++;
}
 
//et une méthode print :
 
void print(){
    System.out.println("valeur de nombreStatic : "+nombreStatic+"<<>> valeur de nombre : "+nombre);
}
 
A1 = new A();
A2 = new A();
 
//ici nombreStatic = nombre = 10
 
A1.add();
A2.add();
 
A1.print();
A2.print();

le résultats sera :

valeur de nombreStatic : 11 <<>> valeur de nombre : 11
valeur de nombreStatic : 12 <<>> valeur de nombre : 11

j'éspère que c'est assez clair...

[thelvin]

@michon: Euh, c'est ni juste ni clair, ton exemple.

Je pense que pour l'instant, il faut comprendre que
- private, protected et public sont des modificateurs d'accès, mutuellement incompatibles.
- static n'est pas un modificateur d'accès, il n'est incompatible avec rien. Son seul contraire, "pas static" consiste à ne pas dire que c'est static.

[Alkhan]

-1 michon !
c'est pas en donnant un exemple qui compile pas bien et un résultat qui n'est pas bon que tu va aider mesken à comprendre !

Avec ton code le résultat sera :

valeur de nombreStatic : 12 <<>> valeur de nombre : 11
valeur de nombreStatic : 12 <<>> valeur de nombre : 11

pour que ca marche, il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
....
A1 = new A();
A2 = new A();
 
A1.add();
A1.print();
A2.add();
A2.print();
....

[professeur shadoko]

pour protected voir détail : http://www.developpez.net/forums/d10...jet-protected/
on y verra qu'il n'est pas tout à fait exact que protected soit visible par les sous-classes .....

[thelvin]

on y verra qu'il n'est pas tout à fait exact que protected soit visible par les sous-classes .....

Si... Mais pas que.
Personne n'a dit une chose pareille ici, d'ailleurs.

[michon]

-1 michon !

oups exacte... tu as raison, j'ai validé trop vite mon message, j'ai mérité d'être puni

Je cherchais à bien montrer que la variable static n'est pas lié aux instances, en pensant que ce serai plus clair avec cette exemple... sorry

[professeur shadoko]

Si... Mais pas que.
Personne n'a dit une chose pareille ici, d'ailleurs.

euh..... aurais je mal lu ....

visible par tout le package et par les sous-classes (même si elle ne sont pas dans le même package) => protected

ceci n'est pas tout à fait vrai puisqu'on peut dans une sous-classe ne pas pouvoir accéder à un élément protected de la super classe .... (voir l'exemple dans le post cité)
(ceci dit la légende est tenace et je ne suis même pas arrivé à faire corriger la question dans SCJP )

[thelvin]

Hé, mais c'est que tu avais bien raison, j'avoue.

Ce que tu voulais dire, c'est que protected ne donne la visibilité aux sous-classes que sur this, et ne la leur donne pas sur les autres variables du type hérité.
Au fond, c'est logique, mais effectivement je ne savais pas.

Elle est pas facile à montrer, cette différence.

[adiGuba]

Pour être plus précis il faudrait distinguer l'héritage des méthodes et la visibilité :

En ce qui concerne l'héritage des méthodes :

• Une méthode private n'est jamais hérité.
• Une méthode "package" ne peut être héritée que par une sous-classe du même package.
• Les méthodes protected et public sont héritées par toutes les sous-classes.

Les règles de visibilité sont un peu plus complexe et concernent tous les éléments (méthodes, constructeurs, champs et type interne).
On distingue plusieurs cas selon le type d'origine du code appelant et le type déclaré de l’appelé :

Le type appelant correspond à la classe qui contient le code.
Le type appelé correspond à la classe qui contient l'élément qu'on veut manipuler.

Par exemple si on prend ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public class A {
	public void exemple(B b) {
		b.method(); // ICI
	}
}

Le type appelant est "A", et le type appelé est "B".

Ainsi :

• Si le type appelant est identique au type appelé, on peut accéder à tous ses éléments y compris private.
• Si le type appelant est du même package que le type appelé, on peut accéder à tous les éléments sauf ceux private (*).
• Si le type appelant provient d'un package différent, on ne peut accéder qu'aux éléments public.
  Toutefois si le type appelant correspond à un type parent, on peut également appeler toutes les méthodes "package"/protected qui ont été héritées de l’appelant.

(*) : Il y a juste une "exception" à cette règle : une classe interne peut également accéder aux éléments private de sa classe conteneur, mais en réalité le compilateur "triche" car il génèrera une méthode d'accès en visibilité "package"

a++

[SucreGlace]

J'ai mis un peu de temps à comprendre de quoi vous parliez exactement...
Du coup, maintenant que j'ai trouvé un exemple illustrant la discussion, il faut que je le partage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package package1;
 
public class Mom
{
	protected static int count = 0;
	protected int id;
 
	public Mom()
	{
		this.id = ++this.count;
	}
 
	public String toString()
	{
		return "M[count="+this.count+";id="+this.id+"]";
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package package2;
 
import package1.Mom;
 
public class Son extends Mom
{	
	public String toString()
	{
		return "S[count="+this.count+";id="+this.id+"]";
	}
 
	public String test()
	{
		Son other = new Son();
 
		// other.id est visible car id est protected dans la classe Mom, et nous sommes dans le cadre de l'héritage
		// (Son hérite de Mom et a accès au membre id de la classe Son, même si nous agissons sur une autre instance que l'instance courante)
		return "O[count="+other.count+";id="+other.id+"]";
	}
 
	protected int getId()
	{
		return id;
	}
}
 
public class Daughter extends Mom
{
	public String toString()
	{
		return "D[count="+this.count+";id="+this.id+"]";
	}
 
	public String test()
	{
		Son other = new Son();
 
		// other.id n'est pas visible car id est protected dans la classe Mom, or nous sommes dans un autre package et hors du cadre de l'héritage
 		// (Daughter hérite de Mom et a accès au membre id de la classe Daughter, mais pas à celui de la classe Son)
		// return "O[count="+other.count+";id="+other.id+"]";
 
		// other.getId() est visible car getId() est protected dans la classe Son, et nous sommes dans le même package
		// other.count est visible, au contraire de other.id, parce qu'il s'agit en fait du membre statique de la classe Mom
		// j'aurais du en tout rigueur écrire Mom.count (le compilateur émet un warning mais accepte cette syntaxe)
		return "O[count="+other.count+";id="+other.getId()+"]";
	}
}

[mesken]

Merci beaucoup pour vos explications, c'est clair et je comprends