Discussion :

[SirDarken]

Voila j'ai recherché a droite et a gauche sur ce sujets , et je susi tombé que sur des truc en anglais.
Problèmes je parle pas anglais , donc j'aurai besoin qu'on m'explique comment cela fonctionne , une espece de tutorial en francais trés detaillé.

Je doit coder un class Directeur , qui ne doit crée , que un seul Directeur , et si il en existe deja un , envoyé un message juste.
J'avais pensé avant d'entendre le mot singleton , de faire une variable static , que si egal a 1 le Directeur n'etait pas crée , mais j'ai pas trouvé , comment faire pour que l'isntancation ne ce fasse pas.

[sylvain_2020]

Bonjour,
Tu aurais pu trouver ton bonheur en faisant un tour du cote des cours et tutoriels pour apprendre Java : http://java.developpez.com/cours/
Par exemple : http://smeric.developpez.com/java/uml/singleton/


sylvain_2020

Problèmes je parle pas anglais

en effet, c'est un probleme ... mais il y a des moyens d'y remedier. Ca me parait indispensable pour pouvoir evoluer dans l'informatique ....

[erefer]

Voila j'ai recherché a droite et a gauche sur ce sujets , et je susi tombé que sur des truc en anglais.
Problèmes je parle pas anglais , donc j'aurai besoin qu'on m'explique comment cela fonctionne , une espece de tutorial en francais trés detaillé.

Je doit coder un class Directeur , qui ne doit crée , que un seul Directeur , et si il en existe deja un , envoyé un message juste.
J'avais pensé avant d'entendre le mot singleton , de faire une variable static , que si egal a 1 le Directeur n'etait pas crée , mais j'ai pas trouvé , comment faire pour que l'isntancation ne ce fasse pas.

Le plus simple, en reprenant le principe du singleton:

- créer un constructeur privé
- implémenter une methode factory static

ex:

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
 
class Directeur {
 
   private static Directeur dInstance = null;
 
   private Directeur() {
   }
 
    public static Directeur createInstance() throws CreateException {
        if (dInstance != null) {
            throw new CreateException("directeur déjà créé");
        }
         dInstance = new Directeur();
 
         return dInstance;
    }
 
}

Evidement, dans le cas du singleton classique, on ne lance pas une exception mais on retourne dInstance:

Code :

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

1
2
3
4
5
6
7
8
 
    public static Directeur createInstance() {
        if (dInstance == null) {
            dInstance = new Directeur();
        }
 
         return dInstance;
    }

[jIdJo]

As tu tapé Singleton dans le champ d'édition qui se trouve sous le logo developpez.com ??????

