Discussion :

[zigmo]

Bonjour,

je veux déclarer un grand nombre de variables avec un type primitif donné, mais je veux pouvoir changer le type facilement. En C je ferais quelque chose comme ça :

Code :

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

1
2
3
4
#define mtype long
 
private mtype var1
private mtype var2

Pour changer le type il suffit de modifier le #define.
Comment faire la même chose en java où je n'ai pas vu d'équivalent au #define ?

[bpy1401]

Bonjour zigmo

en effet, le #define n'existe pas en java. Le java ne fait pas de compilation conditionnelle.

A ma connaissance, on ne peut pas le faire, et est ce que cela est vraiment utile, je n'en suis pas convaincu.

Bonne nuit

[thelvin]

On peut obtenir la même chose avec les types objets, avec un simple pattern factory, par contre.
Mais avec les types de base, c'est bien trop lourd, en effet.

Mais pour des types de base, je dois bien dire que je ne vois pas bien l'intérêt, moi non plus.

[adiGuba]

Salut,

Mais pour des types de base, je dois bien dire que je ne vois pas bien l'intérêt, moi non plus.

+1

Qu'essayes-tu de faire exactement ?

a++

[Drakiss]

est ce que cela est vraiment utile, je n'en suis pas convaincu.

C'est même le gros avantage de java d' avoir des variables bien typées.
Quand on récupère un int, on récupère un int, on est sur que ça va se transformer après en double (pas comme en php ou javascript ).

Et je vois dans aucun cas l'intérêt non plus, si ce n'est de s'embrouiller et paumer le type de base à un moment donné

Tiens, on en avait déjà parlé...

[fallo]

pour ton cas eventuellement passe par le templating

avec eventuellement les variable en protected pour faire ce que tu veux dans les classe en heritant.

Code :

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

1
2
3
4
5
6
7
8
9
public class Toto<mtype  extends Number>
{
protected mtype a;
 
public mtype getA()
{
return a;
}
}

--------------
avec eventuellement une definition statique de la casse correctement typée,
tu peux alors faire des cochoneries comme en c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class TotoLong extends Toto<Long>
{
public long totoMethod(long y)
{
  long x = y * a;
return x;
}
 
}
 
}

neanmoins c'est quand meme étrange d'avoir ce besoin en java

[zigmo]

C'est simplement qu'entre un proto et la version finale les spécifications changent et qu'il peut être nécessaire de changer pour un type offrant par exemple une plus grande résolution ou de meilleures performances.
Le #define en C/C++ est juste du traitement de texte effectué par le préprocesseur sur le code, et on peut lui trouver plein d'autres applications.

Je suis d'accord que ce n'est pas indispensable, c'est juste une facilité, et comme je débute en java je me demandais si on avait quelque chose de ressemblant.

En tous cas merci pour vos réponses et pour le temps que vous y avez consacré.

[Drakiss]

tu peux alors faire des cochoneries comme en c

