Transcription
1. Présentation générale: Salut les gars, et
bienvenue dans mon cours,
où nous allons créer à partir de zéro un monde
invité complet,
également connu sous le nom de jeu
et en Java, en utilisant les technologies Springbood, MySQAL
et Java Swing et Dans les sections suivantes, vous pourrez interagir avec différents aspects de la
création du jeu, tels que la définition
de l'écosystème, l'utilisation
du framework Springboard, l'
un des frameworks
les plus
populaires du marché, et vous parviendrez à créer
l'application de manière modulaire, chaque fonctionnalité étant séparée dans un package
correspondant Nous allons définir plusieurs
composants dans le cadre de ce jeu, mais ne vous inquiétez pas,
car je vais vous montrer exactement comment les faire
interagir les uns avec les autres. Enfin, comme il s'agit d'un simulateur de bourreau, nous devrons stocker les mots
quelque part Pour cela, nous allons ajouter les données dans la base de données
électionnelle Moser Commençons donc.
2. Premiers pas: La première étape de notre processus de
développement consiste à créer une application Spring
Boot. Je suis donc allée commencer
ce Spring Dot IO, et ici, vous voyez que vous avez plusieurs options
à choisir. Le type de projet, la version
Spring Boot, le langage Java et maintenant
les métadonnées du projet. Nous pouvons créer un groupe spécifique, que nous
appellerons Hangman Pour l'artefact,
nous l'appellerons jeu. Il en va de même pour le nom figurant
sur la description. Nous pouvons l'appeler le simulateur de
jeu Hangman. Pour le nom du package, nous pouvons choisir le jeu C and Man, le pot d'emballage, et
pour la version Ja, nous choisissons la version 11. Nous avons également la possibilité d'
ajouter des dépendances spécifiques. Mais pour l'instant, il ne faut pas
aller dans cette direction puisque ces dépendances
seront ajoutées manuellement
ultérieurement dans le cours. Nous pouvons aller générer
le projet. Ouvrons ce dossier. En fait, extrayons le
zip dans un dossier spécifique. Et découpons ce dossier
sous les projets ici. Bien entendu, vous pouvez choisir l'endroit que vous préférez. Nous avons maintenant la
possibilité d'importer ce projet Maven dans notre identifiant La prochaine étape
sera de créer les packages correspondants que nous utiliserons dans le cadre
de ce cours. Il s'agit donc de la
structure de base des packages. Appelons donc ce package guy and frame depuis l'interface utilisateur
graphique. Un nouveau package appelé Coman Game Guy and Listeners lequel nous stockerons nos auditeurs
correspondants Un autre package pour le menu. Je suis en
train de configurer un nouveau package pour les panneaux qui seront ajoutés au
cadre principal de l'application. J'essaie ici de structurer
autant que possible ce projet en
différentes sections. Créons un
package appelé model. Un référentiel numéro 14 dans
lequel nous stockerons notre référentiel
correspondant à Spring Data GPA Un pour le service,
où nous conserverons notre principal
service de logique métier pour le service IMPL. Dans le cadre du service, nous aurons une interface sous l'IMPL. Nous aurons la mise en œuvre
correspondante. Et un dernier package pour cela . Ici, à côté de la dépendance de démarrage de
Springboard Nous avons la possibilité d'ajouter
une nouvelle dépendance ici. Configurons l'ID de groupe pour le démarrage du framework O Spring. L'identifiant de l'artefact
sera Boot Starter Web. Depuis, je veux vraiment que l'instance Don't Get
fonctionne dans les coulisses. L'application sera
opérationnelle sans aucune interaction de
l'utilisateur. Démarrons l'application dès maintenant. Nous choisirons l'application Spring Boot, et l'
application Spring Boot
commencera à utiliser une instance
Tomcat intégrée, et nous avons la
possibilité de vérifier cela Allons dans notre navigateur et
tapons l'hôte local A huit, et nous verrons une page d'erreur
par défaut.
3. Commençons simplement: Maintenant que nous avons mis en
place
la structure principale de l'application en termes de packages, nous devons commencer à créer
nos composants réels. La première étape consiste à naviguer dans les panneaux de discussion de
Underhand Man Game
et à créer une classe simple Disons que c'est un panneau vide. La première chose à faire est d'
annoter cette classe avec le stéréotype du composant
afin qu'elle soit enregistrée avec le ressort en
tant que composant simple et puisse être injectée ultérieurement dans le cadre
correspondant Cette classe
étendra en fait le panel. Cela
nous est utile afin de créer le panneau lui-même en tant que composant
distinct. O. Maintenant, ajoutons un constructeur
simple Et nous avons la référence
au panneau J en utilisant le mot-clé di et nous
voulons définir la taille préférée à une dimension spécifique,
500 pour 100. Réglons également la couleur
d'arrière-plan du panneau sur le noir. Et nous pouvons configurer une
mise en page simple pour notre panneau. Et allons-y avec
une mise en page axée sur la cupidité. Deux et un. Je vais arrêter le lancement
initial de l'application. Maintenant que nous avons mis en place ce panneau
simple, nous pouvons passer au cadre du
jeu Changan et
créer le cadre réel de notre application qui
conservera tous les panneaux Nous pouvons cliquer sur le motif
fini. De plus, pour notre cadre de pendu, nous devons l'annoter
avec un composant afin qu'il soit
récupéré au printemps Cette classe
étendra le cadre J. J frame est une classe
du package Java Swing. Et nous avons la possibilité de câbler
automatiquement le panneau vide. Encore une fois, le
panneau vide étant un composant, nous pouvons l'injecter directement ici. Et nous allons également créer un
panneau appelé panneau principal. Ajoutons également un commentaire. Puisque ce panneau principal conservera tous nos panneaux importés qui seront ajoutés
au cadre principal. Imaginez que nous importions
tous les panneaux que nous avons créés, les ajoutions, que nous les ajoutions au panneau principal, et que ce panneau principal soit ajouté directement au cadre en J. Nous avons également configuré un constructeur
simple. Et créons une méthode
appelée create Min guy, et nous devrons l'
annoter avec post construct afin que cette méthode soit
automatiquement invoquée Nous avons importé le package de
notation Java afin d'utiliser correctement la notation
post-construction. Nous allons maintenant définir des propriétés
spécifiques pour notre cadre principal en J. Nous devons définir les
limites à 170100500. Nous n'autoriserons pas l'utilisateur à redimensionner ce
cadre en j en option L'étape suivante consistera à ajouter un
écouteur de fenêtre spécifique à ce cadre en J. Nous devrons instancier
l'adaptateur Windows. Supprimez ces commentaires. Et nous devrons implémenter la méthode correspondante
appelée fermeture de fenêtre. En paramètre, cela
recevra l'événement window. Lorsque l'utilisateur clique sur le bouton x
pour fermer cette fenêtre, nous nous débarrassons
de l'application, nous la quittons et
libérons toutes les ressources. Maintenant, nous devons instancier
le panneau principal. Et sous le panneau principal, nous devons définir la mise en page. Et dans ce cas, nous utiliserons la disposition des bordures. Nous pouvons maintenant ajouter
le panneau vide sous
le panneau principal en utilisant l'option de disposition des
bordures. Ce panneau vide
sera donc ajouté en bas. Nous ajouterons également le panneau
principal au cadre J,
le cadre J principal, et définirons le cadre J comme visible pour
l'utilisateur correspondant. Maintenant, lançons
l'application. Sauvegardons le panneau vide, et vous verrez que nous avons reçu un message d'erreur Spring
does not work well with swing
correspondant aux composants correspondants, et vous verrez ici
l'erreur liée à headless Pour résoudre ce problème, nous devons accéder à la principale méthode
correspondante depuis notre application de jeu, et j'ai supprimé l'instruction
initiale, et nous devrons utiliser le générateur d'applications
Spring. Je vais créer un nouvel objet pour le générateur
d'applications Spring. Par exemple, nous recevrons la classe point de
l'application de jeu. Nous devons définir le headless
du générateur sur false et exécuter ce générateur Et nous sommes maintenant prêts à démarrer l'application puisque l'option headless
a été réglée sur Falls Et vous voyez ici, nous avons défini le panneau vide, et nous avons également la possibilité
de fermer le cadre en J.
4. S'amuser avec les images: Maintenant, avant de commencer à créer le panneau suivant, pas de liste,
le panneau des images. Nous avons besoin de quelques images
pour jouer avec. J'ai créé pour vous deux images, 14 en forme de sourire et 14 en set. La première chose à noter
est que nous devons
créer un dossier sous les ressources principales de la
source, et appelons-le images. Ne t'inquiète pas Je vous fournirai
à la fois le décor et les images de
Smile pour travailler sur
ce projet avec eux. Cela étant dit. Créons
le panneau suivant de notre liste. J'ai mis en place une classe
appelée panneau d'images. Cette classe devra également être annotée avec le
composant afin qu'elle soit captée par le conteneur à
ressort et pareil pour le panneau, nous devons étendre le panneau G. Par exemple, supprimez ces commentaires. Nous devons établir une
liste de labels G. Appelons cela une liste d'images. Cela sera utilisé
pour stocker nos images. Nous allons maintenant créer un constructeur
simple appelé image panel, bien sûr, et la méthode qui
sera annotée avec une construction post
afin qu'elle soit invoquée automatiquement
par Spring
afin de configurer toutes les propriétés de notre panneau
d'images La première chose à faire
sera d'instancier la liste d'images sous forme de liste Et définissez également la taille de référence sur 100100 en tant qu'
objet de dimension pour notre panneau G. Corrigeons ce problème car
cela ne s'appelle pas des images, c'est en fait une liste d'images. D'accord. Définissons une
couleur d'arrière-plan spécifique pour le panneau en blanc. Et nous définirons également
une mise en page spécifique sous forme de
grille avec cinq
lignes et une colonne. Créons de l'espace ici. Maintenant, j'aimerais faire une boucle en quatre en commençant de
0 à 4 inclusivement Donc, moins de cinq et
nous allons créer une étiquette. Imaginons que nous
devions stocker cinq images. Nous avons créé des
objets simples pour notre étiquette J. Passons également au jeu
C hangman Teal et créons un assistant simple Puisque j'aimerais
stocker quelques références
à des images de sourire et de tristesse
dans cette classe auxiliaire. J'ai donc noté cette
classe avec un composant. Configurons quelques icônes d'image
simples. Il s'agira d'une
icône d'image qui
fera référence à l'image du sourire. Nous devons créer une icône représentant une image. Et nous utiliserons le chargeur de classe help
get. Obtenez une ressource. Et si vous vous souvenez bien, nous avons configuré l'image sous
les images, Smile JPG. Faisons également quelque chose de
similaire avec l'image satellite. Une nouvelle icône d'image,
le même processus, permet d'obtenir le chargeur de classes, d'
obtenir des images de ressources. Maintenant, définissez ce PNG. Nous avons donc pris connaissance de ces
deux images. Passons maintenant au panneau
des images, et ici, en tant que paramètre
du constructeur d'étiquettes J. Nous pouvons en fait utiliser
la référence à l'image du sourire auxiliaire, car par défaut, les
images auront le type correspondant défini
et obtiendront une image Mais vous voyez que nous
recevons une erreur, nous devons
donc d'une manière ou d'
une autre
transformer cette référence en un format spécifique
que le niveau G pourra réellement
utiliser correctement. Pour ce faire, nous allons
créer une méthode simple. Donc deux. Nous y reviendrons
sur l'icône de l'image. Appelons cela l'échelle selon laquelle nous recevons la
source de l'image comme référence. En gros, à partir de cette
source d'image à partir de cette image, il retournera sur l'icône de l'image. Nous allons définir à la largeur et à la
hauteur deux propriétés 250, une autre variable pour le type, et le type sera le type d'âge du
souffleur en RGB Oh Maintenant, créons une image mise en mémoire tampon appelée
DST à partir de la destination Nouvelle image tampon que
nous avons reçue avec 50, hauteur 50, dans le
type A en Go. Nous devrons utiliser
les graphiques et fonction de l'
image mise en mémoire tampon, la destination invoquera la méthode de création
graphique Nous allons maintenant pouvoir dessiner
une image à partir du graphisme vers
l' objet et ce
sera la source zéro, le
zéro, la largeur, la
hauteur, et ainsi de suite. Et nous devrons également invoquer la méthode dispose sur
les graphismes à objecter. Enfin, nous pouvons renvoyer l'icône de l'image à partir de cette méthode. Ici, il suffit d'
utiliser la méthode de l'échelle
et vous verrez que le problème a été résolu
et que l'étiquette pointera en fait vers une
icône représentant l'image du sourire. Nous devons également ajouter l'
étiquette de l'image à la liste des images. Pour le méta-code. Revenons au cadre
du handman. Puisque nous avons déjà ce panneau
d'images en place. Injectons-le en utilisant le câblage automatique. Panneau d'image privé. Semblable au panneau vide, vous pouvez l'ajouter au panneau principal. Ce panneau principal
ajoute des images, et nous utiliserons la
disposition des bordures comme pour l'est. Cela sera donc stocké dans la partie
droite de l'écran. Démarrons l'application. Et vous pouvez voir que le panneau
d'image a été configuré. Fermons ceci, par exemple. Déplaçons cette console vers
le bas de l'écran.
5. Événements d'utilisateurs: Avant de poursuivre et de commencer à implémenter le troisième
panneau de la liste,
nous devrons configurer certaines classes de composants
spécifiques dans nous devrons configurer certaines classes de composants
spécifiques le cadre de notre processus de
développement. Je veux donc le package de jeu C
Hangman. Créons une classe
appelée sp Context. Cliquez sur Terminer. Nous devrons
annoter cette classe avec un stéréotype de composant Ajoutons également un commentaire
descriptif, tel que ce composant
sera utilisé pour automatiser
le
contexte de l'application Spring dans la classe non correspondante. Vous verrez ultérieurement dans ce cours comment cette
classe sera utilisée. Le contexte Spring
doit implémenter de l'application en tenant compte du contexte. Nous utiliserons également la
dénotation automatique des fils. Ajoutons une variable en tant que variable
statique de type contexte d'
application, et appelons-la contexte
d'application. Assurez-vous de l'importer depuis
le package
correspondant au framework. Et nous devrons également remplacer
la méthode de définition du
contexte d'application
puisque nous implémentons la méthode consciente du contexte de
l'application Cette méthode reçoit le paramètre de contexte de
l'application et le type d'exécution Bins. J'ai importé l'exception Bins. Nous allons maintenant utiliser le contexte
Spring,
ce
contexte d'application qui doit être égal
au contexte d'application reçu en
tant que paramètre dans la méthode de contexte
d'application défini. Retournons également le contexte de l'
application à l'aide d'une méthode statique. Ici, nous renvoyons
uniquement le contexte de l'application. Avançons et travaillons sur les écouteurs qui seront
utilisés dans notre application Nous aurons un écouteur de souris
et également un écouteur de boutons. Passons donc aux auditeurs de
Hangman Game Guy
et créons notre écouteur de souris
qui répondra
aux événements de la souris pour les boutons qui seront
créés dans
notre cours auditeurs de
Hangman Game Guy
et créons notre écouteur de souris qui répondra
aux événements de la souris pour les boutons qui seront
créés dans
notre Cette classe d'écouteur de souris doit étendre
l'adaptateur de souris. J'ai configuré un simple
constructeur vide pour notre classe. Ajoutons un commentaire pour
la méthode que nous avons configurée, gérons le cas où la souris
saisit un motif spécifique. La méthode doit être
appelée mouse entered de type void et reçoit un événement de
souris en tant que paramètre. Nous devrons obtenir le
bas que nous avons sélectionné. En fait, le bouton qui
a déclenché cet événement de souris. Lorsque nous appuyons sur le
bouton avec la souris, cet événement sera
automatiquement généré. Si le bouton est activé, nous avons passé la souris dessus pour
simplement survoler le bouton Nous devons définir la
couleur de fond comme effet. Et mettons-le
en blanc pour que l'utilisateur sache sur quel
bouton il a survolé. Ajoutons maintenant une nouvelle
méthode qui
gérera le cas où la
souris quitte le bouton Nous devons l'appeler souris
sortie de type void, identique à la souris centrée sur la souris, elle reçoit un événement de souris Et nous devons vérifier si
le bouton choisi est activé pour définir également une couleur d'arrière-plan
spécifique pour ce bouton. Nous définissons la couleur de fond. Créons une nouvelle classe
appelée button listener. Cette classe d'écouteur de boutons doit implémenter un écouteur d'action Ajoutons également une méthode qui
doit être implémentée, action exécutée qui
reçoit un événement d'action E. Nous devons obtenir le
bouton actuel sur lequel nous avons cliqué En utilisant le même
procédé. Trouvez des sources. Nous allons simuler le fait que nous ne voulons pas que le bouton soit
à nouveau sélectionné Nous le désactivons et définissons également la couleur d'
arrière-plan sur le vert. Nous devrons également obtenir la lettre correspondante au bouton puisque chaque bouton
aura une lettre. Pour ce faire, nous utiliserons le
get text to chary of zero. Cela nous permettra en fait d'obtenir la première et la seule lettre
existante à ce bouton
ajoutée à ce bouton. Maintenant, si vous vous souvenez du contexte de
l'
application, la classe de contexte Spring sera utilisée ici pour le contexte de
l'application. Et plus loin
dans ce chapitre, vous verrez, une fois que nous aurons configuré
tous les boutons, comment nous pourrons utiliser ce contexte d'application
dans notre module.
6. Construire le décor: Nous sommes maintenant prêts à créer
notre troisième panneau dans la liste. Passons donc aux panneaux Guy du jeu C
hangman, au package
correspondant, et
créons une classe de panneaux de lettres Nous devrions suivre la
même approche pour annoter cette classe avec le stéréotype du composant afin qu'elle soit
reprise par Cette classe devra étendre le composant pivotant du panneau G. Nous devons maintenant créer
une carte spécifique qui
conservera les paires clé-valeur composées de lettres et de boutons
correspondants. Puisque nous essaierons de simuler
l'intégralité du clavier de notre ordinateur de bureau ou de l' ordinateur, cela dépend du cas de l'utilisateur. Je crée une
carte simple avec la clé étant une chaîne et la valeur le bouton
correspondant, et nous l'appellerons carte des lettres. Maintenant, pour le constructeur de lettres
patentes, nous allons définir une disposition simple d'une mise en page en
grille dans laquelle
nous utiliserons une structure de mise en page en
grille gratuite et sans aucune structure correspondante Nous allons mettre en place une méthode de création de
panneau annotée
avec post construct Cette méthode sera donc
automatiquement invoquée par printemps et nous commencerons à
définir la liste des correspondants à
partir de notre clavier. La première liste contiendra toutes les lettres de
Q à P inclus. J'ajoute ici toutes
les lettres
du Q au p de notre clavier. Utilisons une
approche similaire pour le second et nous allons
configurer les lettres de A à L. Rappelons
que toutes les lettres le sont. J, K et aussi L.
Mettons en place la
dernière ligne de z à M. Il s'agit d'une liste V B et de la dernière lettre M. Nous définissons des listes libres de
chaînes qui suivront lignes
de notre clavier
et incluront toutes les lettres. Maintenant, nous devons ajouter un commentaire descriptif, par
exemple pour chaque lettre de la liste. Nous devons créer un bouton
correspondant. Maintenant, je voudrais configurer
une méthode qui créera un panneau J pour la
liste des lettres qui
seront définies en paramètre. Nous recevrons chacune
des trois lettres et sur la
base de ces lettres. Nous allons créer le panneau
correspondant, et ce panneau
comportera un ensemble de boutons
correspondant à ces lettres. Je crée ici
un panneau de lettres. Cela servira de panneau
intermédiaire. Nous voulons créer
un écouteur de boutons, instance
correspondante, et ajoutons également
un écouteur de souris Nouvel écouteur de souris. Maintenant, pour chaque
lettre de la liste. Nous voulons créer un bouton et les données correspondantes
doivent y être mappées Faisons une itération sur la liste de lettres reçue en tant que paramètre
de cette méthode Et pour chaque lettre,
nous allons essayer de créer un bouton que nous avons reçu en paramètre
au constructeur de la lettre Nous souhaiterons créer certaines
propriétés pour ce modèle, telles que définir la taille préférée et définir la couleur
d'arrière-plan. 100. Nous devons maintenant ajouter
l'écouteur d'action, tel que ce bouton
répondra à des événements spécifiques,
ainsi que l'écouteur de la souris
afin que ce bouton puisse répondre aux
événements de la souris au centre de la souris
et à la sortie de la souris Ajoutons également une
police spécifique à ce bouton. Nous créons ici une variable. Appelons ça une police de caractères. Moi et nous allons
instancier une nouvelle police. Mais il ne faut pas
oublier le type, il s'agit donc de la police du nom de la
variable, et pour la police,
nous utiliserons le gras et 26. Utilisons la
classe d'assistance pour cela,
il s'agit une
variable constante, d'une police auxiliaire. Nous avons défini la police de notre bouton. Et maintenant, le bouton en forme de lettre. En fait, ajoutons un
bouton à lettres au panneau des lettres, et nous devons également l'ajouter
à la carte des lettres La lettre sera la clé,
et le bouton lettre
sera la valeur correspondante sorte que nous garderons tous
les boutons au même endroit, c'
est-à-dire Letters Map. Puisque nous créons ce panneau
intermédiaire, nous devons le renvoyer et selon
la méthode de création de panneau, nous devons invoquer le panneau de création de lettres pour
chacune de nos trois listes. Créons une variable
appelée panneau QP à laquelle nous
renvoyons un panneau de boutons
à partir de la liste QP Idem pour la deuxième
liste de A à L. Et aussi pour la troisième liste. Z. deux. Nous avons défini trois
panels. Et nous allons ajouter ces trois panneaux
intermédiaires
au panneau principal de la lettre s
en utilisant ce mot-clé, puisqu'il fait référence
au panneau principal Supprimons les espaces. Et maintenant, nous avons le panneau des
lettres en place. Mais nous voulons également
disposer des méthodes setter et
getter pour notre carte des lettres qui
conserveront une référence à tous nos boutons
ajoutés au panneau des lettres Il s'agit de la méthode get. Ajoutons également la méthode set. Faisons-le manuellement, puisque Spring Tool Suit ID
peut le faire automatiquement, mais nous pouvons le
noter nous-mêmes. Donc, cette carte de lettres
est égale à la carte de lettres. Passons au cadre
du bourreau. Injectons le panneau de la lettre S. M. Nous utiliserons la
notation automatique. Panneau de lettres privé,
panneau de lettres comme variable. Et ici, nous devons
ajouter le panneau de lettres
au panneau principal Mais cette fois, nous utiliserons la disposition des
bordures centrée. Nous allons donc ajouter ce panneau au
centre de notre écran Démarrons l'application. Et vous pouvez voir le
panneau en place. L'
écouteur de la souris est également en place. Vous voyez que lorsque
j'ai un bouton, la couleur change. L'
écouteur d'action est également en place. Lorsque je clique sur le bouton, le bouton passe au vert.
7. Deviner le mot: Dans cette vidéo, nous allons créer notre quatrième panel à partir de
notre liste de panneaux. Passons à notre
package de panneaux et créons une nouvelle classe. Cela s'appellera Word Panel. annoter cette classe avec un stéréotype de composant Spring, et nous devrons également
étendre la classe panel Ajoutons également un ID de version
de série par défaut. Nous devrons
configurer une nouvelle variable
qui sera une liste de boutons G, et nous l'appellerons liste de mots
générée afin que chaque lettre du mot généré mappée vers un bouton spécifique qui
sera ajouté à cette liste, une nouvelle variable appelée mot
généré qui conservera le mot généré
correspondant, et le nombre de tentatives que l'utilisateur a essayé de
deviner le monde. Dans cette classe de panneau J, nous aurons besoin d'une référence
au panneau de lettres s, nous allons
donc l'injecter. Également une autre référence
au panneau d'image. Injectez-les donc tous les deux
en utilisant la notation automatique. J'ai créé un
constructeur simple et ici, nous allons définir des propriétés de
panneau spécifiques J'ai ajouté la mise en page définie en
tant que disposition de flux simple. La taille préférée
pour notre panneau. Nous devrons définir la couleur d'
arrière-plan sur le noir. Nous allons maintenant annoter
une nouvelle méthode avec une construction post afin qu'
elle soit automatiquement invoquée par le printemps Cette méthode créera un panneau Jusqu'à présent, nous
devrons instancier le mot généré
avec un mot par défaut, car nous n'avons rien
en place qui générera
automatiquement des mots de façon
aléatoire Nous allons donc opter pour quelque chose de
simple à ce stade. Le
mot généré sera donc un jeu. Imaginons également
la liste de mots générée
sous la forme d'une nouvelle liste R A, et le nombre de
tentatives devrait être nul, puisque nous venons de commencer le jeu. Maintenant que nous avons
un mot en place, même s'il s'agit du mot
par défaut du jeu, nous devons en extraire les première
et dernière lettres. Il s'agira donc de variables
spécifiques au graphique. Pour la première lettre de Word, nous allons l'extraire du tableau de mots zéro
généré. Pour la dernière lettre d'un mot, nous obtiendrons la longueur des mots
générée
par le diagramme de mots moins un. Nous avons maintenant la première
et la dernière lettre du mot. Et nous devrons
répéter le mot généré et créer un bouton pour chaque lettre du monde
généré Le modèle final et appelez-le LB est instancié dans
un nouveau modèle, et par défaut, nous utiliserons ce signe pour
simuler que lettre n'est pas
montrée à l'utilisateur Nous allons définir la taille
préférée du bouton ainsi que la police
correspondante. Réglons également la couleur d'
arrière-plan sur le blanc et ne l'activons pas. Il doit être désactivé par
défaut afin qu'il ne
réponde à aucun
événement de clic ou de souris. Nous ajouterons ce bouton à
la liste de mots générée, ainsi qu'au panneau
correspondant. Maintenant, puisque nous avons les
première et dernière lettres extraites du mot
généré. Nous devons également
les montrer à l'utilisateur sur l'
interface utilisateur graphique. Puisque, comme vous le savez, nous
faisons une simulation de bourreau, et les premières et
dernières lettres
du monde devraient
être exposées à l'utilisateur J'expose donc la première lettre. Et exposons également la dernière lettre à l'utilisateur
en utilisant la méthode de texte défini. Nous devons maintenant itérer sur le mot généré
en utilisant une boucle à quatre boucles Car j'appelle zéro, longueur de mot
abaissée et générée moins un plus plus plus. Et nous devons tirer chaque
lettre du mot. Ajoutons également un commentaire ici. Et ce que nous
essayons de faire ici, c'est exposer la
lettre actuelle à l'utilisateur, si elle
correspond à la première lettre du mot généré ou à la dernière lettre
du mot généré. Donc, si la lettre actuelle
est égale à la première lettre, ou si la lettre actuelle est égale
à la dernière lettre. Nous devons obtenir la liste de mots
générée, la
référence du bouton correspondant et définir le texte la lettre actuelle. OK ? Et maintenant, nous devons
désactiver les lettres initialement
exposées dans
le mot que nous avons généré. De cette façon, nous devons désactiver les première et dernière lettres
du panneau de lettres, car elles sont
déjà exposées à l'utilisateur et celui-ci ne doit pas
pouvoir cliquer dessus. Passons au panneau des lettres. T et créez la méthode ici. Appelons cela des lettres
par défaut désactivées. Cette lettre doit recevoir
la première lettre en format Word et également la
dernière lettre en Word. Créons des chaînes
basées sur les deux graphiques que nous avons reçus en tant que paramètres pour la première lettre et
un pour la dernière lettre. OK ? Et maintenant, nous devons
désactiver la première lettre. Nous devons obtenir une référence à la première lettre du bouton Word. Pour cela, si vous vous souvenez bien, nous avons la carte des lettres qui fait référence à
tous nos boutons, et nous allons obtenir le bouton
correspondant en utilisant la première lettre
en majuscule. Sur la base de la touche de mappage des lettres, nous pourrons extraire la valeur du bouton
J correspondante, et nous devons essentiellement
désactiver ce bouton. Et définissez également la couleur
d'arrière-plan sur le
vert pour le simuler
d'une manière pour l'utilisateur. Une approche similaire
doit être suivie pour la dernière lettre que nous recevons en tant que paramètre
de cette méthode. Nous allons donc créer le bouton « Dernière
lettre du service ». Et d'après la carte des lettres, nous trouverons la dernière lettre. C'est la majuscule. Réglons ça. Nous avons la valeur correspondante du bouton J et nous devons la
désactiver et également définir la couleur
d'arrière-plan sur le vert. Faisons-le. Définissez le
fond vert, et c'est tout. Revenons au
panneau Word et invoquons cette méthode. Nous avons la référence d'
envergure des lettres que nous avons injectée plus tôt
dans ce composant. Appelons le panneau de
désactivation des lettres en utilisant la première lettre de
Word et la dernière lettre de Word Nous sommes maintenant le panneau que nous avons
créé à partir de cette méthode. À l'étape suivante, nous avons besoin d'une
méthode qui nous permettra de vérifier si lettre
sélectionnée est présente
dans le mot généré. Par exemple, lorsque nous sélectionnons une lettre
dans le panneau des lettres, nous devons vérifier si elle est présente ou non dans le mot
généré. Sur cette base,
nous allons faire quelque chose. Configurons donc une valeur de bleen, car
la lettre trouvée par défaut sera fausse et répétons
sur le mot généré Nous devons obtenir la lettre
actuelle partir du
mot généré Garrat of I. Et nous devons vérifier si
la lettre actuelle correspond à
la lettre que nous avons sélectionnée Et si c'est le cas, nous invoquerons la
liste de mots générée si
je définis la
valeur de la chaîne de texte de la lettre. Nous allons donc exposer la lettre
sélectionnée puisqu'elle se trouve dans
le mot généré. Ainsi, la lettre sélectionnée
sera exposée à l'utilisateur, simulant le fait qu'il
a pu trouver la lettre Et puisque l'utilisateur a
pu trouver la lettre, vous êtes
peut-être sur le fait que le
mot entier a été trouvé. Donc, si la lettre a été
trouvée, il ne faut pas
oublier de modifier le. Donc, si la lettre a été trouvée, nous aurons également besoin d'une méthode de vérification mot
terminé pour voir si toutes les lettres du
mot généré étaient f. Implémentons cette méthode
terminée, une méthode simple. Faisons donc vérifier dans le
commentaire si toutes les lettres du
mot ont été trouvées. Il s'agit donc d'une méthode privée, vérifiez
le mot terminé,
et nous aurons besoin de mécanismes pour
déterminer si toutes
les lettres du
mot ont été trouvées. Et pour ce faire, si nous avons au moins un de symboles
qui simulent que la lettre n'est pas
montrée à l'utilisateur, cela signifie que le mot n'
est pas terminé. Faisons donc une recherche
sur le nombre de lettres avec ce symbole que nous avons dans
le mot généré restant. Donc, le nombre de lettres
trouvées sera extrait de la liste de mots
générée. Nous allons faire un filtre, et pour chaque bouton, nous vérifierons que le texte du bouton est égal au
symbole en question. Et si le nombre de lettres
trouvé est supérieur à zéro, cela signifie que le mot n'
est pas terminé. Mais en fait,
changeons cette variable en nombre de lettres introuvables, car elle est plus descriptive. Et si toutes les
lettres ont été retrouvées, nous reviendrons vrais. en revenir à cette déclaration, si les lettres sont
trouvées et que le mot est terminé, nous devrons invoquer le panneau des lettres et
obtenir la carte des lettres, et pour chaque lettre
de la carte des lettres, rappelez-vous que les clés sont chaînes et que les valeurs
sont des motifs en G. Pour chaque bouton, il sera
désactivé afin que l'utilisateur ne
puisse plus cliquer sur aucun bouton
du panneau. Nous devrions également afficher un message contextuel en utilisant
l' épingle d'option G, afficher le dialogue des
messages. Et informons l'
utilisateur qu'il a pu trouver le mot dans ce cas,
et félicitons-le Et passons à l'
affaire S, si la lettre est trouvée. Ce n'est pas vrai. L'utilisateur n'a pas pu
identifier une lettre. Nous devons simuler cela dans
l'interface utilisateur graphique. Si vous vous souvenez de la
liste des images, nous devons mettre à jour une
référence d'image de smile à set. Pour ce faire, nous utiliserons
le panneau d'images. Et sur le panneau des images, nous avons besoin d'une référence
à la liste des images. Nous devons donc créer la méthode getter pour cela
sous le panneau des images Pour faire référence une
fois de plus à ces cinq images qui sont utilisées pour simuler cinq tentatives
possibles l'utilisateur pour deviner
le mot entier. Cela renverra
la liste des images. Ajoutons également une
méthode setter pour cela. Définissez la liste d'images, que nous
recevions une étiquette de liste OJ, et cette liste d'images
est égale à une liste d'images. Pour en revenir au panneau de mots, nous avons maintenant accès
à la liste des images. Et nous allons obtenir la tentative
actuelle. N'oubliez pas que le
nombre de tentatives est nul lorsque nous démarrons le jeu
et que nous allons définir l'icône. En fait, changez
l'icône d' une image de sourire par défaut
en une image triste. Nous allons également augmenter le
nombre de tentatives. Et comme nous augmentons
le nombre de tentatives, nous devons également vérifier si nous avons atteint le nombre maximum de tentatives
autorisées. Dans ce cas, le nombre
maximum de tentatives est égal au panneau d'images,
obtenez
la taille de la liste d'images. Dans notre cas, cinq. Si tel est le cas, nous allons parcourir les lettres
du panneau des lettres, en utilisant la même approche que celle
décrite précédemment, et nous désactiverons tous les
boutons
afin de permettre à l'utilisateur de
cliquer sur n'importe quel bouton restant, et nous informerons également l'utilisateur qu'il n'a pas pu
trouver le mot Ce qui signifie qu'il a perdu la partie. Le mot a été généré. Jusqu'ici, tout va bien. Ça a l'air bien. Si vous vous souvenez, nous avons mis en place
ici une méthode de lettre de chèque, mais nous ne l'appelons pas vraiment. Mais nous avons un écouteur d'action
pour chacun de nos boutons,
et maintenant, sous l'écouteur de
boutons, nous devons invoquer cette méthode de lettre de
contrôle en utilisant la classe de contexte que
nous avons définie précédemment Nous devons donc obtenir l'
instance du panneau de mots, puisque vous voyez que l'écouteur de
boutons n'est pas un composant ressort
et que le panneau de mots est un composant de ressort et qu'en utilisant
la classe de contexte Spring, nous pourrons
invoquer correctement la méthode depuis
le panneau de mots en utilisant
cet écouteur de boutons Vous voyez donc le panneau de mots, lettre de
vérification ou lettre. présent, nous pourrons également
invoquer les bacs correspondant au ressort à invoquer les bacs correspondant au ressort partir d'un composant qui
n'est pas associé
au conteneur à ressort. La dernière étape consistera à
câbler automatiquement le panneau de mots sous le cadre manuel et à l'ajouter dans le panneau principal
sous la section nord Faisons-le.
Démarrons également l'application dès maintenant. Nous sauvegardons le panneau de mots. Et vous voyez, par défaut, tous les panneaux sont en place
avec le mot de jeu par défaut. Vous voyez que des tentatives sont en
place à partir d'une image de sourire, l'image se trouve dans
le panneau des images. Oh.
8. Essayer à nouveau ?: Nous avons le jeu en place, mais il semble que nous
n'ayons aucune option pour le régénérer
une fois que nous l' avons terminé avec
succès ou échec Travaillons donc là-dessus. Nous devons travailler sur les panneaux, et pour le panneau vide, nous n'avons rien à faire puisqu'il s'agit simplement d'un panneau vide. Mais à partir
du panneau des images, nous devons créer un moyen de régénérer les composants de
l'écran Mettons donc en place une méthode simple, une méthode publique void clear. Et selon cette méthode, nous allons d'abord supprimer
tous les composants du panneau d'images, puis réinvoquer la méthode de création de panneau
qui
créera essentiellement tous les composants et
les ajoutera au Suivons la même chose
pour le panneau des lettres. Public Void efface cette suppression, et réinvoquons la méthode de
création de panneau,
et il en va de même
pour le panneau Word vide public est clair, cette suppression et ce superbe panel. Nous avons donc maintenant besoin du
moyen d'
appeler réellement ces trois méthodes à
partir du panneau des images, du panneau des lettres et du panneau des mots. Passons au cadre du bourreau, et en bas, nous allons créer une méthode privée de suppression des panneaux
vides Si vous vous souvenez que le cadre andman fait référence à
tous nos panneaux, et nous invoquerons la méthode
claire pour le panneau t s, le panneau mots et le panneau d'image Et nous aurons également besoin de la méthode qui s'
appellera nouveau jeu. Selon cette méthode, nous allons d'abord disposer de la trame j actuelle. Nous devrons obtenir les
coordonnées x et y à partir de notre position
actuelle du cadre j, et nous devrons également
invoquer la
méthode clear panels afin d'effacer
et de régénérer les panneaux J. Une fois cela fait, nous allons définir l'emplacement de
notre cadre en J et le remettre en place
pour qu'il soit visible par
l'utilisateur, tous les panneaux étant régénérés
correctement Nous devons maintenant invoquer d'une manière ou d'une autre cette
nouvelle méthode de jeu Hanman Frame, et nous allons passer sous le panneau de mots et avoir une
instance, le handman Il s'agit d'un composant, il peut
donc être injecté. Nous avons donc deux emplacements où nous pouvons générer
ce nouveau jeu. Dans le cas où l'utilisateur a trouvé le mot et également dans le cas où l'utilisateur n'a pas pu
trouver le mot. Maintenant, tout devrait être en
place et nous avons la possibilité régénérer les composants essentiellement pour redémarrer le jeu Vous voyez que le jeu a été redémarré automatiquement
et que tous les panneaux ont été régénérés avec succès
9. Sauvegarder les mots: Dans cette vidéo,
j'aimerais
implémenter un mécanisme
qui nous permettra extraire des mots aléatoires
d'une base
de données au lieu d'utiliser le
mot du jeu par défaut à chaque fois. Donc, dans un premier temps, nous devons passer sous POM point XML. Et ici, nous devons ajouter quelques dépendances spécifiques.
La première dépendance aura l'ID de groupe
pork spring framework. Ça a mis. Pour l'ID d'artefact, lancez GPA, et maintenant,
pour
la deuxième dépendance, nous aurons l'ID de groupe Pour l'identifiant de l'artefact, nous devons configurer le connecteur M
squeal Java Puisque cette
dépendance est en place, nous devrons utiliser package du modèle de jeu
Como Hangman et créer une classe simple, et appelons-la Word Cette classe agira comme une entité GPA et nous
permettra d'interagir
avec la base Disons-le donc
avec l'entité. Veillez à utiliser le package d'entités Java
Persistence. Ajoutons également le
nom de la table sous forme de mots. Nous devons maintenant configurer une variable spécifique
qui servira clé primaire pour
notre table de mots. Nous l'avons donc annoté avec l'
ID et la valeur générée. Nous utiliserons le type de génération
str comme identité. Alors faisons-le. Ajoutons maintenant une variable privée à identifiant long. Je voudrais également
configurer une valeur de chaîne privée. Mais d'abord, il faut le faire avec
la colonne n 16 et ainsi de suite. Nous allons maintenant ajouter le constructeur
public, un constructeur par défaut, qui
est requis pour les entités GPA Utilisons l'ID pour
générer les getters et les
setters pour notre champ de valeur L'étape suivante consiste à créer un référentiel de
mots correspondant. Cela est donc lié à
notre GPA de données de printemps. Cela doit être annoté avec le stéréotype du référentiel Et bien entendu, cela devrait
étendre le référentiel JPA. Et en tant que paramètres, nous
devons définir la classe du modèle et le type de
clé primaire dans notre cas. Pour la classe de modèle,
de, la classe de mots. La prochaine étape sera
de créer un service pour notre interaction avec la logique métier
et notre entité GPA Appelons donc ce
service Word service,
et configurons-le dans le cadre du package de service de jeu C
Han Man. Nous allons le transformer en interface, et nous allons définir deux méthodes. On y stockera
une liste de mots dans la base de données lors de la première
exécution de l'application. Une autre méthode consiste à extraire le mot aléatoire de la base. Nous aurons besoin d'une implémentation
de classe concrète pour réellement implémenter
ces méthodes. J'ai créé le service Word MPL et annoté avec le numéro de série du
service. Et cette classe implémente
le mot interface de service. Ajoutons également une méthode
non implémentée jusqu'à présent. Et injectons également
le référentiel Word. Pour la liste des mots, je vous ai déjà
préparé une liste d'un mot qui sera
stocké dans la base de données. Vous pouvez donc simplement le copier-coller sans le noter. Vous voyez, il y a beaucoup de mots avec
lesquels vous pouvez jouer. Et nous avons besoin du mécanisme pour réellement stocker cette
liste de mots. Dans le cadre de la méthode de base de données sécurisée, nous vérifierons d'abord si la
méthode Word Repository Count renvoie zéro. Cela signifie qu'
aucun mot n' est enregistré jusqu'à
présent dans la base de données. Nous allons diviser la liste de mots
en un tableau séparé par co. Et nous allons répéter ce tableau de mots Et enregistrez chaque mot dans la base de données à l'aide de la méthode de sauvegarde
du référentiel de mots. Pour cela, créons un constructeur simple qui reçoit la valeur en paramètre Cette valeur est égale à la valeur et
cela devrait résoudre notre problème. Nous allons enregistrer un mot directement dans la base de données
relationnelle Muscular Passons maintenant à la méthode
get random word. Pour cela, allons dans
le référentiel et
configurons une méthode spécifique. Cela renverra un mot, appelons-le
trouver un mot aléatoire, et nous utiliserons la
notation spécifique et le sélectionnerons. Appelons notre base de données hangman, puisque le jeu est hangman, et invoquons les
mots andman classés par rand,
limite un, et la requête native
doit être définie Cela extraira
un mot aléatoire de notre base de données andman que nous
configurerons ultérieurement et
du mot sable
que nous avons configuré précédemment dans le mot classe de modèle
correspondant Pour en revenir au service de
mots MPL, utilisons
la méthode nouvellement
créée à partir du référentiel de mots Donc, dans le référentiel Word,
trouvez un mot aléatoire et récupérons
la valeur de la chaîne en utilisant la méthode get value. Maintenant que nous avons mis en place ces
deux méthodes, nous aurons besoin d'un moyen de les invoquer
réellement. Pour la première méthode,
passons à l'application du jeu, et c'est ici que l'
application démarrera. Nous allons d'abord injecter le service correspondant à l'aide
de l'annotation automatique du câblage. Bien entendu, en utilisant la méthode
post construct, Spring invoquera automatiquement cette méthode et à ce stade, enregistrons dans un appel DV
à partir du mot service De cette façon, tous les mots
seront enregistrés dans la base de données. Maintenant, nous avons besoin du moyen d'invoquer cette méthode d'obtention de mots
aléatoires. Et si vous vous
souvenez bien, dans le panneau de mots, nous avons défini par défaut ce jeu
comme étant le mot généré, et nous devons changer cela. Câblons automatiquement le
mot instance de service. Et au lieu d'utiliser le texte du
jeu ici, utilisons la méthode Word Service, get random word. Ainsi, chaque fois
que nous générerons ce panneau, un nouveau mot sera
extrait de la base de données. Maintenant, une étape importante consiste à
définir des propriétés spécifiques dans notre fichier de
propriétés d'application afin que Spring puisse
communiquer avec
la base de données mSw Nous allons donc définir le nom de classe du pilote de
source de données Spring comme le nom de classe correspondant
à l'instance Muscular. Nous devons définir l'URL des données de
printemps. Cette URL correspond à l'
instance Muscular que nous avons configurée localement et se connecte à une base de données
Hangman que nous créons. Pour le nom d'utilisateur de la source de
données Spring,
le nom d'utilisateur de l'
instance Mice défini sur root et le
mot de passe sur password Bien entendu, cela
dépend de votre instance Mcal. Nous montrerons les SQL générés dans
les journaux,
et nous utiliserons la mise à jour
automatique DDL en termes de modifications possibles
qui seront dues au stockage automatique de la classe de modèles de
mots l'
instance correspondante Définissons maintenant le dialecte mSQEL. Dialecte d'Org Hibernate. Commençons le fichier, MQ est égal à 57 dialecte Maintenant, je suis allé sur mon instance
Miquel et tout ce que vous avez à faire est créer une base de données simple
appelée Hand Man une seule fois Démarrons l'application. Ou regardons les journaux. Vous voyez que tous les mots
sont insérés. Ce processus
ne se produit qu'une seule fois, et vous voyez que nous avons déjà un mot aléatoire
extrait de la base de données dans l'interface utilisateur
graphique. Nous pouvons également vérifier le fait que tous les mots
ont été
insérés dans la base de données à l'aide d'un
décompte tiré de la table des mots. Et tu ne vois qu'un seul mot. Et maintenant, le jeu fonctionne
beaucoup plus facilement en termes de capacité à générer des mots
aléatoires à chaque fois. Vous voyez des mots longs , des mots
courts, etc.
10. Ajouter un menu: Dans cette vidéo, j'
aimerais ajouter l'option permettant de fournir un menu pour notre interface utilisateur
graphique. Fermons l'
instance actuelle de l'application et passons au menu Cohen
Man game Guy. Créons une
classe simple appelée menu. Ce cours sera et avec le stéréotype du composant
Spring Devrait étendre la barre de menu J. Il s'agit d'un composant d'
un package Javac Swing. Maintenant, je dois
câbler automatiquement le cadre du handman. Composant principal. Réglons ça et éliminons les comètes. Ou créez un constructeur
pour notre classe de menu. Ensuite, nous allons configurer la méthode de création de menu sur
place Sous notre constructeur, appelons cette méthode de
création de menu Selon cette méthode nouvellement créée, nous allons d'abord définir le menu G
appelé menu Options, et nous allons stocker les chaînes d'
options. Chaîne d'options à côté. Créons maintenant quelques éléments de menu
simples qui seront ajoutés
au menu des options. Pour la première option. Nous aurons la possibilité de
générer le mot, et pour la deuxième option, nous aurons le cas d'utilisation
pour quitter l'application. Il s'agit d'une autre façon d'
appuyer sur le motif en X. Maintenant, j'aimerais ajouter également des auditeurs
clés à nos éléments de menu Control plus n pour
la nouvelle option de jeu et Control plus E
pour l'option de sortie. Faisons-le. Première option, nous devons invoquer
l'accélérateur défini. Et en tant que paramètre, nous devons
définir la touche et obtenir la touche et touche d'événement
clé et n,
et nous devons ajouter l'
événement d'action en tant que masque de contrôle Il en va de même pour la
deuxième option de notre menu. Réglez l'accélérateur, nous utiliserons
toujours la touche, et maintenant nous utiliserons l'événement clé avec le
E et l'événement action, pareil, le masque de contrôle. Nous devons mettre en œuvre la logique
commerciale de nos options. Nous allons ajouter des écouteurs d'action
pour les deux. Donc, pour la première option
ou le monde généré, nous devrons implémenter
la
méthode d'exécution d'action et recevoir
un événement d'action E. Et ici, nous utilisons
l'instance
du jeu Hand maan et
invoquons le nouveau jeu Pour la deuxième option, nous allons
ajouter un écouteur d'action. Même signature de méthode,
action exécutée, événement
d'action E en paramètre, et cette fois nous
dépasserons l'application. Nous devons maintenant ajouter
l' option 1 et l'option
2 au menu des options. Et ajoutez ce menu d'options
au composant principal du menu j étendu par
cette classe. Pour
utiliser correctement ce menu, nous devons l'injecter
sous le cadre pour hommes. Faisons-le. Nous devons d' abord
utiliser la notation câblée
automatique, le menu
privé, puisque notre
classe est appelée de cette façon. Et ici, nous allons invoquer
cette barre de menu set J, et pour le paramètre,
nous allons utiliser le menu. Nous allons maintenant lancer
l'application. Et vous pouvez voir que
les menus d'options présentent deux options
différentes, générer un mot et quitter, j'ai appuyé sur le bouton générer un mot. Un nouveau mot a été généré, et vous avez également la
possibilité d'utiliser des touches. Utilisons-les pour
l'option de sortie.