Tu aurais trouvé un article de sébastien méric sur ce pattern (et d'autres pattern)

[SirDarken]

Non j'ai pas taper sa sous le logo , j'avais une recherche avancée sur le forum.
En tout merci du tuto en fr , mais j'ai un petit souci

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
 
public class directeur{
	private static directeur dInstance = null; 
	String nom;
 
	private directeur(String nom) { 
		this.nom = nom;
	} 
 
	public static directeur getInstance(String nom) { 
		if (dInstance == null) { 
			dInstance = new directeur(nom); 
		} 
		return dInstance; 
	}
 
	public String toString(){
		return nom;
	}
 
}

Mon directeur et voici la class qui l'appel

Code :

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

1
2
3
4
5
6
7
8
9
 
public class Paie{
	public static void main(String[] args){
		directeur d1 = new directeur("Gerard");
		directeur d2 = new directeur("Roger");
		System.out.println(d1);
		System.out.println(d2);
	}
}

Quand je l'appel comme cela , il me dit que la classe est private , la je voie pourquoi , et si je fait la même chose dans ma class directeur , il me crée les 2 directeur et me les affiche.
pincer moi si il faut mais la je comprend pas.

[laffreuxthomas]

Code :

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

1
2
3
4
5
6
7
8
public class Paie{
   public static void main(String[] args){
      directeur d1 = directeur.getInstance("Gerard");
      directeur d2 = directeur.getInstance("Roger");
      System.out.println(d1);
      System.out.println(d2);
   }
}

[divxdede]

il y a un probleme de design dans l'exemple,

Code :

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

directeur d2 = directeur.getInstance("Roger");

renverra d1 soit "Gerard"


De plus il est preferable d'initialiser l'instance statique par le mode passif

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
public class directeur{ 
   private static directeur dInstance = createInstance();
   String nom; 
 
   private directeur(String nom) { 
      this.nom = nom; 
   } 
 
   public static directeur getInstance()
   {  return dinstance; }
 
   private directeur createInstance()
   {  /* do your init stuff */
       return new directeur("Gerard");
   }
 
   public String toString(){ 
      return nom; 
   } 
 
}

[ATH]

il est preferable d'initialiser l'instance statique par le mode passif

Ce n'est pas aussi systématique.
Tout dépend de l'utilisation qui est faite du singleton.
Si tu n'as qu'un singleton et que tu récupères 10 000 fois son instance alors ta méthode est meilleur.
Maintenant si tu as 10 000 singletons que tu n'appels que de temps en temps, tu as interet à utiliser la programmation lazy ...

De manière général une instanciation d'objet étant très couteuse en Java, je préfère le style :

Code :

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

1
2
3
4
5
6
   public static Directeur getInstance() {
      if (dInstance == null) {
         dInstance = new directeur();
      }
      return dInstance;
   }

Bon maintenant retour sur la question.
Si le but est de n'avoir qu'un directeur unique dans toute l'application alors il faut utiliser le singleton qui a été donné par "erefer".

Mais d'après ce que tu as écrit :

Code :

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

1
2
      directeur d1 = new directeur("Gerard");
      directeur d2 = new directeur("Roger");

tu ne cherches pas à avoir un seul directeur unique, mais plusieurs directeurs, avec une instance unique de directeur par nom.
Tu dois donc te tourner vers le design pattern flyweight.
Je te laisse rechercher des informations sur le sujet, mais je te propose une implémentation simple pour t'aider.

Code :

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

1
2
3
public interface Director {
      //  L'interface de ton directeur
}

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
public class DirectorFactory {
 
    private static Map directorMap = new HashMap();
 
    private static class DirectorImpl implements Director {
        private String name;
 
        private DirectorImpl(String n) {
            name = n;
        }
 
        public String toString() {
            return name;
        }
    }
 
    public static Director getDirector(String name) {
        Director d = (Director) directorMap.get(name);
        if (d == null) {
            d = new DirectorImpl(name);
            directorMap.put(name, d);
        }
        return d;
    }
}

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String[] args) {
        Director d1 = DirectorFactory.getDirector("Gerard");
        Director d2 = DirectorFactory.getDirector("Roger");
        Director d3 = DirectorFactory.getDirector("Gerard");
 
        assert (d1 == d3 && d1 != d2) : "DirectoryFactory problem";
        System.out.println(d1 + ", " + d2 + ", " + d3);
    }
}

@+

[divxdede]

Sauf que ta méthode est "imparfaite" dans un environnement multi-thread a cause du model de données JAVA
tu peut avoir un thread qui execute le test dInstance == null,
execute le alors, commence l'execution du ctor(), c'est a dire l'allocation memoire. Et imagine que ce thread est interrompu. un deuxieme thread prends le relai, appel le getInstance() et le test == null echoue. et retourne un objet non completement initialisé.

Pire encore, le 1er thread est interrompu juste apres le test == null sans avoir encore eu le temps de passer dans le ctor();
le deuxieme, demande une instance et le test == null se verifie, il creer une instance de ton singleton, une fois que le 1er thread reprends, il va également creer une instance du singleton. Ce n'est donc plus un singleton.

Dans l'absolu, cette méthode dans un environnement multi-thread n'est absolument pas fiable.

Tu peu lire le discours de SUN au sujet du "double checked guard" pattern pour mieux comprendre. Dés que je retrouve le lien, je le poste dans ce thread.

il est preferable d'initialiser l'instance statique par le mode passif

Ce n'est pas aussi systématique.
Tout dépend de l'utilisation qui est faite du singleton.
Si tu n'as qu'un singleton et que tu récupères 10 000 fois son instance alors ta méthode est meilleur.
Maintenant si tu as 10 000 singletons que tu n'appels que de temps en temps, tu as interet à utiliser la programmation lazy ...

De manière général une instanciation d'objet étant très couteuse en Java, je préfère le style :

Code :

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

1
2
3
4
5
6
   public static Directeur getInstance() {
      if (dInstance == null) {
         dInstance = new directeur();
      }
      return dInstance;
   }

@+

[ATH]

Tu as raison (même si il n'a jamais été fait état d'environnement multi thread dans ce post).
Cependant le design pattern du singleton tel qu'il est décrit par le GoF est lazy, et je voulais souligner l'intéret de cette instanciation lazy.

