Discussion :

[Faiche]

Bonjour,

Je dois parser différents fichier de plusieurs millier de lignes chacun.

La méthode de parsing est la même qque soit le fichier, mais l'action a effectuer change.

Instinctivement, j'ai envie d'éviter de mettre dans le while un switch pour effectuer l'action suivant la donnée, histoire d'éviter 3 millions de tests.

En C++, il suffirait de passer une fonction en paramètre et de l'appliquer à la ligne.

En Java, comme le pointeur de fonction c'était trop simple, il faut créer une interface et une classe par type de fichier juste pour une pauvre fonction de deux lignes.

Donc mettons que c'est un gros projet java avec deja des tonnes de classes dans tous les sens, et que ça me dis rien d'en créer 20 autres pour deux lignes chacune, est ce qu'il n'y aurait pas un moyen plus clair et plus élégant pour résoudre mon probleme ?


voila ma fonction (pour info)

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
48
49
50
51
 
	public static String parseRequest(Node data, String info) throws Exception
	{
		// DECS
		int nb = 0;
		int pos = 0;
		byte[] temp = null;
		String[] tab = null;
		String line = null;
		String header = null;		
		StringReader sr = null;
		BufferedReader br = null;
 
		String err = "";
 
		sr = new StringReader(data.getTextContent());
		br = new BufferedReader(sr);
 
		header = br.readLine();
 
		pos = header.lastIndexOf(":");
 
		info = header.substring(0, pos);
 
		nb = Integer.parseInt(header.substring(pos + 1, header.length()));
 
		while ( (line = br.readLine()) != null && nb > 0)
		{
			nb--;
			tab = line.trim().split("\t");
 
			try
			{
			    // ACTION A EFFECTUER
			}
			catch (Exception e)
			{
				err += line + "\n";
			}
		}
 
		if (nb > 0)
			err += "Missing lines !\n";
		else if (!br.readLine().equals(header))
			err += "wtf #@!?\n";
 
		br.close();
		sr.close();
 
		return err;
	}

Merci d'avance, j'arrive pas à me faire à java encore.

[santati]

Bonjour, votre action change par rapport à quoi. je vois que vous passer deux elmts en paramettre mais tu n'a pas dit sur quelle variable tu veux te baser pour faire les différentes action.

[adiGuba]

Salut,


Tu es bien obligé de passer par une interface... (peut-être que Java 7 incluera des closures pour remédier à cela).

Mais tu n'est pas obligé de déclaré toutes ces classes dans un fichier indépendant. Tu peux utiliser les classes anonymes lors de l'appel de la méthode :

Code :

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

1
2
3
4
5
	parseRequest(data, info, new MonInterface() {
		public void doSomething() {
			// CODE ICI
		}
	});

Tu peux aussi utiliser une classe conteneur qui contiendra les principales implémentations de l'interface. A la rigueur tu pourrais même utiliser l'interface pour cela, par 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
public interface MonInterface {
 
	public void doSomething();
 
 
	/*
	 * 
	 * Les principales classes qui implémentent cette interface :  
	 * 
	 */
 
 
	public static class MaClass1 implements MonInterface {
		public void doSomething() {
			// CODE ICI
		}
	}
 
	public static class MaClass2 implements MonInterface {
		public void doSomething() {
			// CODE ICI
		}
	}
 
	...
}

a++

[BugFactory]

cf classe Method.

[Faiche]

Code :

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

1
2
3
4
5
6
 
parseRequest(data, info, new MonInterface() {
		public void doSomething() {
			// CODE ICI
		}
	});

ça c'est quand meme ultra porc.

D'ailleurs c'est tout de meme hallucinant que java ne permette pas de redéfinition d'opérateur pour cause de "plus difficile à lire et à comprendre" (cf FAQ), mais qu'on puisse déclarer des classes dans les paramètres.

L'interface me semble correspondre le plus à ce que je recherche. Par contre, il y a plein de concepts que je maitrise pas la : les classes statiques, la déclaration de classe dans l'interface, et comment on appelle tout ça du coup.

Dans cet exemple je devrais appeller parseRequest(data, info, MonInterface.Maclass1)
et dans le code de la fonction faire MonInterface.doSomething(), c'est ça ?

[adiGuba]

Code :

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

1
2
3
4
5
6
 
parseRequest(data, info, new MonInterface() {
		public void doSomething() {
			// CODE ICI
		}
	});

ça c'est quand meme ultra porc.

Ce n'est pas très clair à lire je te l'accorde mais il n'y a rien de bien méchant là dedans...

D'ailleurs c'est tout de meme hallucinant que java ne permette pas de redéfinition d'opérateur pour cause de "plus difficile à lire et à comprendre" (cf FAQ), mais qu'on puisse déclarer des classes dans les paramètres.

