Discussion :

[drcd]

Bonjour à tous
Je debute en java et j'ai l'habitude de programmer en C++ et il 'y a un truc que je voudrai faire en java mais je n'y arrive pas.
Enfait je voudrai creer une classe toto qui ne contiendrai que des methodes virtuels(donc une interface en java si j'ai bien compris) et une fonction factory qui me retourne une référence sur un objet dérivé de la classe toto.
En gros le code C++ donnerais ca:

Code :

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

1
2
3
4
5
6
7
8
9
 
class toto
{
public:
    virtual void fct1(void)=0;
    virtual void fct2(void)=0;
    virtual void fct3(void)=0;
    static toto* create(string chaine);//Fonction factory
}

La string chaine permet de dire à la fonction create quel type d'objet derivé de toto elle doit creer.

Ma classe toto en java donne:

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
 
public class toto 
{
	//-------------------------------------------
	//Ne pas utiliser le constructeur pour instancier
	//un element.
	public toto()
	{
	}
 
	//--------------------------------------------
	//Fonction factory 
	public static toto Creer(String e)
	{
		if(main.TypeDeSaisie(e)==Constante.TUTU)
		{
			return new Tutu(e);//Constructeur de la classe Tutu dérivé //de la classe toto
		}
		else
		{
			return new Tata(e);//Idem Tata dérive de toto
		}
	}
 
	//--------------------------------------------
 
 
	/*public static void main(String[] args) {
		// TODO Auto-generated method stub
 
	}*/
 
}

Donc voila.
Merci à tous.

[schniouf]

Salut,
Dans ton cas il ne faut pas créer une interface, mais plutôt une classe abstraite.
Une interface en Java correspond à une classe virtuelle pure en C++, donc tu ne peux pas définir de méthode à l'intérieur.
Par contre avec une classe déclarée abstraite (public abstract class Toto) tu peux déclarer à l'intérieur des méthodes qui sont soit abstraites ( public abstract void fct1() et qui doivent obligatoirement être redéfinies dans les classes filles, soit des méthodes qui ne le sont et que tu peux utiliser telles quelles (comme ta fonction créer).
Tu ne peux pas instancier de classe abstraire, c'est à dire tu ne peux pas faire de new Toto() (et c'est ce que tu cherches à faire, non ?).

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
public abstract class Toto 
{
 
    //-------------------------------------------
    // 
    public Toto()
    {
        super() ;
    }
 
 
    // Méthode abstraite à redéfinir dans Tutu et Tata
    public abstract void fct1() ;
 
 
 
    //--------------------------------------------
    //Fonction factory 
    public static toto Creer(String e)
    {
        if(main.TypeDeSaisie(e)==Constante.TUTU)
        {
            return new Tutu(e);//Constructeur de la classe Tutu dérivé //de la classe toto
        }
        else
        {
            return new Tata(e);//Idem Tata dérive de toto
        }
    }
 
}

[iohack]

Juste une remarque : ta fonction pouvant retourner différents types d'objets, elle devra avoir cette signature ( toute class héritant d'Object ) :

Code :

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

1
2
 
public static Object Creer(String e){

EDIT : apparemment, la coloration du code ne fonctionne plus

[Betatesteur]

EDIT : apparemment, la coloration du code ne fonctionne plus

si ( en tout cas chez moi su mon Laptop)
@+

[herve91]

Tu peux faire comme ceci :

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
public interface Toto {
    void fct1();
 
    class Factory {
      public static Toto create(String e) {
        if (Main.typeDeSaisie(e) == Constante.TUTU) {
	  return new Tutu(e);
        } else {
          return new Tata(e);
        }
      }
    }
}
 
public class Tata implements Toto {
    public void fct1() {
    }
}
 
... Toto toto = Toto.Factory.create(Constante.TUTU);

mais attention, dans ce cas, les classes Tata, Tutu et l'interface Toto sont étroitement liées.
En général, on prévoit une méthode factory interne lorsqu'il n'y a qu'un seul type d'instance à créer (non paramétrable) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface Toto {
    void fct1();
 
    class Factory {
      public static Toto newInstance() {
        return new Toto() {
          public void fct1() {
            ...
          }
        };
      }
    }
}

Sinon, il est préférable d'écrire une classe Factory indépendante :

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
public interface Toto {
    void fct1();
}
 
public abstract class TotoFactory {
      public static Toto create(String e) {
        if (Main.typeDeSaisie(e) == Constante.TUTU) {
	  return new Tutu(e);
        } else {
          return new Tata(e);
        }
      }
    }
}
 
... Toto toto = TotoFactory.create(Constante.TUTU);

[drcd]

Salut,

Tu ne peux pas instancier de classe abstraire, c'est à dire tu ne peux pas faire de new Toto() (et c'est ce que tu cherches à faire, non ?).

Non je sais que je peux pas instancier de classe abstraite d'ailleur j'ai mis un com au dessus de mon constructeur toto comme quoi il ne faut pas l'utiliser pour creer un objet.

Merci à tous pour vos réponses. C'est bon je vais pouvoir faire joujou