Par rapport à ta remarque,
un code propre pour de la synchronisation serait :

Code :

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

1
2
3
4
5
6
   public static synchronized Directeur getInstance() {
      if (dInstance == null) {
         dInstance = new directeur();
      }
      return dInstance;
   }

Mais la synchronisation nous fait "peut être" perdre l'interet de l'instanciation lazy.

le livre Effective Java (dont je recommande la lecture) propose le meilleur des deux mondes :

Code :

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

1
2
3
4
private static class FooHolder {
   static final Foo foo = new Foo();
}
public static Foo getFoo() { return FooHolder.foo; }

foo n'est crée que lors du 1er appel de la fonction getFoo, et l'utilisation de la synchronisation n'est pas nécessaire.
Mais nous nous éloignons dangeuresment de la question initiale :p

@++

[ATH]

oue en faite ce que je viens de écrire me fait penser que ce que je raconte c'est n'importe quoi depuis le début.
Le lazy ne sert a rien en java dans un singleton, ta méthode est la bonne.
toutes mes excuses

[christopheJ]

Sauf que ta méthode est "imparfaite" dans un environnement multi-thread a cause du model de données JAVA
tu peut avoir un thread qui execute le test dInstance == null,
execute le alors, commence l'execution du ctor(), c'est a dire l'allocation memoire. Et imagine que ce thread est interrompu. un deuxieme thread prends le relai, appel le getInstance() et le test == null echoue. et retourne un objet non completement initialisé.

Pire encore, le 1er thread est interrompu juste apres le test == null sans avoir encore eu le temps de passer dans le ctor();
le deuxieme, demande une instance et le test == null se verifie, il creer une instance de ton singleton, une fois que le 1er thread reprends, il va également creer une instance du singleton. Ce n'est donc plus un singleton.

Dans l'absolu, cette méthode dans un environnement multi-thread n'est absolument pas fiable.

Tu peu lire le discours de SUN au sujet du "double checked guard" pattern pour mieux comprendre. Dés que je retrouve le lien, je le poste dans ce thread.

Thibaut a donné les liens il y a pas longtemps...
http://www.developpez.net/forums/vie...light=#1491884

[SirDarken]

Euh la vous m'avez noyé ^^".
Donc pour reprendre un peu , je doit crée un seul directeur , et si je tente d'en crée un autre je doit avoir un message disant qu'un directeur est deja la.
J'en est instancié 2 pour tester cela , je pensez que c'etait cela l'exercice a faire , le titre de l'exo etant design pattern singleton.
Donc pour moi il me semblé logique d'instancié (crée ) 2 directeur pour tester.
Ou est plus compliqué que cela ?

[divxdede]

Une fàcon de montrer le singleton pattern est de recuperer ton instance unique dans differentes classes de ton programme.

exemple:

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
 
public class Directeur
{  
      private static final instance = initDirecteur();
      private String       nom      = null;
      private double      salaire   = null;
 
      private Directeur()
      { /* do nothing */ }
 
      public static Directeur getInstance()
      { return instance; }
 
      public String getNom()
      { return this.nom; }
 
      public double getSalaire()
      { return this.salaire; }
 
      public void setNom(String nom)
      { this.nom = nom; }
 
      public void setSalaire(double salaire)
      { this.salaire = salaire; }
 
      public String toString()
      { return "Directeur " + this.getNom() + " avec un salaire de " + this.getSalaire());
      }
 
 
      private static Directeur initDirecteur()
      {  Directeur result = new Directeur();
          result.setNom("Gerard");
          result.setSalaire(135000);
      }
}

et avec ce code pour la demonstration

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
public class TestSingleton()
{
       public TestSingleton()
       { Directeur directeur = Directeur.getInstance();
          System.out.println("1. > " + directeur);
 
          new TestSingleton2(); 
 
          System.out.println("4. > " + directeur);
          directeur.setNom("Patrick");
 
          System.out.println("5. > " + Directeur.getInstance());
       }
 
       public static void main ( String[] args )
       {  new TestSingleton(); }
}

Code :

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

1
2
3
4
5
6
7
8
9
public class TestSingleton2()
{
       public TestSingleton2()
       {   Directeur directeur = Directeur.getInstance();
            System.out.println("2. > " + directeur);
            directeur.setSalaire(365000);
            System.out.println("3. > " + directeur);
       }
}

tu auras

Code :

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

1
2
3
4
5
6
 
