Bonjour, je suis au chapitre des classes abstraites dans le tuto de java et je n'arrive pas à comprendre pourquoi sur un code au milieu de ce chapitre (abstract class animal...) les méthodes n'ont pas de "static" devant...

Salut,

hm pour qu'elles raisons penses-tu qu'elles devraient être static ?

Je sais pas, à vrai dire je me rappelle pas quand il faut mettre static mais je l'ai toujours mis...

static veux dire
"ne dépend pas de l'objet"

(pense bête : static = ne varie pas)

alors maintenant à ton avis pourquoi n'y a t'il pas de static ?

@Yourgod2000> Tu n'as donc jamais fait de POO jusque là alors en fait.
Alors d'une part ce n'est absolument pas spécifique aux classes abstraites, d'autre part tu ferais mieux de bien maitriser les classes "normales" avant d'aller plus loin.

J'allais te renvoyer vers le cours officiel présent ici, mais après relecture je le trouve assez affreux sur ce point là (on voit certaines méthodes d'instances de la classe String dans le chapitre "méthodes de classes", inversement plus loin.. )
Heureusement qu'il y a des types comme Snooooopy pour recoller les morceaux

Citation : Snooooopy

(pense bête : static = ne varie pas)

Certainement pas un attribut ou une méthode abstraite se comportent totalement comme leur équivalent non-static, leur différence vient de leur accès qui ne nécessite pas d'objet instancié.

Ce qui fait que la valeur d'un attribut statique est commune à tous les objets de sa classe.

j'essayais de faire simple =/

Ce n'est pas simple c'est faux, un attribut statique n'est pas invariable.
Un attribut final (static ou pas) lui est invariable(enfin du moins sa référence, rien n'oblige l'objet référencé à être immutable).

soit =/ scuz moi c'est comme ça que moi j'ai appris =/ au début on m'a dis ça...

lol, ouai bon....je vois que c'est pas simple, pour ma part la je suis un peu embrouillé...et j'avoue pour répondre à freecircus que je galère depuis le passage à la POO mais je trouve que le cours n'est pas très bien fait, j'ai vraiment lu puis relu à tête reposée les deux premiers chapitres de la POO mais ça reste toujours abstrait (tout comme ces fameuses classes :p)...
J'aurais besoin si c'est possible, d'un exercice hyper simple pour m'entraîner en POO...et en classe abstraite qui plus est..

peut être mieux vaut commencer par penser POO avant de rajouter les class abstraite
tu sais déjà faire des truc graphique ? ou il faut te trouver un exercice uniquement en console ?


ça ne devrait pas te prendre trop de temps (si tu pense POO )

tu fais un jeux de dés ok ?

voici les règles :
donc les règles c'est une espèce de poker
mais avec des des


la personne lance 5 dés

après avoir lancé les dés une fois, il peut choisir les dés qu'il garde, et relancer les autres
(il ne peut en relancer que 3 maximum (de dé) )
il peut refaire ça trois fois

après ça tu n'est pas obligé de le faire mais on compare avec les combinaison possible voir plus bas

la ou ça deviens marrant c'est que ce ne sont pas des dés normaux

il y a non seulement les chiffre mais aussi des couleurs dessus

pour le premier et le deuxième dés, toutes les faces "PAir" sont rouge et les face impaire sont noir

pour le troisième et quatrième dés, toutes les faces "imPAir" sont rouge et les face paire sont noir

pour le 5eme dé sont rouge les faces 1,2,3 et sont noir les faces 4,5,6






voici une autre idée
deux personne s'affronte a un jeux de batail modifié
ils ont chacun un jeux de 52 carte (jeux classique )
le but n'est pas de gagner toutes les cartes mais bien de marquer un maximum de points

tour de jeux :
ils piochent chacun une carte et la compare
...si les deux cartes on la même "couleur" (dans le sens carreau, trèfle, cœur ou pique) => ils comparent simplement la valeur de la carte si c'est la même, égalité personne ne marque de point sinon le plus fort gagne un point l'autre gagne 0