Mouais la grande différence vient du fait que la poo et notamment java est fortement typée, et permet de construire des objets à la chaine, avec le principe de l'héritage et du polymorphisme, ça évite de se prendre la tête...
(oui je sais vous allez me dire que c'est faisable en c, et je vous répondrai que vous avez raison, mais java reste plus propre et plus rapide là-dessus).

[adiGuba]

pour ton cas eventuellement passe par le templating

Ce n'est pas des "Templates" mais des "Generics". Ce n'est pas exactement la même chose... (pour plus d'infos : Les Generics ne sont pas des Templates comme les autres !

Au passage cela ne permet pas de manipuler les types primitifs (contrairement à ton exemple).

C'est simplement qu'entre un proto et la version finale les spécifications changent et qu'il peut être nécessaire de changer pour un type offrant par exemple une plus grande résolution ou de meilleures performances.

Tu pourrais préciser ton besoin avec un exemple ?

Le #define en C/C++ est juste du traitement de texte effectué par le préprocesseur sur le code, et on peut lui trouver plein d'autres applications.

Les #define servent surtout à gérer du code portable... Java n'a pas de tel problème


a++

[zigmo]

Tu pourrais préciser ton besoin avec un exemple ?

Par exemple tu peux commencer un proto en utilisant des double pour être sûr de couvrir les besoins pas encore complètement spécifiés, puis, si les besoins en résolution le permettent, changer pour des float pour réduire les temps de calcul.

Mais ma question allait bien au-delà de cet exemple. Je fais toujours en sorte d'anticiper les éventuelles modifications et de les rendre faciles à implémenter.

[JoeChip]

Je fais toujours en sorte d'anticiper les éventuelles modifications et de les rendre faciles à implémenter.

Justement, dans ce domaine, la programmation orientée objet va bien plus loin que le C.

[thelvin]

Par exemple tu peux commencer un proto en utilisant des double pour être sûr de couvrir les besoins pas encore complètement spécifiés, puis, si les besoins en résolution le permettent, changer pour des float pour réduire les temps de calcul.

Mais ma question allait bien au-delà de cet exemple. Je fais toujours en sorte d'anticiper les éventuelles modifications et de les rendre faciles à implémenter.

En fait, c'est effectivement un exemple convainquant d'un besoin de ce genre, j'y ai en effet pensé, en cachette, quand tu as posé ta question. Je le sais pour avoir rencontré ce cas moi-même, et j'ai eu une fois à remplacer plein de double par des float. Beurk.

Mais, c'est bien le seul exemple que je puisse imaginer.
- Avec les autres types de bases :
-- ou bien il y en a un et un seul qui répond au besoin, changer ça c'est changer la nature du besoin.
-- ou bien la différence entre l'un et l'autre (int ou short, int ou long...) n'a pas vraiment d'importance et ce n'est pas la peine d'y passer plus de temps.

- Avec autre chose que les types de base, un pattern factory fait très bien l'affaire.

=> Seule la différence float/double, dans les cas où les float sont effectivement acceptables et éventuellement préférables, lève ce problème.

Mais je confirme qu'il est chiant. Java n'est pas très adapté à ce genre de calcul intensif. Il y a aussi les accès aux tableaux, qui sont plus lents qu'en C.

[JoeChip]

Pour faire ça facilement, il faut définir une classe contenant la valeur et les accesseurs, ensuite il n'y a qu'un mot à changer. Ce qui permet ensuite non seulement de passer de float à double ou l'inverse, mais de compliquer bien plus, genre lire la valeur sur un capteur, en ne devant modifier que dans l'objet...

De toutes façons, il y a toujours moyen de dire "double toto, tata, riri ;" pour ne devoir changer qu'un mot.

Cela dit, avec un traitement de texte simple, il est assez facile de remplacer tous les "float" par des "double", donc c'est peut-être un problème assez marginal, tout ça, non ?

[Drakiss]

Cela dit, avec un traitement de texte simple, il est assez facile de remplacer tous les "float" par des "double", donc c'est peut-être un problème assez marginal, tout ça, non ?

Et oui merci le Ctrl+f Find double & Replace with float, Replace All et hop c'est fini...

[Robin56]

Et oui merci le Ctrl+f Find double & Replace with float, Replace All et hop c'est fini...

Sauf que je suppose que dans leur cas, c'est plutôt remplacer tout les double qu'ils avaient taguer comme étant "A changer" et non tout les double de l'application entièrement.

[thelvin]

Oui, mais :

Pour faire ça facilement, il faut définir une classe contenant la valeur et les accesseurs, ensuite il n'y a qu'un mot à changer. Ce qui permet ensuite non seulement de passer de float à double ou l'inverse, mais de compliquer bien plus, genre lire la valeur sur un capteur, en ne devant modifier que dans l'objet...

Coût d'accès et de mémoire abominables, or les seules raisons de préférer float à double, c'est l'occupation mémoire et le temps de traitement.

De toutes façons, il y a toujours moyen de dire "double toto, tata, riri ;" pour ne devoir changer qu'un mot.

Ça ne changera pas les déclarations de méthodes, ni de variables locales à chaque.

Cela dit, avec un traitement de texte simple, il est assez facile de remplacer tous les "float" par des "double", donc c'est peut-être un problème assez marginal, tout ça, non ?

Sans doute vrai en pratique, c'est ce que j'avais fait moi . Mais en théorie, il pourrait très bien y avoir un type "changeant" de float à double suivant les préférences, et des types "constants", qui restent float ou double quel que soit ce qu'est le type changeant. Dans ce cas, ça ne marcherait pas.

[zigmo]

Eh oui, seules certaines variables sont à changer, ce serait trop simple !

Merci à tous pour vos réponses et vos idées.

[JoeChip]

Il suffit peut-être d'ajouter un truc genre "/**/" avant chaque "float" remplaçable....?

[zigmo]

Il suffit peut-être d'ajouter un truc genre "/**/" avant chaque "float" remplaçable....?

...ou bien affubler les variables en question d'un préfixe. Il y a plein de possibilités.

En réalité, comme je découvre Java, je voulais juste savoir s'il existait un mécanisme similaire au #define. La réponse est non. Alors on fera sans...