1. > Directeur Gerard avec un salaire de 135000.00
2. > Directeur Gerard avec un salaire de 135000.00
3. > Directeur Gerard avec un salaire de 365000.00
4. > Directeur Gerard avec un salaire de 365000.00
5. > Directeur Patrick avec un salaire de 365000.00

[SirDarken]

J'ai pas pu tester sa marche pas ce code :S

Code :

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

1
2
3
4
5
6
7
8
9
10
 
//TestSingleton2
public class TestSingleton2()
	public TestSingleton2(){   
		Directeur directeur = Directeur.getInstance(); 
		System.out.println("2. > " + directeur); 
		directeur.setSalaire(365000); 
		System.out.println("3. > " + directeur); 
	} 
}

Erreur

Code :

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

1
2
3
4
5
6
7
8
 
C:\ProgJava\Educatel\dev9\3\tmp2>javac TestSingleton2.java
TestSingleton2.java:1: '{' expected
public class TestSingleton2()
                           ^
1 error
 
C:\ProgJava\Educatel\dev9\3\tmp2>

Pareil pour le premier , et Directeur planter aussi lui je pense l'avoir bien repris , car il compile.
Je le copie quand même.

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
 
public class Directeur {  
	private static final Directeur instance = initDirecteur(); 
	private String       nom      = null; 
	private double      salaire; 
 
	private Directeur(){ 
		/* do nothing */
	} 
 
	public static Directeur getInstance(){ 
		return instance; 
	} 
 
	public String getNom() { 
		return this.nom; 
	} 
 
	public double getSalaire(){ 
		return this.salaire; 
	} 
 
	public void setNom(String nom){ 
		this.nom = nom; 
	} 
 
	public void setSalaire(double salaire){ 
		this.salaire = salaire; 
	} 
 
	public String toString(){ 
		return "Directeur " + this.getNom() + " avec un salaire de " + this.getSalaire(); 
	} 
 
 
	private static Directeur initDirecteur() {  
		Directeur result = new Directeur(); 
		result.setNom("Gerard"); 
		result.setSalaire(135000); 
		return result;
	} 
}

Donc voila , moi je veux jsute empecher que Directeur d2 = new Directeur(); si il en existe deja un.
Je sais suis un peu novice , mais je pensais pas que c'etait si hard.

[SirDarken]

Bon j'ai plancher un peu plus dessus , mais j'ai un souci encore , quand je crée plusieurs directeur , sa donne que le dernier crée , alors que je veux que si y'en as déja un , sa fait une erreur , ou affiche un message , mais conserve le premier ( je ferai une class remplacement)

Voici mes sources

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
 
public class directeur{
	private static directeur dInstance = null; 
	String nom;
	double salaire;
 
	private directeur() { 
	} 
 
	public static directeur getInstance() { 
		if (dInstance == null) { 
			dInstance = new directeur(); 
		} 
		return dInstance; 
	}
 
	public String toString(){
		return nom;
	}
	public void setNom(String nom){
		this.nom=nom;
	}
	public void setSalaire(double salaire){
		this.salaire=salaire;
	}
 
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public class Paie{
	public static void main(String[] args){
		directeur d1 = directeur.getInstance();
		directeur d2 = directeur.getInstance();
		d1.setNom("Gerard");
		d2.setNom("Jean-claude");
		System.out.println(d1);
		System.out.println(d2);
	}
}

Merci ^^

[laffreuxthomas]

Bah là il n'y en a bien qu'un de directeur, et tu lui changes de nom.

[SirDarken]

Ah ?
Mais y'as pas moyen d'empecher d2 d'exister ? , c'etait cela mon but.
Que si d1 existe d2 ne doit pas s'instancier ( même si les 2 sont les mêmes ).
Si je change en mettant un message d'erreur au lieu de retourner dInstance , cela fonctionnera ? ( pas de d2 ? ).

[jerome.petit]

eh bien là il n'y a déjà pas de deuxième Directeur de créé.
Le premier getInstance() créée le Directeur et le retourne (façon de parler )
Le deuxième getInstance() ne fait que renvoyer la même instance c'est à dire le même Directeur.
Donc pas besoin de message d'erreur, puisque getInstance() ne crée qu'un seul directeur et une seule fois !

C'est le principe même du pattern Singleton (qui veut dire, en maths, "ensemble contenant un unique élément" )

est-ce clair ?

[SirDarken]

Mais pourquoi d2 s'affiche alors ?
Si je comprend d2 = d1 = mon directeur.
Mais puis je ne pas crée d2 ?