...si les deux cartes n'ont pas la même couleur la couleur la plus forte gagne :
(Coeur>carreau>trefle>pique)

une fois les cartes comparée chacun reprend sa carte et re-mélange son jeux (en remettant la carte dedans)

Merci pour les exos je vais essayer d'en faire un des deux aujourd'hui.
Je commence l'exo des dés et j'ai déjà beaucoup de problème, je me rend compte que je ne suis pas capable de réaliser la moitié de l'exercice, je ne sais pas générer un nombre aléatoire, je ne sais pas comment m'y prendre pour dire qu'il y a 3 personnes en jeu, et certains autres petits truks...
Pour le moment j'ai juste crée une classe "Principale", une classe "Dés", 3 classes héritées de "Dés" qui sont "DésUnEtDeux" "DésTroisEtQuatre" "DésCinq". Dans "Dés" j'ai mis un tableau {1,2,3,4,5,6}...

As-tu pensé en termes d'objets ?
Bon on n'est plus vraiment dans le cadre de classes abstraites mais c'est vrai que pour comprendre leur utilité il faut beaucoup de pratique.

Pour générer des nombres aléatoires, ben suffit de fouiller un minimum pour trouver (forum/tuto/google).
Essaie déjà de faire jouer deux personnes. Après tu pourras essayer de penser un jeu à n personnes, y'aura quelques petits changements à effectuer (rien de bien méchant).

Ce n'est pas mon boulot de décider ça, mais peut-être devrais-tu créer un autre topic pour l'aide à la confection de ce jeu ?

[EDIT]
En fait dans l'idée lancée par snoooopy, y'a qu'un seul joueur Et si j'ai bien compris y'a une histoire de dés qui sont spéciaux... Dans ce cas on peut rassembler toutes les caractéristiques communes aux dés dans une seule classe (abstraite peut-être ? ^^). Classe abstraite car on ne souhaite à aucun moment instancier un dé (juste les 5 dés spéciaux). Donc t'es bien parti.
Dans la classe Dé, tu devrais mettre des méthodes (par exemple couleurObtenue, chiffreObtenu, ...).

hihi, oui je pensais faire des classes comme j'ai dit ci-dessus, mais ensuite pour que le joueur lance les dés comment je peux faire? C'est surtour ça que je ne comprend pas. Habituellement on est capable de lui faire taper du texte ou des nombres mais lui faire lancer des dés...

Et comment t'y prendrais-tu pour lui faire taper du texte ?

mm...un Scanner (que je dois d'ailleurs apprendre à réutiliser car il n'est plus évoqué depuis beaucoup de chapitres)
Autre question pour les méthodes abstraites, dans l'exemple du tuto aucune d'entre elles renvoit quelque chose (void blabla())
Peut-on écrire une méthode abstraite du style "abstract String couleur(int chiffre)"?
(ça serait ensuite pour renvoyer une couleur en fonction du chiffre donné par le dé)

Ah oui d'accord. L'intéraction console est assez gênante en effet.
Pour débuter, tu peux faire correspondre un chiffre demandé à l'utilisateur à l'action "lancer les dés".

Oui une méthode abstraite, c'est simplement la signature de la méthode avec le mot-clé abstract. Tu peux mettre n'importe quel type de renvoi.

D'accord, qu'est ce que l'intéraction console?
L'action lancé les dés, tu veux dire par là s'il écrit lancer les dés ça lance les dés?

Euh l'intéraction console, c'est le fait qu'un utilisateur comme toi ou moi puisse communiquer avec le programme (qui s'affiche dans la console).
Dans les logiciels plus courants, on a des applications graphiques pour intéragir avec le programme.

Alors j'ai bien écrit : "...associer un chiffre à l'action...".
Donc ce qui se passe, avec un Scanner, tu demandes à l'utilisateur d'entrer un chiffre (par exemple 1). Dans ton code, tu vérifies si l'utilisateur a rentré le chiffre 1. Si c'est le cas, tu exécutes la méthode lancerDes().

