Bonjour.

Je suis actuellement en dut informatique et je dois réaliser un exercice de tp. Je pense y être parvenu mais je ne suis pas sûr. Vous pourrez voir que les attributs dans ma classe Article sont privés et je n'ai pas eu besoin d'un setter pour leur donner une valeur ni même d'un getter pour les visualiser. Je me demande donc comment cela se fait-il.

Toujours dans ma classe Article, je me pose des questions si j'ai bien compris ce que j'ai fait.

Je pense que à la ligne 21 de la classe Article j'ai créé mon constructeur Article et que je lui ai donné des paramètres entre parenthèses. Est-ce bien le cas ?

Voici l'énoncé de l'exercice :

ET

Voici ce que j'ai fais :

Voila merci d'avance

Tu n'as juste à aucun moment eu besoin d'un getter et d'un setter puisque tu appelles seulement une fonction publique de la classe Article. (à savoir obtenirEtiquette)

En revanche, si tu avais besoin des valeurs dans afficherEtiquette() tu aurais créé un getter et un setter.

Tout d'abord merci de ta réponse.

Je ne comprends pas trop. J'utilise quand même les variables puisque je leur donne une valeur.

Et sinon c'est bon ce que j'ai dis avec le constructeur et les paramètres dans mon premier post ?

Le 07 octobre 2016 à 21:17:58 lucas-x-ray2 a écrit :
Je ne comprends pas trop. J'utilise quand même les variables puisque je leur donne une valeur.

Et sinon c'est bon ce que j'ai dis avec le constructeur et les paramètres dans mon premier post ?

Le constructeur est ok, il prend bien 3 paramètres et initialise les attributs.

Une classe encapsule des méthodes et des variables. Une méthode qui est en dehors de ta classe n'a pas la même visibilité qu'une méthode en dehors de ta classe.

Une méthode dans la classe article, a accès à tous les paramètres (public et private), alors qu'une méthode dans afficherEtiques() n'aura accès qu'aux fonctions qui sont publiques (constructeur et ObtenirEtiquette().
Si tu mets un attribut public, ou que tu créés un getter, tu pourras voir les voir depuis afficherEtiques().

Merci beaucoup

Je regarderais tes explications un peu plus tard et je dirais si j'ai compris

Merci beaucoup pour vos réponses en tout cas

Bonjour. Je réutilise ce sujet car j'ai un problème avec plusieurs questions de qcm.

Je ne comprends pas pourquoi ici la réponse est vraie :

Je ne comprends pas ici pourquoi la réponse est fausse :

Et je ne comprends pas non plus pourquoi ici la réponse est oui :

Merci d'avance pour votre aide

1.
Je te conseil de te renseigner sur le terme "surcharge" en Java.
Tu peux créer plusieurs méthodes avec le même noms, à condition que leurs nombres de paramètres soit différents, ou que leurs paramètres sont différents. Int et Double étaient différents, c'est bon.

2.
Le mot-clé void indique que c'est une méthode et non un constructeur.

3.
La méthode accepte une Personne et change son nom, pas besoin de la retourner.
Je te conseil de te renseigner sur les termes "effet de bord".
En gros, la méthode changer et la méthode appeler partagent le même objet, si une méthode fait des changements sur cet objet, alors l'autre méthode les reçoit aussi, puisque dans la mémoire, c'est le même objet (comme si tu passé des paramètres par pointeur en C).

J'espère que c'est pas un truc noté

Tout d'abord merci de ta réponse

Ensuite pour la question 1, il y a le même nombre de int et de double comme paramètres dans les deux méthodes. C'est simplement le fait que le double soit mis avant le int et inversement qui autorise la surcharge ?

Pour la question 3, je ne comprends pas pourquoi ça modifie la valeur de l'objet et ça ne marcherai pas avec un type primitif comme int. Je suis un peu perdu ^^

Malheureusement c'est noté :/

Pour te faire une explication différente, considere que lorsque tu appel la fonction static changer tu passes une variable int qui contient la position en mémoire de l'objet.

Ce qui veut dire que si t'appelle la fonction changer de l'objet, c'est bien cette objet qui va être modifié directement à son emplacement en mémoire. Si jamais maintenant tu fais truc = null ou même truc = new Personne(....) Tu changes juste la valeur de la position en mémoire. L'objet d'origine dans le main reste intact

Merci de ta réponse

J'ai du mal à comprendre :/

Et ce n'est pas simple d'expliquer ça sur un forum j'imagine ^^

Je vais regarder à tout ça

Et sinon pour la question 1 c'est juste l'ordre des paramètres qui fait que je peux avoir une surcharge ? Car si on regarde bien, il y a le même nombre de int et de double comme paramètres.

Merci encore

Merci de ta réponse

Je crois que je me suis mal exprimé ^^

Ce que je ne comprends pas c'est pourquoi il peut y avoir une surcharge alors qu'il y a le même nombre de paramètres et qu'il y a le même nombre de double et de int dans les 2 méthodes.

Ma prof nous a dis que si il y a le même nombre de paramètres, alors il ne peut y avoir de surcharge. Et si il y en a le même nombre alors pas le même type de paramètre.

Et la il y en a 2 et en plus le même nombre de int et de double dans les deux.

Une surchage c'est le fait d'avoir plusieurs fonction du même nom, mais qui différe en nombre de paramètres, ou selon les types .

Et (int x, double y) c'est différent de (double x,int y).

Mais la c'est marqué (int P1, double P2) et (double P2, int P1)

Il n'y a que l'ordre des paramètres qui change.

On a le même type pour chaque paramètre. C'est ça que je ne comprends pas.

Et dans ton exemple tu as le même nombre de paramètres donc ce n'est pas bon, si ?

Désolé pour toutes ces questions mais je suis un peu perdu

Illustration par l'exemple :
Tu ne pourrai pas avoir les couples :
multiplier (int x, int y)
multiplier (int y, int x)

multiplier (int x, double y)
multiplier (int y, double x)

Mais tu pourrai avoir :
multiplier (int x, int y)
multiplier (double x, double y)

multiplier (int x, double y)
multiplier (double x, int x)

Le nombre de paramètres est le même, mais leur ordre est différent.
Tu vois mieux ?

D'accord !! Merci beaucoup à vous !

Ce que je me demandais c'étais si l'ordre des paramètres avait une influence. Donc oui elle a une influence.

Merci beaucoup

Ah mince je me suis emballé un peu vite^^

Quelle est la différence entre ton exemple 1 et ton tout dernier exemple ? Car si on regarde, a part le fait qu'il y ai int et double et que dans l'autre il n'y ai que int c'est la même chose.

Alors pourquoi la première ne marche pas et la dernière marche ?

Le système ne regarde pas les noms des paramètres.
Le premier exemple, il va voir : multiplier (int, int) et multiplier (int, int) et il sera incapable de faire la différence entre les deux, il ne peut pas savoir lequel tu appelles, donc c'est impossible.

Le dernier, l'ordre de int et double est inversé, il sait quelle méthode a un paramètre qui commence par un int, laquelle par un double, donc, il pourra faire la différence.

D'accord ! Merci vraiment énormément !