Bonjour! J'ai un exercice en Java et je ne sais pas comment le résoudre (j'ai de problèmes avec cette matière je comprends tout mais quand je dois écrire le code je n'arrive pas) Donnée:
Créer une classe permettant de gérer les nombres complexes. Cette classe représentant un nombre complexedoit permettre l'addition, la soustraction, la multiplication et la division de ce nombre avec un autre nombre complexe.
Merci d'avance
Tu tapes "Java complex class" par ex et tu vas trouver un exemple. Ici notamment :
http://introcs.cs.princeton.edu/java...plex.java.html
Bon, ca va aussi te donner la solution complète et au delà mais pour apprendre à programmer, lire du code écrit par d'autres est très efficace.
En effet, mais si peux me permettre une remarque, il serait bon ensuite d'essayer de faire l'exercice sans regarder la solution, car si la compréhension de celle-ci semble faire croire que tout semble désormais acquis, c'est souvent loin d'être le cas.Envoyé par pm42
A+
Je ne peux qu'approuver mais vu la simplicité de l'exercice et la question posée, j'ai supposé que cela avait peu de chance de se produire.
La simplicité est une notion très relative
Déjà OP qui ne présente même pas un bout de code, je vous trouve bien urbains
Je suis d'accord avec Bisou10, surtout en lisant "je comprends tout mais quand je dois écrire le code je n'arrive pas".
Ça ne peut pas se résoudre avec un copier-coller qui permettra juste d'avoir une bonne note, et encore à condition que le prof d'info n'ai jamais entendu parler de google ...
Il faudrait plutôt commencer par :
Qu'est-ce que doit contenir la classe en question :
- quels attributs ?
- quelles méthodes ?
Définir les types et prototypes précis et enchaîner sur le développement des méthodes.
Là, Christina1414 aurait des chances de progresser.
Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.
J'ai du rater la partie où "lire du code pour apprendre" s'est transformé en "faire un simple copier-coller" mais bon...
Je t'accorde que c'est une pure extrapolation de ma part.
Mais je crains d'avoir été assez réaliste, hélas ... (sans préjuger de la bonne volonté de Christina1414, d'ailleurs : c'est simplement trop tentant quand on a la solution de se contenter de la recopier).
Ce qui se conçoit bien s'énonce clairement ; et les mots pour le dire arrivent aisément.
Oui. le "Bon cela va aussi te donner la solution complète" était un regret de ma part. Je me suis dit que s'il y avait motivation, on aurait un retour, des questions et possibilité d'aider à progresser.
Sans tout cela, je reconnais que poser des questions comme tu le suggérais est sans doute plus efficace mais je dois reconnaitre que j'ai eu un instant d'optimisme sur "je comprends le cours mais j'ai du mal à écrire"...
Bonjour
Si je peux comprendre l'interêt de l'exercice, dois je en déduire néanmoins qu'il n'existe pas d'implémentation standard des complexes dans Java ???(c'est une vraie question).
Dernière modification par Bluedeep ; 17/09/2015 à 13h12.
Non, pas en standard en effet. Comme dans pas mal de langages d'ailleurs.
D'accord. Mon étonnement était motivé par le fait que .NET a une implémentation standard des complexes depuis 5 ans (framework 4.0), au demeurant très facile à implémenter sur n'importe quel langage disposant de la surcharge d'opérateur.
Oui mais Java n'a pas la surcharge des opérateurs et suit une logique très différente de .NET. On pourrait même argumenter que Java est trop conservateur et que .NET est l'une des grandes réussites de Microsoft mais je souhaiterais éviter de lancer une polémique.
Ah, j'ignorais (j'ai une excuse : la dernière fois que j'ai eu des développeurs "java" , c'était il y a plus de 15 ans)
A l'origine, Java avait un coté "anti-C++" : l'idée était qu'en lisant le code, on devait immédiatement savoir ce que ça faisait sans devoir savoir ce qui avait été défini ailleurs (en gros).
Donc pas de post-processeur, pas de surcharge d'opérateurs, etc.
Avec le temps, ce principe s'est un tout petit peu relaché mais pas tant que ça.
C'est un point qui peut se défendre; concernant la surcharge d'opérateur, le seul problème pouvant se poser est une utilisation avecc des redéfinitions "non naturelles" de la part du développeur; car on peut tout aussi bien arguer que cela contribut au contraire à la lisibilité du code.
Bonjour Christina1414,
C'est un petit exemple sur la manipulation des nombres complexes en Java
http://codes-sources.commentcamarche...bres-complexes
Bon courage!
Oui, c'était l'idée de Java (comme d'autres langages avant genre Ada) : favoriser absolument la lisibilité du code.
Maintenant, cela a fait un langage verbeux, qui évolue très lentement mais surtout, cette programmation "lourde" s'avère bien adaptée à de gros systèmes d'entreprise mais pas forcément à de la programmation rapide type prototypage, interfaces, sites Web...
D'où l'existence d'alternatives même dans le monde de la JVM : groovy, scala, clojure mais aussi le succès de Python et dans une moindre mesure de Ruby par ex (pour rester en dehors du monde .NET).
Bonsoir, merci pour votre solution. Mais je ne l'utiliserai pas car comme vous avez dit que la solution doit etre développée par moi meme. Et j'ai ouvert la discussion car j'ai la motivation d'apprendre ce cour et pas comme vous avez dit. Hier j'ai consacré 3 heures de suite pour résoudre ce problème sans aucune aide. J'ai vus maintenant que vous avez répondu sur ma question c'est pour cela je n'ai pas répondu avant et je n'ai pas posé des questions. Merci pour votre temps.
Je n'ai rien recopié. J'ai codé ma propre solution. Si je voudrais recopier la réponse il y a plein de sites sur google. En plus notre prof sait si le code est écrit par ses étudiants ou par une autre personne. Voila mon code pour te rassurer.
Code:package p; public class nbComplex { private double im; private double re; public nbComplex (double re1, double im1){ im = im1 ; re = re1; } // Constructeur explicite public double getim (){ return im; } //getter public double getre(){ return re; } //getter public void addition(nbComplex C){ im = im + C.getim(); re = re + C.getre(); } // Addition public void soustraction(nbComplex C){ im = im - C.getim(); re = re - C.getre(); } // Soustraction public void multiplication(nbComplex C ){ im = re*C.getim() + im*C.getre(); re = re*C.getre() - im*C.getim(); } //Multiplication public void division (nbComplex C){ im = ( im*C.getre() - re*C.getim())/(C.getre()*C.getre() + C.getim()*C.getim() ); re = ( re*C.getre() + im*C.getim())/(C.getre()*C.getre() + C.getim()*C.getim() ); } // Division public void affichage(){ System.out.println(re + "+" + "i" + im); } // Méthode d'affichage public static void main(String[]args){ nbComplex C1 = new nbComplex (1,2); nbComplex C2 = new nbComplex (3,4); nbComplex C3 = opComplex.addition(C1, C2); C1.addition(C2); C1.affichage(); C3.addition(C3); C3.affichage(); } } package p; import p.nbComplex; public class opComplex { public static nbComplex addition (nbComplex C1, nbComplex C2){ double im1 = C1.getim() + C2.getim(); double re1 = C1.getre() + C2.getre(); return new nbComplex(im1 , re1 ); } public static nbComplex soustraction (nbComplex C1, nbComplex C2){ double im1 = C1.getim() - C2.getim(); double re1 = C1.getre() - C2.getre(); return new nbComplex (im1 , re1); } public static nbComplex multiplication (nbComplex C1, nbComplex C2){ double im1=(C1.getim()*C1.getre() - C2.getim()*C2.getre()); double re1=(C1.getim()*C2.getre() + C2.getim()*C1.getre()); return new nbComplex (im1 , re1); } public static nbComplex division (nbComplex C1, nbComplex C2){ double im1=(C1.getre()*C2.getre() - C1.getim()*C2.getim())/(C2.getre()*C2.getre() + C2.getim()*C2.getim() ); double re1=(C1.getre()*C2.getre() + C2.getim()*C1.getim())/(C2.getre()*C2.getre() + C2.getim()*C2.getim()); return new nbComplex (im1 , re1); } }
Dernière modification par JPL ; 20/09/2015 à 22h49. Motif: Ajout de la balise Code (#) pour garder l'indentation
C'est pas mal mais quelques remarques :
1) la classe opComplex avec les statiques ne sert pas à grand chose. Si on a 2 complexes c1 et c2, on n'a pas de raison de faire opComplex.addition(c1, c2) au lieu de c1.addition(c2)
1) j'appellerais plutôt les méthode plus, moins, fois et diviséPar par ex. Comme çà on écrit c1.plus(c2). C'est du détail
2) je ferais plutôt une classe "immuable" c'est à dire qu'une fois crée un complexe avec im et re fixé, on ne peut plus les changer. dans ce cas, on peut supprimer les "getter" et faire du code plus simple et supprimer les méthodes statiques de opComplex. Cela offre aussi l'avantage qu'on peut utiliser ce genre de code en parallèle facilement et diminue les bugs potentiels. Ce sont des pratiques utiles pour des vrais programmes, pas un simple exercice mais c'est toujours bien de les connaitre.
Code:public class nbComplex { public final double im; public final double re; public nbComplex (double re1, double im1){ im = im1 ; re = re1; } // Constructeur explicite public nbComplex addition(nbComplex C){ return new nbComplex(im+C.im, re+C.re); } // Addition