Si tu ne comprends pas encore ceci, tu devrais relire plus attentivement la première partie du tuto.

Oui je comprends ok ok

dans mes premiers exemple il n'y a pas vraiment besoins de classe abstraite
mais je me dis que commencer simplement par bien comprendre comment agencer ses class
et puis compliquer au fur et a mesure

le principe est simple tu me propose un code puis je te dirai ce que moi j'en pense et te dirai comment j'agence les choses

si tu ne veux pas perdre trop de temps tu peux directement me présenter un diagramme UML
c'est le plus simple a faire pas de code juste de la réflection
a dire vraix je m'en fous un peu de ton code ce qui m'interesse c'est savoir quels class tu compte créer et que feront elle ? de qui elles héritent ?

c'est la partie la plus importante en bref la décomposition de ton programme si tu le décompose assez bien en 2 h tu as finis de le faire (2h max je veux dire)
si tu est trop procédurale ça prendra plus de temps à faire


Donc réfléchis bien puis dis moi exactement les class que tu vas faire et leurs rôle
si tu sais me donner un diagrame uml c'est encore mieux
(fin tu dois pas faire UML, UML tu fais juste des fleches pour dire qui utilise quoi et des fleches en pointillé pour dire qui hérite de qui et c'est ok)





suffit de faire ça :

new Random toto = new Random();

apres ça a chaque fois tu fais

toto.nextInt(5)+1; //renvois un nombre entre 1et6

Pour ce qui est de tes dés, la décomposition n'est pas mauvaise du tout
l'avantage c'est que si un jours tu veux faire des dés à 13 faces tu peux avec un minimum de modification

ha au passage comme t'as dis elmh la class "Dés" ne sera jammais utilisée en temps que tel tu es d'accord ?
donc la mettre en abstract peut être une bonné idée

Voilà un aperçu de mon code, il y a évidement des fautes que je réglerais plus tard, c'est juste pour que vous voyez mon évolution et me dire éventuellement certaines choses un peu stupides que j'ai faites...

public class Principal {

	public static void main(String[] args) {
		
		System.out.println("Bonjour, commencez!");
		
		// code
		
		System.out.println("Vous avez fait un...");
		
	}
}

public class Dés {
	int face[] = {1,2,3,4,5,6};
	abstract String couleur(int chiffre);
	
	public Dés(){
		
	}
}

public class DésUnEtDeux extends Dés{
	abstract String couleur(int chiffre){
		if(chiffre % 2 == 0){
			return "rouge";
		}
		else{
			return "noir";
		}
	}
}

public class DésTroisEtQuatre extends Dés{
	abstract String couleur(int chiffre){
		if(chiffre % 2 == 0){
			return "noir";
		}
		else{
			return "rouge";
		}
	}
}

public class DésCinq extends Dés{
	abstract String couleur(int chiffre){
		if(chiffre == 1 || chiffre == 2 || chiffre == 3){
			return "rouge";
		}
		else{
			return "noir";
		}
	}
}

Voilà, c'est l'idée, je continuerais ça demain à tête reposée je pense.

Merci pour vos aides, ça m'est vraiment utile

bon primo j'aime vraiment pas cette façons d'attribuer directement une valeur à une variable

bon je m'attaque vite a la class "Dés" que je trouve pas top pour l'instant

int face[] = {1,2,3,4,5,6};

et quoi ? si tu veux faire des dés a 10 faces ?
en général mieux vaut simplement mettre

int face[];

et puis tu définira dans les class fille ce que vaut les faces
et comment gère tu la couleur de la face ?

moi je te conseil de faire 2 variable int (au cas ou tu voudrais faire plus de deux couleurs

int Valeurface[];
int Couleurface[];

ou encore
String Couleurface[];</code>
(mais moi je préfère la première solution je préfère travailler avec des int ça prend moins de place en mémoire voir secret juste en dessous:p)



dernière chose .... tu lances ton dés et puis quoi ? comment tu retiens sur quel face il est ?
peut être ferais tu mieux de rajouter une variable qui le fait directement dans le dé






voilà maintenant dans chaque class fille, tu devra définir ce que vaut les faces et les valeurs
pourquoi je fais ça ? et je fais pas tes méthodes "if(chiffre % 2 == 0){"
parce que tu ne pourras pas toujours faire un calcul de couleur si je te donnes des truc spéciaux genre un dés à 12 face
1,2,5,7,8,10,12 sont rouge les autres sont noir sauf 11 qui est jaunes

mieux vaut déterminer ton des et pas refaire les calcules à chaque fois

en plus grâce à ça, la fonction " String couleur(int face)" est la même pour tous les dés et tu ne dois plus la redéfinir dans chaque class fille :

String couleur(int face){
return Couleurface[face];}

ensuite dans chacune de tes class qui héritent de Dés tu fais la même erreur

quand tu déclare une fonction abstarct, c'est que les class fille doivent la définir pour pouvoir l'utiliser
hors dans tes class fille tu dis encore qu'elle est abstract donc pour pouvoir les utiliser il te faudra des class fille de class fille =/ bref tu ne dois pas les déclarer abstract si elle ne le sont plus





PS : au passage "Valeurface" pourrais sembler inutile mais rien n'oblige tes dés à aller jusque 6 on pourrait faire un des qui ne vas que jusque 3 mais une fois en rouge et une fois en noir (6 faces donc)

Ok ok mais chaque chose en son temps il y a beaucoup trop de truk que je maîtrîse pas ici...j'ai au moins appris que lorsque l'on réutilise une classe abstraire il ne faut plus la déclarer abstraite...
Pour le reste c'est exrtêmement abstrait...comme je l'ai dit plus haut, je maîtrise très mal la POO et donc un exemple comme celui ci me paraît un peu difficile pour moi...
N'en n'aurais tu pas un autre encore plus simple? (même si celui ci doit te paraître trivial :d)...

Un exemple de code pour débutants, c'est de coder un système de coordonnées dans le plan.
En gros tu codes une classe Point, puis une classe Coordonnees, et pourquoi pas une classe Plan qui s'occuperait d'afficher le plan (en console bien sûr). Enfin pour cette dernière, c'est plus une démonstration de dessins ASCII...

Si tu passes au chapitre sur l'héritage, pense à un exemple d'héritage dans la vie réelle ! Ou code par exemple la hiérarchie d'une université (employés, étudiants, profs...). Il faut à tout prix maîtriser ces notions avant de s'essayer à autre chose.
Essaie mon premier exemple (avec les points), implémente des getters et des setters, déclare tes variables d'instance private.

Y'a pas vraiment besoin de tuto, juste un cerveau et plus ou moins d'efforts pour tester, se tromper, apprendre.

.... XD
tu as tans de mal que ça a décomposer en objet ?

bonne idée elmh ça, c'est vraiment simple
mais peut être ferait tu mieux d'éviter de lui dire ce qu'il doit faire
on est ici pour lui apprendre à réfléchir si tu dis déjà les class qu'il doit faire, il ne réfléchira pas

Avant de réfléchir il faut comprendre le principe ... On le guide pour les classes a faire puis il les implémente lui même de façon à voir comment on fait interagir les classes entre elles.

Une fois ça compris, à lui le jeu de dés (que tu peux simplifié d'ailleurs avec 2 joueurs, chacun fait un lancé et +1 points pour le plus grand score dans un premier temps).

pour moi le jeux de dés etait 1 seul joueur
en faite la partie interaction joueur ne m'intéressait pas seul la partie Dés et comment il les gère m'intéresse
pour ce qui est du joueur... je le ferai une fois que ça marche pour 1


mais si il n'y à qu'un lancé :s ça sert a rien de programmer en POO alors :s

Ok, bon, je vais essayer de réaliser ce petit exo, je vais clôturer le topic et en rouvrir un autre quand j'aurais pas réussi à faire l'exo
Allez, grand merci à tous @+