Cela dépend de ce que tu entends pas "plus difficile à lire et à comprendre" !
Les classes anonymes sont très verbeuses et lourdes mais tu possèdes bien toutes les informations nécessaires (création d'une classe de type XXXX en implémentant les méthodes YYY...).

Par contre lorsque tu tombes sur quelque chose du style :

Code :

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

c = a + b;

Et que le langage autorise la surcharge d'opérateur tu ne peux pas dire ce qui se passe exactement sans analyser les différentes surcharges des différents types...


La surcharge des opérateurs est principalement utile pour les types numériques... Pour le reste il y a très peu de cas où c'est vraiment utile (à part pour les opérateur << et >> du C++).

L'interface me semble correspondre le plus à ce que je recherche. Par contre, il y a plein de concepts que je maitrise pas la : les classes statiques, la déclaration de classe dans l'interface, et comment on appelle tout ça du coup.

Lorsque tu déclares une classes dans une autre classe, tu as deux choix :

• Si la classe n'est pas static, elle sera automatiquement lié à une instance de la classe conteneur, et pourra donc manipuler directement ses attributs. Mais du coup on a besoin d'une instance de la classe conteneur pour créer la classe contenu...
• Si la classe est static, elle n'est pas lié à une instance de la classe conteneur et peut donc être instancié directement. Par contre elle conserve des privilèges d'accès aux champs et méthodes private). Bref c'est une classe normale sauf qu'elle est déclaré à l'intérieur d'une autre...

Dans le cas d'une interface les classes internes sont implicitement static...

Dans cet exemple je devrais appeller parseRequest(data, info, MonInterface.Maclass1)

Tu dois créer une instance, donc :

Code :

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

parseRequest(data, info, new MonInterface.Maclass1());

et dans le code de la fonction faire MonInterface.doSomething(), c'est ça ?

Tu dois utiliser le nom du paramètre que tu as utilisé :

Code :

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

1
2
3
4
5
6
public static String parseRequest(Node data, String info, MonInterface action) throws Exception
{
...
    action.doSomething();
...
}

a++

[Sanguko]

ça c'est quand meme ultra porc.

Le fait de pouvoir mettre une fonction en parametres, c'est du C. Pouvoir/Devoir passer un objet, meme avec une classe construit à la volée, ca permet de faire toutes les verifications de type à la compilation.
L'utilisation de cette technique est courante.

D'ailleurs c'est tout de meme hallucinant que java ne permette pas de redéfinition d'opérateur pour cause de "plus difficile à lire et à comprendre" (cf FAQ), mais qu'on puisse déclarer des classes dans les paramètres.

Dans tous les projets en C++ que j'ai fait, il y avait toujours des règles de codage pour eviter les ennuis dus à la surcharge (ou à l'absence de surchage) des operateurs. S'il faut repréciser des règles, c'est qu'a priori il y a quelque chose de pourri au départ.

L'interface me semble correspondre le plus à ce que je recherche. Par contre, il y a plein de concepts que je maitrise pas la : les classes statiques, la déclaration de classe dans l'interface, et comment on appelle tout ça du coup.

Dans cet exemple je devrais appeller parseRequest(data, info, MonInterface.Maclass1)
et dans le code de la fonction faire MonInterface.doSomething(), c'est ça ?

c'est plutot :

Code :

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

parseRequest(data, info, new MonInterface.Maclass1());

et dans le code de la methode

Code :

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

1
2
3
4
5
6
 
parseRequest(Node data, String info  MonInterface action) {
   ...
    action.doSomething();
    ...
}

[EDIT]Grilled![/EDIT]

[Faiche]

Le fait de pouvoir mettre une fonction en parametres, c'est du C. Pouvoir/Devoir passer un objet, meme avec une classe construit à la volée, ca permet de faire toutes les verifications de type à la compilation.
L'utilisation de cette technique est courante.

Ce que je voulais dire c'est qu'autant ça parait logique qu'on puisse le faire, autant ça parait logique de pas le faire.

Et puis l'idée du java, c'est de faire un langage dans lequel on évite les dérives, en tout cas c'est la raison pour laquelle il n'y a pas cette redéfinition d'opérateurs.

Enfin bon. Merci beaucoup pour les explications : l'interface utilisée comme ça va me rendre la tache plus aisée.

Pendant que je vous tiens, c'est quoi la raison officielle pour laquelle il n'y a pas d'unsigned en java ?

[Sanguko]

Pendant que je vous tiens, c'est quoi la raison officielle pour laquelle il n'y a pas d'unsigned en java ?

Si mes souvenirs sont bons, il me semble que c'est par souci de simplification.

Le principe, c'est que unsigned permet surtout de gérer des nombres positifs plus grands.
Le problème, c'est que cela fait partie des chose en C souvent mal comprises par les développeurs (notamment le bit de signe, et sa propagation lorsqu'on fait du décalage de bits) et piegeuses.

Pour un développeur java, qui souhaiterait manipuler des nombres qui tiennent dans un unsigned int, mais pas dans un int, il doit alors passer à des long. De maniere general, on doit passer au type primitif de capacité supérieure.

[herve91]

On peut même prévoir des instances déjà toutes faites dans MonInterface :

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 interface Action {
 
	public void doSomething(String line);
 
	action1 = new Action() {
		public void doSomething(String line) {
			// CODE ICI
		}
	};
 
	action2 = new Action() {
		public void doSomething(String line) {
			// CODE ICI
		}
	};
 
	...
}
 
 
parseRequest(data, info, Action.action1);
 
parseRequest(Node data, String info, Action action) {
   ...
    action.doSomething(line);
    ...
}