Transcription
1. Introduction: Bonjour.
Bienvenue dans mon cours sur Java. Maintenant, si vous cliquez sur ce cours, vous avez probablement au moins
une vague idée de ce qu'
est Java et cela est important pour votre carrière et
votre formation. Eh bien, tu ne te trompes pas.
Permettez-moi de vous montrer en quoi Java est l'un des langages de
programmation les plus populaires ,
utilisé par presque
toutes les entreprises technologiques. La utilisé par presque
toutes les entreprises technologiques page des carrières de
presque toutes les
entreprises technologiques citera Java comme
l'une des compétences. Savoir programmer est
la compétence qui
vous permet d'obtenir rapidement
un salaire très généreux. La raison en est que Java est
performant, riche en fonctionnalités et relativement facile à
maîtriser par rapport à d'
autres langages
tels que le C. Cela signifie
également que vous pouvez apprendre à programmer sans
passer par un cours d'une semaine. Les bases de Java peuvent être distillées en quelques heures seulement, c'est
ce que j'ai
fait dans ce cours Vous utiliserez les leçons
de ce cours pour créer votre propre
jeu interactif que vous pourrez ensuite partager avec vos amis
ou mettre sur votre CV. Les recruteurs
recherchent notamment des projets personnels
vérifiables, et celui-ci convient parfaitement Vous pouvez choisir de réaliser
l'ensemble du projet vous-même si vous
voulez relever un défi. Sinon,
j'ai également inclus quatre vidéos de présentation. Je t'aide au
cas où tu te perdrais. J'ai également configuré
tous les exemples de code dans un environnement sandbox en ligne.
Maintenant, qu'est-ce que cela signifie ? Cela signifie qu'il n'y a pas
besoin d'ordinateurs complexes. Aucune instruction de configuration obscure. Tout ce que vous avez à faire
est de visiter les liens que je fournis et de cliquer sur
le bouton vert Exécuter. Vous pouvez consacrer toute votre
énergie à vous concentrer sur le codage proprement dit au lieu de
perdre du temps à configurer
un environnement de codage. J'espère que vous avez
hâte de découvrir Java. Je passe beaucoup de temps à préparer
ce cours et
j'espère que cela se reflétera. Je vous verrai dans la prochaine vidéo.
2. À propos de vous et de moi: Bonjour. Dans cette vidéo, nous allons
parler brièvement du public cible de ce cours,
ainsi que des raisons
pour lesquelles vous devriez
choisir ce cours parmi tous les cours disponibles que vous trouverez probablement sur le marché. Alors tout d'abord, pourquoi
devriez-vous me faire confiance ? Tu ne me connais même pas bien. Je travaille pour l'une des
plus grandes entreprises technologiques
au monde,
actuellement basée Cupertino, Je n'ai pas vraiment le
droit de dire pour qui je travaille. Mais il suffit de dire que ce code
publicitaire a eu un impact sur l'expérience utilisateur
de millions de personnes,
peut-être même J'ai beaucoup d'expérience dans l'
écriture de code important. Avant de travailler dans
le secteur de la technologie, j'ai enseigné l'informatique
au
premier cycle à l'université de Californie Berkeley pendant quatre ans Le cours que j'ai enseigné C 61 a été désigné comme l'un des cinq
meilleurs cours aux États-Unis
par Bloomberg et accueille régulièrement plus de 2 000
étudiants par semestre. J'ai également enregistré des
vidéos Youtube pour ce cours sur la chaîne
CS 61, une chaîne départementale En août 2023, cette chaîne avait été visionnée
plus de 963 000 fois Enfin, en 2020,
j'ai été nommé parmi
les 13 meilleurs professeurs du département
d'ingénierie de l'université. Parmi plusieurs
centaines, j'ai beaucoup d' expérience dans
l'enseignement et
la gestion de grandes classes, en particulier celles qui
comportent une composante
en ligne importante comme celle-ci. Maintenant, pourquoi devrait-il
choisir ce cours ? Eh bien, j'y ai fait allusion
dans une vidéo précédente, mais l'un des
principaux avantages de ce cours est que tout le code est
public et exécutable Maintenant, vous ne comprenez peut-être pas ce que cela signifie ou
pourquoi c'est important, et c'est tout à fait raisonnable. En fait, un problème
qui se produit souvent dans cours de
programmation
est que même si vous prenez le code du professeur exactement tel qu'il est et que vous le mettez
dans votre ordinateur, vous risquez de ne pas obtenir
le même résultat ou peut-être que le code
ne s'exécute même pas. La raison en est que les ordinateurs
sont des machines très complexes. arrive souvent que votre ordinateur ne
soit pas configuré exactement de
la même manière que l'
ordinateur du professeur. Dans ce cours, tout le code a été déplacé vers un environnement
en ligne, y compris le code du projet. Toute la configuration du codage
a été résumée pour vous et
prise en charge afin que
vous puissiez concentrer toute votre énergie sur
la programmation au lieu de
configurer votre ordinateur Si vous souhaitez suivre ce cours de
manière interactive, je vous recommande de créer
un compte chez Repl Je mettrai un lien dans
la description du cours ainsi que dans les ressources. Ensuite, je voudrais
parler brièvement du public visé par
le discours. Maintenant, ne vous inquiétez pas
par cette déclaration. Même si vous n'avez aucune
expérience en codage, vous devriez pouvoir
tirer le meilleur parti de ce cours. Cela étant dit, si vous
voulez vraiment aborder toutes vos bases et vous
assurer de comprendre toute la syntaxe
Java de bas en haut, je vous recommande de
consulter mon autre cours, Java for Beginners
Code en 1 heure. Ce cours vous
apprendra quelques détails sur la programmation Cependant, vous n'avez pas besoin de
tout connaître de ce cours pour comprendre les choses
de ce cours. Ce que je vous recommande de faire, c'est de
regarder quelques vidéos de ce cours et de voir si vous comprenez l'importance
de ce que je dis. S'il s'avère que vous
ne comprenez rien, je vous recommande de faire une pause. Regardez quelques vidéos
du cours que j'ai filmé plus tôt et revenez à ce
cours lorsque vous serez prêt. Et c'est tout pour cette vidéo. La prochaine fois que vous me verrez,
nous aborderons
du contenu réel.
3. Introduction du projet: Bienvenue, mes amis. Dans cette
vidéo, nous allons parler du projet
que vous allez mettre en œuvre
tout au long de ce cours. Le projet que nous allons
mettre en œuvre s' appelle Minesweeper N'hésitez pas à
le rechercher sur Google car c'est un jeu assez populaire et qui n'est
pas exclusif à cette classe. Même si vous
connaissez déjà le jeu, je vous recommande de
regarder cette vidéo afin comprendre notre implémentation
spécifique. Le code du
projet qui vous sera fourni est
partiellement terminé, mais il manque quelques éléments
importants. Votre objectif sera de corriger ces
composants essentiels pour le jeu
fonctionne comme dans cette vidéo. Nous passerons en revue
ces éléments
ensemble
ultérieurement dans le cours afin que vous ne vous perdiez pas. À la fin du projet, vous devriez pouvoir jouer au jeu de manière interactive et
inviter vos amis et votre famille à y jouer également Voyons maintenant comment fonctionne
ce jeu. Allons-y et cliquons sur
Run our game of Mind. Sweeper commence par un tableau de dix par
dix de cellules inexploitées. Toutes ces cellules, marquées X sont des cellules qui
n'ont pas encore été révélées. Ces cases, écrites de A à J sur les
bords du tableau, vous
aident à identifier
les coordonnées d'une cellule Nos coordonnées figureront dans
la colonne de lignes du formulaire. Par exemple, cette
cellule
aura des coordonnées
parce qu'elle se trouve dans A.
Dans la colonne B, toutes les cellules
sont soit des cellules numériques, soit cellules
vides, soit des cellules de mine, mais leur état est
actuellement masqué par le X. Si vous tapez sur une cellule qui est une cellule de mine, vous perdez la partie. L'objectif du jeu est
de trouver toutes les cellules non minières. Voyons ce qui se passe
lorsque nous appuyons sur une cellule. Nous pouvons appuyer sur B, d'accord ? B s'est révélé
être une cellule vide, ce que nous pouvons voir parce que,
eh bien, elle est vide. Une cellule vide est une cellule qui n'a aucune mine juste à
côté. Cela signifie que la cellule A, la cellule B, la cellule
A, la cellule AC, la cellule BC et la cellule BB n'étaient pas toutes des miennes. Cela signifie qu'
ils pouvaient tous être utilisés en toute sécurité. Notez
qu'après avoir enregistré la cellule B, un tas d'autres cellules ont
également été révélées Tout cela ici,
toutes ces cellules vides ainsi que ces
cellules numériques ici. Nous le faisons parce que,
comme je viens de le dire, une cellule vide signifie que toutes les cellules adjacentes à cette cellule
vide peuvent être touchées en toute sécurité. Nous les appuyons simplement pour
que vous gagniez du temps. Si nous trouvons une cellule vide
supplémentaire à
côté de la cellule
vide d'origine que nous avons collée, nous utilisons
également toutes les cellules sûres autour de cette cellule Et nous poursuivons
ce processus jusqu'à ce que nous n'ayons plus de cellules sûres à exploiter. Jetons un coup d'œil à
cette cellule par exemple. Cette cellule s'est
révélée être une cellule numérique. Le chiffre deux signifie
qu'il y a exactement deux cellules de mine
immédiatement adjacentes. Cela signifie que ces cellules sont toutes potentiellement des cellules minières. Celui-ci est également
potentiellement une cellule de mine. Comment savoir
lequel est sûr ou non ? C'est le cœur du jeu
de déminage. Nous devons combiner les
informations provenant d'autres cellules afin de déduire des
informations pour cette cellule Voici une façon de déduire
quelle cellule est une cellule de mine. Jetons un coup d'œil à
cette cellule ici. Cette cellule s'est également
révélée être une, mais comme les cellules qui l'entourent se
sont déjà révélées
être des cellules vides,
il sont déjà révélées
être des cellules vides, s'est avéré qu'il
s'agissait d'une cellule numérique et qu'
il s'agissait d'une cellule numérique. Il ne reste
qu'une cellule adjacente à celle-ci. Par conséquent, cette cellule non révélée doit être la
cellule de la mine. Comme nous ne
voulons pas appuyer sur une mine, nous allons signaler la cellule
comme étant dangereuse afin
de ne pas appuyer dessus. Nous pouvons voir que ce
X se trouve dans ligne et la colonne H.
Nous pouvons utiliser le drapeau F,
H. Ce symbole triangulaire
nous
indiquera que la cellule
est marquée et que nous savons qu'il ne faut H. Ce symbole triangulaire nous
indiquera que la cellule
est marquée pas appuyer dessus Maintenant que nous savons que
cette cellule est une cellule de mine, nous savons que cette cellule sera sûre.
Pourquoi ? Mettez la vidéo en pause et je
révélerai la réponse en 321. La raison en est que cette
cellule numérique ici est une. Nous en avons déjà déduit que c'était une cellule dangereuse à cause de
ce numéro un ici Par conséquent, comme nous
avons déjà trouvé la cellule adjacente à cette
cellule numérique qui est la mienne, nous savons que toutes les
autres cellules autour ce numéro un pourront
être touchées en toute sécurité. Allons-y et
testons notre hypothèse. Allons-y et tapons sur I. En effet, nous constatons que
je suis une cellule numérique, c'
est-à-dire trois que l'
on peut taper en toute sécurité. Bien qu'il y ait encore de nombreuses
mines
dans cette zone, dans la grande majorité des cas, vous pourrez poursuivre
ce processus d'inférence pour l'ensemble du conseil et éventuellement identifier l'emplacement de toutes
les mines Si vous pensez avoir commis une erreur, vous pouvez également désignaler
la cellule de cette manière Maintenant, H a été réinitialisé sur
une cellule non révélée à des fins
de démonstration. Voyons ce qui se passe si
vous tapez sur cette cellule de mine. Ces astérisques
représentent les esprits notre tableau et nous pouvons voir que
la partie est maintenant terminée Redémarrons le jeu
en cliquant sur le bouton Exécuter. Je vais maintenant parcourir tableau suivant très rapidement pour que vous puissiez voir le résultat final. N'hésitez pas à regarder cette vidéo très lentement si vous
voulez suivre et voir si vous pouvez
déterminer pourquoi j'ai décidé de signaler ou de
toucher certaines cellules. Enfin, nous pouvons constater que nous avons exploité toutes les cellules non minières Nous avons gagné le match au total. Chaque jeu doit
comporter dix cellules de mine. OK, et
c'est tout pour cette vidéo. J'espère que cela vous donne envie
de participer au projet. Je passe beaucoup de temps à le
préparer pour vous et j'espère que vous en avez appris
beaucoup sur Java en le faisant. Je vous verrai dans la prochaine vidéo.
4. Illustration d'héritage: Bienvenue, mes amis. Dans cette vidéo, nous allons
parler de l'héritage. Pour rendre cette leçon
un peu moins sèche, nous allons
parler de crème glacée. C'est de la crème glacée. Imaginez maintenant que vous
avez un ami qui
n'a jamais entendu parler de crème glacée et que vous vous
demandiez de le lui décrire. Chaque unité de crème glacée présente un certain nombre
de caractéristiques communes. Pour l'instant, nous allons simplifier
et il est assez
prudent de dire que chaque unité de crème
glacée contient de la crème. Une température d'environ 0 degrés Celsius et un cône pour contenir la crème. Imaginez maintenant que vous avez fini décrire la crème glacée à
votre ami imaginaire. Mais maintenant, il s'intéresse aux
différents types de glaces,
comme la crème glacée à la fraise
et la crème glacée aux myrtilles Vous le
décririez probablement de la même manière que vous décrivez la
crème glacée originale ici. Ces nouvelles saveurs ont également un cône et une température
d'environ 0 degrés Celsius. La seule différence est que la crème glacée à la fraise contient de la crème aromatisée à la
fraise
et la crème glacée aux myrtilles de la crème
aromatisée aux myrtilles Tout cela est parfait
pour cet exemple en particulier. Si nous n'avons que trois attributs
pour décrire la crème glacée, cela ne fait pas de mal de
nous répéter pour chacun, mais vous pouvez imaginer
que nous voudrions peut-être
ajouter encore plus de traits pour
décrire cette crème glacée. Peut-être voulons-nous également ajouter
un attribut de saveur de cône ou une texture de cône. Ou peut-être le poids
de la glace, ou le volume de la crème glacée. Vous pouvez obtenir une
description infiniment plus détaillée de la crème glacée. Et chaque fois que votre ami
vous demandait de décrire une nouvelle crème glacée
aromatisée, vous deviez
redéfinir
chacune de ces caractéristiques
encore et encore Ce serait vraiment bien si nous
trouvions un moyen de réduire
la quantité de travail à effectuer pour décrire les
nouvelles saveurs de crème glacée. C'est là que l'héritage
intervient naturellement. À un moment donné,
vous en aurez assez de décrire les mêmes
caractéristiques pour la crème glacée. Au lieu de répéter que la crème
glacée a un cône et une température de 0 °C,
vous dites à votre ami que la crème glacée aux myrtilles est
comme la crème glacée ordinaire, sauf que la crème
a une saveur différente, tout le reste est pareil L'héritage est un paradigme en Java qui nous permet de le faire. L'héritage signifie que
les comportements et les attributs d' un modèle de base sont copiés dans
un modèle plus récent et mis à jour. Nous avons toujours la
possibilité de remplacer certains attributs tels que l'arôme de la
crème dans ce cas C'est donc génial maintenant Au lieu de
nous répéter et de redéfinir chaque attribut de crème glacée lorsque nous définissons un nouvel arôme de crème
glacée, suffit de
remplacer un attribut,
l'attribut de saveur de crème, et d'hériter du reste des attributs partagés
du modèle de
crème glacée de base, comme la température
et le cône Cela semble très simple, mais c'est un
principe très important de la programmation Java La réduction du code répétitif
est très utile pour récapituler. L'héritage
nous permet de maximiser le code, réutiliser et de le simplifier. je vais vous montrer quelques
exemples concrets de ce à quoi cela prochaine vidéo, je vais vous montrer quelques
exemples concrets de ce à quoi cela
ressemble
dans le code.
5. Exemples d'héritage: Bonjour les amis. Dans cette vidéo, nous allons discuter de quelques exemples concrets d'
héritage. abord, imaginez que nous ayons une classe appelée dog et disons qu'elle possède un champ
statique appelé sound et une méthode get appelée
get Sound qui récupère le son au cas où vous oublieriez ou ne
connaîtriez pas la syntaxe Je vous recommande de mettre
la vidéo en pause maintenant et de regarder la vidéo intitulée Objects
part Two dans mon autre cours, Java, pour débutants en 1 heure. Nous avons maintenant une autre
classe appelée Brown Dog, qui étend la classe des chiens. Cette syntaxe d'extension est nouvelle. C'est ainsi que nous définissons les modèles d'
héritage en Java. Dans ce cas, on dirait que le chien brun hérite du chien Ne vous inquiétez pas des
conséquences que cela pourrait avoir pour le moment. Reconnaissez simplement Dysntex. Supposons maintenant que le chien brun ait une méthode appelée get color, qui renvoie simplement
le mot brun. Maintenant, mettons tout cela ensemble. Nous avons le cours pour chiens
d'antan et nous avons le cours pour chiens bruns qui
étend les chiens à notre classe principale. Créons une instance de la classe dog et une instance
de la classe brown dog. Ainsi, si nous imprimons dog get sound et brown
dog getcolor, le résultat est assez
prévisible. Les chiens reçoivent du son. Nous allons juste imprimer aboiement
et Brown Dog GetColor, nous allons imprimer Brown Word La magie opère quand
on fait du doggetund brun. Sur la base de ce que nous savons jusqu'à
présent de la programmation Java, cela semble
voué à l'échec, n'est-ce pas ? Comme la classe Brown Dog ne propose pas de méthode
get sound, cela semble être une supposition
raisonnable. Il s'avère que
si vous l'exécutez,
cette dernière instruction imprimera
en fait des aboiements. La raison en est que nous avons héritage lorsqu'une
classe en étend une autre, Java va d'abord regarder dans
la classe étendue et voir si une méthode ou un champ est
défini si ce n'est pas le cas. Java vérifie ensuite
sa classe parent. Dans ce cas, nous vérifions d'abord Brown Dog pour la méthode
get sound. Il n'a pas cette méthode, nous vérifions
donc que la classe
parent dog dog utilise la méthode get sound. Utilisez cette méthode
qui renvoie l'aboiement. Je tiens à souligner
ici que Java utilisera en premier lieu la
méthode la plus spécifique qu'il trouvera. N'oubliez pas que Java
regarde d'
abord dans le chien brun pour obtenir du son
avant de regarder dans le chien. Cela signifie que si Brown Dog avait une méthode get sound qui
renvoie quelque chose
de différent de la méthode dog get sound nous appelons Brown
Dog
Get Sound. Java aurait plutôt utilisé
la méthode get sound définie dans brown dog. C'était une bouchée.
Si vous regardez vitesse de
1,5 ou deux fois
et que vous n'avez pas compris, je vous recommande de revenir en arrière de 30 secondes et d'écouter
à nouveau cette phrase Sur une vitesse X, c'est la fin de notre discussion
sur l'héritage. Pour récapituler, nous utilisons le mot clé
extends pour
indiquer à Java que nous souhaitons
créer une
relation d'héritage Une fois la relation d'héritage
établie, Java utilise la résolution dynamique des
méthodes pour déterminer la
méthode à utiliser. Il examine d'abord
la classe à partir de laquelle
nous appelons la méthode. Et ce n'est que si la méthode est absente que Java recherche dans
la classe parent. Voici le lien vers
le code de répulsion, en utilisant cette leçon pour
que vous puissiez le modifier. Je vous verrai dans la prochaine vidéo.
6. Super exemples: Bienvenue, mes amis. Dans
cette vidéo, nous allons parler du super rappel de la
leçon précédente selon laquelle nous avions suivi un cours sur les chiens utilisant
la méthode get sound. Nous avions également une
classe de chiens bruns héritée
de Brown Dog qui avait
une méthode d'obtention de la couleur. Lorsque nous avons appelé brown
dog get sound, Brown dog a réutilisé la méthode get sound from
dog via héritage. Souvenez-vous également de l'ordre dans lequel Java résout les noms de méthodes. Si nous avons appelé Brown, vous aurez du son. Java rechercherait d'abord get sound dans la classe brown dog. Java n'apparaîtrait
dans la classe dog que si Brown Dog n'avait pas
obtenu Sound. Si brown dog avait
défini
une méthode get sound et que nous l'appelions
brown dog get sound, brown dogs get sound
remplacerait la
méthode get sound de la classe dog Cela signifie que nous
exécuterions la logique contenue dans Brown
Dog au lieu de Dog. Nous pouvons soit
réutiliser, soit remplacer les méthodes
de la classe parent Mais que se passe-t-il si nous voulons remplacer et réutiliser la logique
de la classe parent ? Voyons comment cela fonctionne. Tout d'abord, supposons que nous ayons à nouveau
notre classe pour chiens, méthode
get sound
qui renvoie des aboiements. Supposons maintenant que nous ayons notre classe de chiens
bruns qui hérite du chien et qui
possède également une méthode Get Sound Cette méthode contient un nouveau mot clé que nous n'avons jamais vu auparavant. Super. Super est la façon dont nous référençons la
classe parent de la classe actuelle. Dans ce cas, super est en fait
un alias pour la classe canine. Cela signifie que super
do get sound est analogue à «
dog get sound Ce qui signifie que le
son Super Get fera aboyer. Le résultat de toute cette méthode
brune de dog-tetsund sera une écorce C'est à peu près
ça. Nous avons découvert notre nouveau mot clé super, qui est utilisé pour faire référence
à une classe parent lorsque nous écrivons du code
dans la classe enfant. Ce mot clé nous permet également de créer des méthodes de remplacement hybrides C'est-à-dire que nous sommes capables de
réutiliser le code de la classe parent et d'ajouter notre
propre logique personnalisée. Voici le lien
vers le code de répulsion de cette leçon
que vous pourrez modifier. Je vous verrai dans la prochaine vidéo.
7. Polymorphisme de sous-type: Dans cette vidéo, nous allons
parler du polymorphisme des sous-types Avant de nous lancer, ne
vous laissez pas intimider par ces mots très
fantaisistes. Le concept n'est
en fait pas beaucoup plus compliqué que
tout ce que nous avons vu jusqu'
à présent, mais les concepteurs de Java mais les concepteurs de Java n'ont pas
pu trouver un nom plus simple. Encore une fois, commençons
notre illustration avec une classe de chiens dotée d' une méthode get sound
qui renvoie des aboiements. Nous aurons également une
classe de chiens bruns qui hérite du chien, et cette méthode pour chiens bruns
renvoie de l'écorce brune En mettant tout cela ensemble,
nous avons nos deux classes. Nous avons une troisième méthode get sound située
dans notre classe principale. Cette troisième méthode prend en compte une instance de chien et
appelle simplement que les chiens
obtiennent une méthode sonore. Si nous instancions une instance de la classe chien de base, puis que nous la
transmettons cette méthode comme
vous vous
en doutez, nous obtiendrons bark en sortie Mais maintenant, disons que nous instancions
une instance de brown dog et que nous
transmettons cet objet à
cette méthode get sound C'est étrange. La méthode get sound
ici en bas droite n'accepte que les
arguments de type
dog, mais le type d'objet que nous
transmettons est brown dog. D'après ce que nous savons de Java, cela semble
être une erreur, n'est-ce pas ? Il s'avère que cela ne
provoquera pas d'erreur. Cette ligne
imprimera en fait de l'écorce brune. Cela est dû à quelque chose en
Java appelé méthode dynamique. La résolution est un exemple
de polymorphisme de sous-type polymorphisme des sous-types
signifie essentiellement qu'un sous-type d'un type parent peut être
traité comme un type parent Intuitivement, cela
devrait avoir du sens. Un chien brun doit avoir toutes
les propriétés d'un chien. Un chihuahua brun doit avoir toutes les propriétés
d'un Une chose plus spécifique
devrait au moins avoir tous les comportements et traits d'une chose
apparentée moins spécifique. Pour en revenir à cet exemple, la raison pour laquelle nous pouvons passer un chien brun à
cette méthode qui accepte les types de chiens est que Java suppose des
types de chiens spécifiques pourra
appeler toutes les méthodes de la classe de chien de base lorsque le
programme sera réellement exécuté. Java résoudra ensuite les méthodes d'
instance en utilisant le type
dynamique d'un objet. est-à-dire le type selon
lequel un objet est en fait un chien brun et non
le type statique que nous déclarons être
dans cette méthode chien. Je le redis encore une fois parce que c'est un concept très important. Le type statique d'
un objet est ce que nous
déclarons explicitement comme tel. Dans cette méthode, c'est un chien brun. Dans cette méthode, le
type statique devient chien. Le type dynamique d'
un objet est ce qu' est réellement
et il ne change jamais. Dans ce cas, le
type dynamique est le chien brun. Pour résoudre une méthode d'instance, nous utilisons le
type dynamique de l'objet. Vous vous demandez peut-être
pourquoi nous faisons cela. Pourquoi diable nous
embrouillerions-nous ? Pourquoi ne pas simplement l'
appeler chien brun lorsque nous instancions et le
garder comme chien brun pour La raison pour laquelle nous
pourrions vouloir
réutiliser cette méthode pour
de nombreux types de chiens. Imaginez qu'en plus du cours sur
les chiens bruns, nous avions également des cours sur
les chiens blancs, les chiens bleus et les chiens jaunes, qui héritent tous du chien et qui utilisent toutes de
bonnes méthodes Ce serait vraiment
ennuyeux si nous devions définir une méthode qui prend un objet de type chien brun et autre méthode qui prend en
compte un objet de type chien blanc, chien jaune
et chien bleu. Lorsque toutes ces méthodes
font exactement la même chose, au lieu de nous répéter, nous créons simplement une méthode qui accepte le type
du chien modèle de base. En ayant un type d'entrée plus
général, nous pouvons maximiser la
réutilisation de notre code et n'avoir une seule méthode qui prend en charge tous les cas les plus spécifiques. C'est tout pour cette vidéo. Pour récapituler, nous avons parlé du polymorphisme des
sous-types. Il s'agit d'un paradigme Java
qui nous permet de traiter des instances spécifiques d'un objet comme un objet de base moins spécifique. Nous avons également parlé des types statiques
par rapport aux types dynamiques, qui dictent la manière dont nous
résolvons les méthodes d'instance Lorsque nous faisons référence à
une méthode d'instance, nous utilisons la méthode définie dans le type dynamique d'un objet
au lieu du type statique. Voici le lien
vers le code de répulsion de cette leçon
que vous pourrez modifier. Je vous verrai dans la prochaine vidéo.
8. Illustration abstraite: Bienvenue, mes amis. Dans cette vidéo, nous allons passer en revue un aperçu visuel des classes
abstraites. Dans cette illustration, nous allons en fait revenir à nos exemples de glaces tirés de la leçon d'
illustration de l'héritage. Rappelez-vous que nous avons un cours de
crème glacée et que nous avons également des cours crème glacée à la
fraise et crème glacée
aux myrtilles
qui héritent de la crème glacée Maintenant, si vous vous demandez à quoi
ressemblent ces trois cours dans la vraie vie ? Vous pouvez probablement vous faire une
idée de ce à quoi ressemble la crème
glacée aux fraises et aux myrtilles Plus ou moins, ils ressemblent à
ça. Ces cours
reflètent la réalité et sont ancrés dans des exemples
concrets. Mais qu'en est-il du cours
de crème glacée ? À quoi ressemble une crème
glacée non aromatisée ? Vous pensez peut-être à
la crème glacée à la vanille, mais même la vanille est une saveur. La crème glacée à la vanille serait également une sous-classe héritant
de la classe des crèmes glacées Mais la crème glacée
en elle-même, sans saveur, n'
existe pas, moins pas dans votre épicerie
locale. En Java, nous
modéliserions en fait cette
classe de crème glacée sous forme abstraite. Une classe abstraite ne peut pas
être instanciée directement car une instance de cet objet n'a aucun
sens Tout comme une glace sans saveur
n'a aucun sens. Au lieu de cela, nous ne pouvons
instancier que des sous-classes
d'une classe abstraite, comme la crème glacée aux fraises ou aux
myrtilles Une fois de plus, nous ajoutons la complexité à votre
travail et à vos connaissances. Il semble que nous ne faisons
que limiter vos fonctionnalités. Et vous vous
demandez peut-être pourquoi. Pourquoi créerions-nous
une classe abstraite qui ne peut même pas être instanciée Ne nous
limitons-nous pas et ne nous ralentissons pas délibérément
si nous nous forçons à créer une sous-classe avant de
l'utiliser pour quoi que ce soit ? La réponse est que
même si un objet comme crème glacée
sans saveur
n'a aucune signification en soi,
il a tout de même de
la valeur de deux manières La première est que les modèles d'
héritage sont toujours d'actualité ici. Tout comme avec l'héritage
normal, nous pouvons définir une valeur de champ sur l'objet de base et faire sous-classes héritent
de ce Même s'il n'existe pas de crème
glacée sans saveur, nous pouvons toujours déclarer que
sa température est de 0
degrés Celsius et faire en sorte que les sous-classes héritent
toutes Cela devrait avoir du sens,
car nous n'avons pas besoin d' une classe de crème glacée précise pour
déterminer sa température. Nous pouvons simplement dire qu'en général, la crème
glacée doit être de 0 Celsius et définir cela dans la classe abstraite de
base. La deuxième raison pour laquelle
les classes abstraites sont toujours utiles est qu' elles peuvent spécifier un contrat
que les sous-classes doivent respecter Par exemple, nous pouvons déclarer que toutes les glaces doivent avoir
une méthode définie qui renvoie la couleur de la crème glacée dans le modèle de crème glacée de
base. Cette méthode ne sera pas
définie car il
n'existe pas de couleur pour
toutes les instances de crème glacée. Cependant, la crème glacée à la
fraise peut avoir une
méthode d'obtention de couleur qui renvoie le rose. Et la crème
glacée aux myrtilles peut avoir une méthode d'obtention de couleur
qui renvoie le bleu Si nous avions une classe de crème
glacée supplémentaire qui
ne fournissait pas d'implémentation get
color, Java ne parviendrait pas à compiler. C'est une bonne chose
car nous ne
voulons pas que notre code soit
compilé à moins d'être
absolument sûrs que toutes les instances de crème glacée
en béton ont une couleur définie pour elles. Cela peut sembler un peu
déroutant, mais ne vous inquiétez pas. Je vais vous montrer des exemples de la façon dont cela fonctionne dans
la prochaine vidéo. C'est tout pour cette leçon. Nous avons parlé
des classes abstraites et du fait qu'elles sont presque des objets dans la mesure où elles ne peuvent pas être
directement instanciées, mais peuvent fournir un contrat
ou un modèle pour les sous-classes Nous en verrons bientôt des
exemples concrets. Je vous verrai dans la prochaine vidéo.
9. Exemples abstraits: Bonjour les amis. Dans cette
vidéo, nous allons passer en revue quelques exemples
d'utilisation de classes abstraites. Et nous allons vraiment
bouleverser les choses aujourd'hui. Au lieu de parcourir des
diapositives et des diagrammes de code, nous allons nous concentrer
sur le codage pratique. Bien sûr, je vous
recommande vivement suivre votre compte Repel
It si vous le pouvez Si ce n'est pas le cas, assurez-vous de
consulter le lien Repel. Une fois cette leçon terminée, forkez-la et modifiez
le code La première chose que nous
allons faire est de visiter Repl. Cliquez sur le bouton Create Repel, choisissez le modèle Java et nommez vos classes
abstraites Repel. Maintenant qu'il est créé, la
première chose que nous allons
faire est de créer un cours de chien
abstrait. Nous allons le faire en cliquant sur le bouton « Nouveau fichier » ici et en l'appelant Java. La première chose que
nous allons faire est créer un cours abstrait pour chiens. La déclaration de classe ressemble presque à une définition
de classe normale, sauf que nous allons ajouter
le modificateur abstrait. Le modificateur abstrait
signifie simplement que nous allons avoir
au moins une
méthode abstraite dans cette classe. Définissons d'abord un attribut appelé jambes engourdies
et définissons-le sur quatre Notez qu'il ne s'agit pas
d'un champ abstrait. n'y a rien de tel
. Seules les méthodes peuvent être abstraites en Java. Intuitivement, la raison pour laquelle
nous avons défini un attribut
dans une classe abstraite
devrait avoir du sens nous avons défini un attribut
dans une classe abstraite N'oubliez pas que nous n'avons pas
besoin d'un type
de chien spécifique pour nous dire
combien de pattes possède un chien. Les chiens ont généralement quatre pattes. Il est prudent de le définir ici. Définissons maintenant une
méthode classique non abstraite appelée Get Sound, qui va renvoyer de l'écorce. Cela va se
comporter exactement comme n'importe quelle autre méthode non abstraite dans une classe normale.
Aucune surprise ici. Enfin, définissons
une méthode abstraite. Nous allons l'appeler get
color et non le définir. Encore une fois, cela devrait avoir du sens. Il est logique de définir obtenir le son pour les chiens en général, car les chiens
émettent généralement le même son. Mais quelle est la couleur d'un chien ? Vous ne pouvez pas répondre à
cette question sans avoir un exemple concret d'un chien devant vous. Il s'agit donc d'une méthode
abstraite. Créons maintenant une nouvelle classe, classe
normale, pas
une classe abstraite. Et demandez-lui de prolonger notre cours
abstrait pour chiens. Nous allons appeler
ce type un chien brun. Et cela va
étendre notre cours pour chiens. Classe publique Brown. Notez que la syntaxe pour étendre une
classe abstraite est la même
que pour étendre une classe
non abstraite. Ici, nous allons fournir une implémentation concrète de la méthode abstraite get color. La couleur d'un
chien brun doit être brune. Nous allons juste le faire
revenir brun. Ajoutons également une annotation de remplacement
à cette méthode L'annotation at override
est 100 % facultative, mais il est recommandé
de l'inclure La raison en est que Java vérifiera
ensuite au moment de la compilation si la méthode que
vous avez
annotée remplace réellement une méthode Cela serait
utile par exemple lorsque
vous êtes mal orthographié, la méthode ou la méthode n'existe pas réellement
dans la classe parent C'est particulièrement important lors remplacement de
méthodes abstraites, car n'est définie dans
la classe abstraite pour les méthodes aucune logique n'est définie dans
la classe abstraite pour les méthodes abstraites Nous voulons être absolument
certains d'avoir fourni une
implémentation concrète de la méthode. Maintenant,
rassemblons tout cela dans notre classe principale. La première chose que nous allons
tester est donc d'instancier un chien comme celui-ci.
Voyons ce qui va se passer. Écoutez, nous avons une erreur. Il dit que le chien est abstrait
et ne peut pas être instancié. Cela a du sens, car
comme nous l'avons déjà dit, classes
abstraites ne peuvent pas
être instanciées directement. Nous ne pouvons qu'instancier
leurs sous-classes. Essayons maintenant d'instancier
un chien brun, qui hérite à partir de ce moment du code compilé
sans problème Encore une fois, cela ne devrait pas avoir de
sens. Brown dog est une sous-classe
d'une classe abstraite. Voyons maintenant ce qui se passe
lorsque nous appelons ces méthodes. Tout d'abord, renommons
ce type Brown Dog parce que c'est un chien brun Jetons d'abord un coup d'œil aux pattes engourdies à pois
bruns. Si vous vous souvenez, les pattes engourdies par des points de
chien bruns devraient être celles de ce type
ici, dans la classe canine Comme les champs ne peuvent pas être abstraits, les jambes
engourdies agiront
exactement de la même manière que attributs définis dans les
classes normales. Lorsque nous appelons brown
dog dot numb legs, Java examine d'abord
la classe brown dog pour voir
s'il existe un attribut
engourdi legs. Ce n'est pas le cas. Il regarde ensuite dans
la classe des parents,
puis dans la classe des chiens et il
constate qu'il existe bel et bien des pattes engourdies Cette première ligne devrait
en imprimer quatre. Nous allons le tester. En effet, nous en récupérons quatre. Ensuite, essayons
quelques appels de méthode. Voyons ce qui
se passe lorsque nous appelons brown dog point get color
et brown dog point get. Son Comme prévu, le
chien brun obtient une couleur qui redevient marron. C'est la méthode qui était vide dans la classe de chiens d'origine mais qui a été remplacée dans Brown
Dog, Brown Dog, Dog get Sound était la méthode que nous avons définie
dans la classe parent dog et que Brown Dog n'a pas définie explicitement. Récapitulatif rapide Le chien brun a de la
couleur, le chien a de la couleur. Son. Nous pouvons constater que les méthodes
classiques agissent exactement de
la même manière qu'avant. S'il n'existe pas
chez Brown Dog. Nous appellerons ensuite la méthode
définie dans la classe parent. Cependant, get color agit
également de la même manière
que les cours ordinaires. Nous appelons la méthode
définie dans la sous-classe. Dans ce cas, si nous avions
oublié de remplacer la méthode get color de la classe abstraite que brown
dog hérite de Java, aurions généré une erreur Voyons ce qui
se passera si nous le faisions. Disons que nous avons mal orthographié get
color comme ça et que nous appuyons sur Run. Vous voyez maintenant que nous avons une erreur. Le chien brun n'est pas abstrait et ne remplace pas la méthode
abstraite, obtenez de la couleur chez le chien C'est l'un des avantages de l'utilisation des classes abstraites. Nous voyons nos erreurs dès le départ
avant même d'exécuter le code. C'est tout pour cette vidéo. Aujourd'hui, nous avons examiné classes
abstraites et la
manière de les implémenter, ainsi que certaines des
erreurs qui peuvent survenir cas d'utilisation abusive des classes
abstraites. Voici le lien
vers le code de répulsion. J'aimerais que vous le
bifurquiez et que vous modifiiez
le code
10. Procédure pas à pas 1 de Minesweeper: Bienvenue, mes amis. Dans cette vidéo, nous
allons passer en revue la première partie de
ce projet en utilisant ce que nous avons appris
au cours des dernières leçons. Si vous souhaitez
suivre de manière interactive, vous devrez créer un compte et
vérifier votre e-mail. Le lien pour cela devrait se trouver dans la description du cours et se trouvait dans la vidéo d'introduction
de ce cours Si vous ne voulez pas
créer un autre compte, c'est très
bien aussi, bien
sûr , je
vous recommande vivement de créer un compte. La première chose que vous
voudrez faire après avoir un compte est de visiter Bit Dot Lee,
Minesweeper Skeleton, Minesweeper Skeleton Le lien se trouve également dans la description
du projet. Une fois sur cette page, cliquez sur le bouton « fork » pour accéder à une copie
du code de votre compte. Jetons un coup d'œil à la
structure de ce projet. Ayez les fichiers, la cellule du tableau principal, la cellule
vide, la cellule mentale
et la cellule numérique. Une grande partie du code
du Maine et de Board a été implémentée pour vous
et nous aborderons certaines parties manquantes plus
tard dans des présentations ultérieures. Pour cette vidéo, nous allons nous
concentrer sur les classes de cellules. Comme vous l'avez peut-être déjà
deviné, une classe de cellules représente l'une des cases
du jeu
Minesweeper Regardons-y de plus près. La classe cell est
une classe abstraite. Il déclare un contrat à suivre pour les
autres classes et fournit également
des méthodes par défaut. Chaque classe de cellule concrète doit implémenter une méthode à deux chaînes, qui est sa
représentation sous forme de chaîne dans le tableau, et une méthode tap qui définit ce qui se passe
lorsque la cellule est tapotée Nous avons également des
indicateurs dont valeur
par défaut est false
et certaines méthodes qui devraient être partagées entre
toutes les implémentations ont
été Drapeau, un drapeau engourdit les esprits des
voisins et incrémente les voisins engourdis. Je veux que vous
réfléchissiez à ce qui suit. Pourquoi ces méthodes sont-elles abstraites et pourquoi
sont-elles concrètes ? Mettez la vidéo en pause et
je répondrai dans 321. Eh bien, si je vous demande à
quoi devrait ressembler une cellule en général et mines,
pourriez-vous répondre Tu ne peux pas Une cellule est vide. S'il s'agit d'une cellule vide,
elle contient un chiffre. S'il s'agit d'une cellule numérique un astérisque, s'
il s'agit d'une cellule mentale, vous avez besoin d'une
implémentation concrète d'une cellule pour déterminer à quoi devrait ressembler sa
représentation sous forme de chaîne devrait ressembler sa
représentation De même, le comportement du toucher dépend
également du type de
cellule dont vous parlez. Par exemple, si vous tapez sur une cellule
mentale, le jeu est terminé. Mais si vous tapez sur une cellule vide, nous vous aidons simplement à toucher toutes
les cellules sûres voisines. autre côté,
si je vous demande si une cellule, quel que soit son type, a été exploitée, pouvez-vous répondre à cette question ?
Oui, tu peux. Quel que soit le
type de cellule, vous pouvez indiquer si
une cellule a été sélectionnée. De même, les
comportements du drapeau et annulation du drapeau sur une cellule sont les mêmes
dans toutes les classes de cellules, quel que soit leur type Bien, commençons à aborder ces deux commentaires
dans la classe cell. Tout d'abord, nous constatons qu' une méthode basée sur les lingots
a été Lorsque vous avez une méthode qui renvoie l'état d'un objet, cela indique que vous
devriez examiner les champs de l'objet. Dans ce cas, nous avons
cliqué et nous sommes marqués. Que pensez-vous que
cette méthode devrait renvoyer, compte tenu de ces informations ? Eh bien, nous devrions retourner sur Tapped puisque son nom suggère
qu'il va
stocker des informations sur
l'état des cellules tapées Ensuite, regardons le drapeau. Elle renvoie la valeur nulle. Nous n' avons pas à nous soucier de
la valeur de retour. Au lieu de cela, cette
méthode void suggère que son seul but est de modifier l'état d'un objet. Étant donné que nous voulons modifier
l'état de l'objet, quelle variable pensez-vous que
nous devrions modifier ? Eh bien, nous devrions modifier
le champ marqué, lui
attribuant la valeur true De même, la méthode non
signalée va définir le champ
marqué sur false C'est tout ce que nous avons à
faire pour la classe cell. Passons à la cellule vide. Nous voyons d'abord que nous devons
remplacer toutes les méthodes abstraites Copions les méthodes
abstraites et commençons à les implémenter. Nous voyons ici qu'il existe
un commentaire demandant d'utiliser ce caractère spécial
pour les cellules marquées Commençons par
mettre en œuvre cette logique. Comment savoir si
une cellule a été mise sur écoute ? Eh bien, jetons un coup d'œil. Nous avons cette
variable marquée qui stocke informations sur l'état du
drapeau de la cellule. Utilisons-le. Si cette cellule a été marquée,
nous renvoyons ce
caractère spécial ici même Sinon, si cette
cellule a été tapée, nous
renvoyons un espace vide Comme il s'agit d'une cellule vide, si vous appuyez sur une cellule vide, elle devrait révéler un espace vide. Enfin, si cette cellule
n'a été ni marquée ni
tapée , à quoi
devrait-elle ressembler ? Eh bien, souvenez-vous que dans
notre
première vidéo sur ce projet, nous disions que toutes les
cellules commencent par un X, ce qui représente
simplement que l'état de la cellule
n'a pas encore été révélé. Voyons ensuite, comme son nom l'indique, que pensez-vous que cette
méthode va faire ? Vidéo positive, et
je répondrai en 321. La meilleure méthode consiste à
définir le champ tapé sur
true afin que nous puissions nous souvenir de
l'état de cette cellule Après avoir défini le drapeau sur true, nous remarquons que cette méthode
doit renvoyer un lingot Eh bien, il est en fait assez
difficile de dire ici si nous devons renvoyer le vrai ou le
faux. Je vais te donner un indice. Si vous voulez relever un défi, essayez de visiter le forum Java et
examinez sa méthode de tapotement. Voyez si vous pouvez en déduire quelle
devrait être
la valeur de retour prévue de la méthode d'appui des classes de cellules la méthode d'appui des classes de cellules en cas de réussite. Et mettez la vidéo en pause si vous
voulez y réfléchir. Si ce n'est pas le cas, je
vais juste vous donner la réponse. La réponse est en 321, nous allons renvoyer vrai, car une valeur de retour vraie indique que vous pouvez appuyer sur la cellule
en toute sécurité. Ce que nous pouvons déduire en
regardant Board point Java. Nous voyons dans Java intégré que
si le résultat du tapotement est
vrai, nous continuons à chercher les cellules vides voisines à toucher. En d'autres termes, si le résultat du toucher est vrai, cela signifie que vous pouvez appuyer sur la cellule
en toute sécurité. Sinon, nous ne chercherions pas les cellules
vides voisines à toucher. Passons maintenant à
la cellule numérique et
répétons l'exercice. Cette fois, nous
voudrons remplacer les méthodes abstraites et
également engourdir
l'esprit des voisins La méthode du tap sera à peu près la même
que celle de la cellule vide. Il est
également possible de taper sur une cellule numérique en toute sécurité. Nous devenons vrais et retournons
le robinet à la réalité. La méthode à deux chaînes ressemblera
également beaucoup à la méthode à
deux chaînes des classes précédentes sauf que si elle est utilisée, nous devrions renvoyer le nombre de mines
voisines de cette cellule Commodément, nous
voyons qu'il existe ici
un champ appelé engourdissement des esprits
voisins Ne vous inquiétez pas trop
de la façon dont nous utilisons cette méthode pour incrémenter les voisins
numb sachez
simplement que nous l'avons déjà
implémentée pour En gros, nous
appelons simplement cette méthode
au moment opportun lorsque nous
plantons des mines sur le plateau. Le voisin Numb Minds
nous donne la bonne valeur. Puisque nous voulons que cette méthode
renvoie une chaîne, Numb Neighbor Minds,
sous forme d'entier, nous devons convertir cet
entier en chaîne Mais comment s'y
prendre ? Eh bien, utilisons une
ressource fantastique appelée Google. Cherchons en Java comment
convertir un entier en chaîne. Allons-y et cliquons
sur le premier résultat. Faisons défiler la page un peu vers le bas, et nous voyons immédiatement
qu'il y a un exemple ici, I = dix. Et nous convertissons ce dix en
chaîne en utilisant la valeur de la chaîne. Allons-y et
utilisons la valeur
de flux de ce nombre dans l'esprit des voisins. De cette façon, cette valeur de retour correspond à la valeur
de retour de la méthode à deux chaînes. Enfin, éliminons également les esprits
engourdis des voisins, ce que nous n'avions pas à faire
pour le cours précédent Comme son nom l'indique, Numb Neighbor Minds renvoie le nombre de mines situées
dans une cellule voisine Nous avons un champ qui
renvoie exactement cela. Allons-y et retournons à
Num Neighbor Minds. Nous avons maintenant terminé
la cellule numérique. Jetons un coup d'œil
à la dernière classe que
nous mettons en œuvre
dans cette vidéo. La cellule mentale
va en fait présenter de nombreuses similitudes avec les
cellules précédentes que nous venons d'implémenter. Allons-y et copions
ces méthodes abstraites. La
méthode Mind Cells Tap sera différente de celle
des cours précédents. Nous allons toujours définir
le champ saisi sur true, mais au lieu de renvoyer true, nous allons renvoyer false Puisque vrai signifie qu'
il s'agissait d'un toucher sécurisé, une mine n'est pas une
cellule sûre sur laquelle appuyer. La
méthode à deux chaînes
ressemblera à celle des autres classes, sauf que si elle est tapée, nous devrions renvoyer un astérisque car c'est sa
représentation dans le tableau En fait, c'est tout ce que
nous devons faire maintenant. Nous en avons terminé avec toutes
nos classes de cellules. En fait, nous ne serons pas en mesure de
vérifier si nous
l'avons fait correctement avant la fin de toutes ces étapes. Comme défi, si vous
voulez savoir si vous avez vraiment compris ce qui se
passe dans cette vidéo, je vous recommande de modifier le code
original et de voir si vous pouvez remplir tous les
commentaires à faire dans le squelette
sans mon aide. Sinon, je
vous verrai dans la prochaine vidéo.
11. Interfaces: Bienvenue, mes amis. Dans cette vidéo nous allons
parler des interfaces. Mais attendez, nous n'avons
même pas encore parlé interfaces.
Quels sont-ils ? Les interfaces sont
des classes qui spécifient un contrat et ne peuvent pas être
instanciées directement. Maintenant je sais ce que tu penses. Cela ne ressemble-t-il pas exactement la définition que nous avons donnée
pour les classes abstraites ? Vous auriez en fait raison. Les interfaces sont très similaires aux classes
abstraites et leurs
fonctionnalités fondamentales sont les mêmes. Maintenant, vous
vous demandez probablement pourquoi. Pourquoi avons-nous de telles entités en Java qui
font à peu près la même chose ? C'est presque comme si les concepteurs du
langage Java essayaient de nous piéger. Eh bien, il s'avère qu'
il existe des différences
entre les classes abstraites et les interfaces. Passons-les en revue. La plus grande différence est que les classes
abstraites ne
supportent qu'un seul héritage, alors que les interfaces supportent
plusieurs implémentations. En Java, une classe ne peut
hériter que d'au plus une classe qui inclut des classes
abstraites Un chien brun peut hériter d'un chien, mais nous ne pourrions pas laisser un chien
brun hériter
d'autre chose, comme un
animal brun par exemple Les interfaces permettent
de contourner ce problème. Les interfaces ne sont pas héritées
comme le sont les classes. Au lieu de cela, ils sont
implémentés et une classe peut implémenter
plusieurs interfaces. Dans notre exemple de chien brun, nous pourrions demander à brown
dog
d'implémenter une interface chien et
d'implémenter une interface animal brun. Brown Dog
aurait alors deux contrats pour remplir l'interface chien et
l'interface animal brun. Sur la base de ces informations, les classes
abstraites sont utiles lorsque nous avons des hiérarchies
d'objets simples Les interfaces sont utiles
lorsque nous avons un objet dont les contrats doivent mélanger et associer des méthodes issues de
plusieurs hiérarchies. Supposons que nous ayons un chien brun qui
hérite d'une classe de chiens et que la classe des chiens hérite d'une classe
de mammifères s'agit d'une hiérarchie linéaire, et il est logique d'implémenter nos contrats de méthode
sous forme de classes abstraites. autre côté, disons que
nous avons un chien brun et que nous aimerions qu'il corresponde
au modèle
d'objet d'un animal coloré. Et nous aimerions également qu'il reprenne le modèle d'un
animal avec des pattes. Les animaux colorés et les animaux à pattes sont deux hiérarchies
d'objets distinctes Bien sûr, de
nombreux animaux
devraient remplir les deux contrats, mais il y en a aussi qui
ne remplissent que l'un ou l'autre. Comme vous pouvez le constater, le
choix des interfaces ou des classes
abstraites dépend de la manière dont vous décidez de concevoir
votre hiérarchie de classes Voyons maintenant comment nous
utilisons réellement les interfaces dans la pratique. abord, nous définissons une interface
appelée animal with legs et déclarons une
méthode qui doit être implémentée appelée get non legs. Nous allons également définir une interface
appelée animal coloré qui déclare une
méthode à implémenter appelée get color. Créons maintenant une classe pour chiens
bruns. La première chose que je veux que vous
remarquiez, c'est que nous utilisons le mot clé implements
ici au lieu de extends. La prochaine chose que je veux que vous
voyiez, c'est que nous avons
spécifié ici plusieurs
interfaces qui doivent être implémentées
par brown dog. Si vous essayez de le faire
avec le mot clé extends, Java générera une erreur. Il s'agit d'une fonctionnalité
propre aux interfaces, qui permet d'implémenter
plusieurs choses. Hormis la
définition de la classe, le reste de la classe ressemble assez à
ce que nous avons vu. Puisque nous devons
implémenter toutes les méthodes déclarées dans les interfaces
que nous implémentons, nous définissons à la fois get color
et get numb legs Nous ajoutons également l'
annotation override pour indiquer clairement que ces implémentations
sont destinées à remplacer les déclarations
dans les interfaces C'est à peu près
ça. Dans cette vidéo, nous avons parlé des interfaces, qui sont un nouveau type
de classe qui déclare un contrat qui doit être rempli par les classes
qui les implémentent. Les interfaces vous permettent de créer plusieurs
modèles d'héritage que vous ne
pouvez pas créer avec les classes
abstraites classiques. Voici le lien vers le
code de dépôt utilisé dans cette vidéo. Veuillez visiter le lien
vers le dépôt et
modifier le code Je vous verrai dans la prochaine vidéo.
12. Enums: Bonjour les amis. Dans cette vidéo nous allons parler des enums Commençons l'
illustration d'aujourd'hui en définissant une classe appelée dog one, qui possède une méthode get type
qui renvoie simplement brown dog. Supposons que nous ayons également
une classe appelée dog two, qui possède également une méthode
get type, mais celle-ci renvoie white dog. Enfin, nous avons le chien trois. Le chien trois reçoit le type
renvoie un chien jaune. Oui, c'est un jaune
avec un H au lieu d'un W. Maintenant, mettons tout
cela ensemble. Nous avons nos trois
définitions de chiens sur la gauche
, puis sur la droite, nous
instancions trois chiens, une instance pour chaque classe Supposons que nous voulions
effectuer des vérifications simples. Nous voulons juste appeler,
taper sur chacun de ces chiens. Vérifiez ensuite la sortie. Si la sortie correspond à
une valeur attendue. Nous allons imprimer quelque chose
pour notre premier chien. Nous voulons vérifier si le type de chien est
un chien brun. Pour le deuxième chien, nous
voudrons vérifier s'
il s'agit d'un chien blanc. Enfin, pour le troisième chien, nous voulons vérifier s'
il s'agit d'un chien jaune. Eh bien, comme nous avons
accidentellement mal orthographié chien
jaune dans notre définition de type « chien
trois », cette condition
sera fausse et nous n'indiquerons pas que le
chien trois est Ce n'est pas un gros problème dans
un programme aussi simple que celui-ci, mais je peux vous proposer une situation où les enjeux sont
plus élevés. Imaginez que votre
site Web recherche
du trafic provenant de plusieurs pays et que
vous souhaitiez modifier
la langue
du site Web en fonction du
pays d'origine de l'utilisateur. Supposons que pour
une personne résidant au Japon, vous souhaitiez définir
le japonais comme langue
du site Web. Selon cette logique, vous auriez un tas
d'instructions if. Choix de la langue
du site Web en fonction du pays de l'utilisateur. Supposons maintenant que nous ayons mal orthographié le Japon quelque part dans notre code Maintenant, cet utilisateur japonais ne
va pas comprendre la bonne langue et vous avez simplement raté des ventes potentielles. Ce serait formidable si nous pouvions protéger notre code
contre
de telles fautes de frappe, et nous avons un outil qui
fait exactement cela Créons une
classe enum appelée dog type. Habituellement, lorsque nous créons une classe, nous écrivons un nom de classe public. Mais ici, notez que nous
disons « énumération publique », type de
chien » dans cette énumération Nous définissons ensuite trois valeurs, jaune, marron et blanc. Notez que ces trois valeurs
ne sont pas entre guillemets, ce ne
sont pas des chaînes. On ne
sait peut-être toujours pas en quoi cela peut aider. Voyons
comment nous les utilisons. Définissons une nouvelle
méthode pour chacune de
nos classes de chiens
appelée get enum type Nous pouvons alors voir que pour le premier chien, cette méthode renvoie le
type brun et nous renvoyons le type blanc
et le type doc jaune. Pour les deux autres
chiens, cela peut ressembler essentiellement à
ce que nous avions avant, mais il y a une distinction très
importante ici. Enum agit de la même manière qu'une
variable ou un champ en Java, dans la mesure où Java effectue une recherche lorsque
vous y faites référence, lorsque je dis doc type brown, Java recherchera en fait la
classe enum de type chien et verra s' il y a une valeur à
l'intérieur appelée Si cette valeur n'existe pas, Java ne parviendra pas à compiler. C'est l'un des principaux
avantages des enums. Les énumérations permettent à Java de
vérifier au moment de la compilation que toutes les
valeurs de référence existent réellement. Cela réduit le risque de mal orthographier vos valeurs de
référence Les énumérations signifient également qu'il existe
une seule source de vérité pour les valeurs
constantes, alors que nous écrivions manuellement chaque
chaîne pour comparer les valeurs Nous pouvons maintenant faire
quelque chose comme ça, une
meilleure garantie que
la valeur constante à
laquelle nous faisons
référence existe réellement. Si nous avons accidentellement mal orthographié
doctype yellow ici, où nous avons mis Y E L L
O H. Java
ne parviendrait pas à compiler car il s' enregistrerait dans l'énumération
du type de document Sachez qu'il n'
existe pas de
document de type Y L L L O H.
C'est tout pour cette vidéo. Nous avons parlé des énumérations, qui nous permettent de définir valeurs
constantes pour
nos applications Ces valeurs constantes
sont utiles car si jamais
nous avons une
référence mal orthographiée à une énumération, Java générera une erreur de
compilation et nous saurons exactement
où résoudre Les énumérations fournissent également une source
de vérité pour nos constantes. Vous définissez vos
constantes à un seul endroit, et vous vous référez toujours à
ces constantes ailleurs dans votre programme au lieu de réécrire la valeur
encore et encore Voici le lien vers le code
Repl dans cette vidéo. Je te verrai dans le prochain.
13. Commutateur: Bonjour les amis. Dans cette vidéo nous allons
parler de Switch. Commençons notre
illustration par des définitions
similaires à celles
de la dernière vidéo. Nous aurons un type de chien avec trois types de couleurs et
nous aurons un chien brun dont la méthode get type
renvoie le type de chien brun. Maintenant, dans notre méthode principale, instancions un chien brun Nous dirons que si le type de chien brun est blanc, c'est que
le chien est blanc. Si le
type du chien brun est jaune, indiquez que le chien est jaune. Si le type de chien est brun, indiquez que le chien est brun. Sinon, indiquez que la couleur du
chien est inconnue. Maintenant, il n'y a rien de
mal à ce code. Cela fonctionne parfaitement bien. Mais notez qu'ici nous avons la même valeur dans
chaque clause if. De plus, nous avons la même structure logique
dans chaque clause if, comparant la même valeur
à un type d'énumération différent Encore une fois, il n'y a rien de mal à
cela d'un point de
vue fonctionnel, mais cela semble juste maladroit Il s'avère que Java a
une solution pour cela. Voici une autre façon d'
écrire la même chose. Avant de commencer à
parler de ce code, je veux que vous y jetiez
un œil vous-même. Pouvez-vous deviner à quoi sert chaque
nouveau mot clé ? Mettez la vidéo en pause et
quand vous serez prêt. Voyons à quel point tu étais proche. Tout d'abord, cette
clause de commutation en haut indique simplement
que nous voulons comparer cette valeur
encore et encore. Nous allons comparer
la valeur entre parenthèses
de commutation aux valeurs qui suivent
ces mots-clés majuscules Cette première clause est à
peu près équivalente à si type de point de saisie
brun est
égal au type de chien blanc. La seconde est équivalente à si le doggettype
brun est égal
au type de chien jaune Vous pouvez probablement deviner ce que signifie
la clause du dernier cas. Notez que dans ces
clauses, nous ne mentionnons pas type de
chien blanc et le type de
chien jaune. Nous disons simplement blanc et jaune. La raison en est que
dans les blocs de commutation, Java déduira le type d'énumération, la valeur entre parenthèses,
et s'attend à ce que vous écriviez simplement les valeurs d'énumération sans
le nom de la classe d'
énumération C'est un point assez mineur, mais gardez-le à l'esprit si
vous rencontrez des erreurs. Enfin, ce cas par défaut est peu près équivalent à
else, mais pas exactement. Cela signifie en fait toujours exécuter ce cas si le programme
atteint cette ligne. Cependant, nous n'
atteignons ce cas que dans le cas Ls en raison de
ces déclarations de rupture. Mais que sont-ils ? Il s' avère que ces
instructions de rupture interrompent évaluation
ultérieure
au sein du bloc de commutation si le chemin
du code les atteint. Supposons, par exemple, qu'il n'y ait pas
eu de clause de rupture dans la
clause brune dans l'affaire Brown. Si tel était le cas, alors tout ce code serait exécuté. Nous imprimerions
que le chien est brun. Et comme il
n'y a plus de ligne de frein, Java continuerait à exécuter
le code dans le cas suivant. Le cas suivant
est le cas par défaut. Nous imprimerons également
Unknown dog color. Comme vous pouvez le constater, si notre bloc de commutation
contenait beaucoup plus de boîtiers,
ce serait une grosse perte de
temps si nous continuions à exécuter le code même après avoir déjà trouvé le type
du chien brun. En général, lorsque vous vous
attendez
à ce qu'un seul cas corresponde, il est préférable de définir
une conduite de frein dans chaque cas. C'est tout pour cette vidéo. Dans cette leçon, nous avons
parlé de switch, qui est essentiellement
une façon plus concise écrire
de la logique répétitive,
sinon sinon. Voici le lien vers le code
Repl dans cette vidéo. Je te verrai dans le prochain.
14. Procédure pas à pas 2 de Minesweeper: Bienvenue, mes amis. Dans cette vidéo, nous allons passer en revue la deuxième partie de ce projet en utilisant ce que nous avons appris au cours des dernières leçons, particulier enums et switch Cette fois, nous allons
en fait
jeter un œil à la classe principale. Il se passe
beaucoup de choses dans ce dossier. Avant de commencer, veuillez prendre
un moment pour le lire. Ce n'est pas grave s'il y a
des parties que vous ne comprenez pas. La plupart des noms de variables
sont assez descriptifs et devraient au moins
vous donner une bonne idée de ce qu'elles font. Maintenant,
parlons-en ensemble. Nous créons d'abord un tableau, nous l'imprimons,
puis nous entamons une boucle
infinie ici. Cette ligne
de saisie du scanner indique simplement à la console de voir ce que l'utilisateur a saisi
au tour en cours. Rappelez-vous que dans notre démo,
nous avons fait des choses comme lignes de
drapeaux et la colonne de lignes
Tap. Tout ce que vous entrez dans la
console sera enregistré dans cette chaîne saisie par l'
utilisateur ici, la division des entrées utilisateur
signifie simplement que nous allons séparer la chaîne en
fonction de l'espace blanc. Par exemple, lorsque nous avons
tapoté un espace
B, nous devrions nous retrouver avec un tableau contenant
trois éléments. Le premier élément sera touché, le deuxième sera A
et le troisième
élément devrait être B.
C'est pourquoi, et le troisième
élément devrait être B. si la longueur du tableau n'est pas
de trois, nous rejetons la commande
et recommençons la boucle. Vous ne connaissez
peut-être pas cette ligne de poursuite. Tout ce qu'il fait, c'est dire à Java de
sauter le reste de la boucle
et de commencer par le haut. Encore une fois, nous allons revenir
au début de cette boucle en y, vérifier la prochaine entrée utilisateur. Ici, nous avons une ligne
égale à moins un, suivie d'une boucle vide. La colonne est égale à moins un, suivie
également d'une boucle vide. Nous y
reviendrons dans une vidéo ultérieure. Ce n'est pas très
important pour le moment. Sachez simplement que les lignes et les
colonnes
seront des entiers représentant les index
du tableau sur lesquels l'utilisateur souhaite
effectuer une action Enfin, nous avons atteint une partie du code qui
nous intéresse. Ici, nous créons un lingot
appelé cellule sûre. Nous avons un
bloc de commutation vide qui le suit. Ci-dessous, nous disons que si sa cellule sécurisée est
fausse, alors la partie est terminée. Cela implique que
ce bloc de commutation doit modifier la
valeur de la cellule sûre. Sinon, sa cellule sûre
sera toujours vraie. Et il serait superflu d'
avoir cette coque F ici. Pensez à la dernière visite
guidée que nous avons faite. Connaissez-vous la méthode que nous avons mise en œuvre qui renvoie une valeur d'or indiquant si un robinet était
un robinet sécurisé ou non ? La réponse est que vous avez
implémenté la méthode du tap. Rappelez-vous que nous avions
cette méthode
Tap qui enregistre que
la cellule a été qui enregistre que
la cellule a été tapée pour les cellules numériques
et que les cellules vides
renvoient vrai pour les
cellules mentales, nous renvoyons faux Et si vous aviez exploré
un code un peu plus, vous auriez vu que dans Board Java, nous avons également une
méthode de tapotement. Et que faisons-nous ? Tout d'abord, nous appuyons sur la
cellule située dans colonne de la ligne d'
index et enregistrons le résultat de cette saisie dans le résultat de
cette saisie de lingots S'il s'agit d'un robinet sûr et qu'aucune
mine ne l'entoure, nous exploitons toutes les cellules
voisines et nous répondons à la réalité. Sinon, si nous avons enregistré
une mine avec du ruban adhésif, nous renvoyons faux. Cela implique que dans
ce bloc de commutation, nous devrions appeler
Tap Row Column, enregistrer le résultat de cet
appel dans sa cellule sécurisée. Mais rappelez-vous qu'un bloc de commutation est utilisé lorsque nous avons
plusieurs boîtiers pour vérifier quels cas
nous devons vérifier dans
ce boîtier de commutateur. Encore une fois, mettez la
vidéo en pause et réfléchissez à ce qui s'est passé
plus tôt dans le sloop Je révélerai la réponse en 321. Eh bien, la seule fois où
nous obtenons une valeur pour est cellule
sûre, c'est lorsque
nous appuyons sur une cellule. Mais ce ne sont pas les seules
actions qu'un utilisateur peut effectuer. Rappelez-vous dans la
vidéo d'introduction du projet qu'un utilisateur peut également signaler et démarquer une cellule si
vous avez oublié ce que font ces cases En gros, le drapeau
marquera une cellule comme un esprit potentiel, mais
il ne touchera pas la cellule. Supprime également un drapeau de la cellule sans
appuyer sur la cellule. Comme la commande utilisateur
va prendre la colonne de lignes d'action du formulaire, nous allons mettre la commande zéro entre
parenthèses ici Notre premier cas
sera un robinet. Si l'utilisateur
saisit un appui comme commande,
alors nous allons dire,
nous allons réattribuer la valeur d'une cellule sûre pour qu'elle soit
le résultat d'un appui sur
le tableau au niveau de la colonne de ligne de
position N'oubliez pas qu'après avoir effectué l'action que nous voulons effectuer
dans ce cas, nous devons laisser une
instruction break avant le cas suivant. Si la commande utilisateur était un drapeau, quelle méthode doit être rappelée ? Eh bien, voici une bonne occasion utiliser nos compétences en lecture de code. Voyons quelles
sont les autres méthodes de la classe board. Nous avons une
méthode résolue ici, mais cela ne semble pas
vraiment probable. Hé, nous avons ici un drapeau
et une méthode non alimentée. Ils semblent correspondre à notre cas d'utilisation, réutilisons-les
dans notre classe principale. Dans le cas du drapeau, nous
allons appeler la colonne du drapeau. Puisque cette méthode revient, nous n'avons pas vraiment l'intention d'utiliser la valeur de retour de cette méthode pour faire autre chose,
nous cassons simplement. Enfin, nous allons avoir
notre dernier cas, qui est celui du drapeau ici. Nous allons faire la colonne du drapeau, puis nous allons aussi la casser. Nous avons cependant un petit
problème ici. Il est tout à fait possible
qu'un utilisateur saisisse une chaîne aléatoire
comme commande de saisie, ou qu'il
ait accidentellement mal orthographié tap flag ou unflag Mais nous voulons rendre
ce code plus robuste et c'est là que
les énumérations entrent en jeu Prédéfinissons certaines valeurs
possibles que nous voulons
accepter de la part de l'utilisateur Ici, dans l'action, euh, allons-y et
définissons unflagg, tapez L'
ordre dans lequel vous les écrivez n'a pas vraiment d'importance. Maintenant, convertissons ces valeurs majuscules à partir de
chaînes, de valeurs enum Cela vous prémunira contre d'
éventuelles fautes de frappe. Allons-y et
changeons-le en un clic. Faisons-en un drapeau,
faisons-en un drapeau de l'ONU. Mais maintenant, nous avons un petit problème. N'oubliez pas que Java déduira
le type de valeur entre parenthèses et vérifiera
que ce type correspond au type
de ces valeurs majuscules Mais ce n'est pas le cas ici. Le type de commande
zéro est une chaîne. Le type de ces
valeurs de cas est une énumération d'actions. Comment convertir une chaîne
en une énumération d'actions ? Eh bien, c'est une opportunité
fantastique nos compétences
en matière de recherche sur Google Allons-y et Google
Java explique comment convertir une chaîne, une chaîne, en une énumération Allons-y et cliquons
sur le premier résultat ici. Nous faisons défiler la page vers le bas. Nous n'avons pas vraiment besoin
de lire la majeure partie de ces informations, mais nous pouvons voir
ici, dans le bloc de code, qu'ils
vous disent qu'ils ont
une énumération appelée statut de Pisa Hum, et il y a une
valeur à l'intérieur. État de la pièce : énumération. Prêt ? Faisons-le défiler
encore un peu plus vers le bas. Nous voyons que nous avons cet
exemple, Pisa status enum. Sauf que cette fois, nous dérivons
la valeur de l'énumération, non pas en disant patatenum, ready,
mais piece of status, enum
value of string, C'est un très bon
indice car
cela nous indique que la méthode value d'une classe enum convertira
une chaîne en énumération Allons-y et utilisons-le
au lieu de la commande zéro, faisons la valeur d'action
de la commande zéro. C'est à peu près tout ce que nous avions à faire pour cette visite guidée. Malheureusement, encore une fois, nous ne pourrons pas
voir le résultat de ce que nous avons fait avant d'avoir
terminé l'ensemble du projet. Mais j'espère que vous resterez dans les
parages pour voir le résultat final. C'est tout pour cette vidéo. Merci d'avoir regardé et je vous
verrai dans le prochain.
15. Exceptions: Bonjour les amis. Dans cette vidéo nous allons
parler des exceptions. Reprenons l'exemple que nous
avions donné dans la vidéo précédente. Rappelez-vous que notre
enum de type chien en comportait trois types, blanc, brun et jaune Si le type de chien correspondait
à l'un de ces trois cas, nous imprimerions un relevé
, puis nous sortions
du bloc de commande. La seule fois où nous atteindrons
ce cas par défaut, c'est si type
des chiens
bruns n'est aucune de ces trois couleurs, mais que seuls
ces trois types sont définis. Quand serons-nous
confrontés à ce cas ? Eh bien, cela pourrait être le cas si le type est nul ou peut-être qu'à l'avenir nous finirons par
ajouter un type de chien supplémentaire. Mais oubliez de mettre à jour
ce bloc de commutateurs. Mais d'une manière générale,
nous ne nous
attendons pas à atteindre ce
cas par défaut dans la plupart des cas d'utilisation. Si nous atteignons ce
cas par défaut avec ce code, nous allons en fait
obtenir un échec silencieux. Nous allons
imprimer une ligne supplémentaire , couleur inconnue du chien. Mais le programme fonctionne très bien. Il ne manque pas de compiler et il n'y a aucune erreur
lorsque nous l'exécutons. Nous ne savons pas si l'impression
d'une couleur
inconnue pour chiens était prévue ou non. Au lieu de cela,
nous devrions créer une exception. Voici un exemple de l'un des types d'exceptions
les plus courants, l'exception étatique
illégale. Notez ceci dans le texte ici. Nous disons throw, qui indique à
Java de lancer une erreur. Ensuite, nous fournissons une nouvelle
instance de l'exception avec new et nous transmettons un
message d'erreur à l'exception. Maintenant, si Java atteint
cette ligne de code, une erreur sera
générée lorsque vous exécuterez le programme et celui-ci
s'arrêtera. C'est en fait une bonne chose. Supposons que vous ayez ajouté un type de chien
supplémentaire appelé Blue, mais que vous ayez oublié d'
ajouter un étui pour ce chien. Vous voulez que le code s'arrête
et vous indique qu'il existe un type inconnu au lieu de continuer à s'exécuter comme
si de rien n'était. C'est difficile à voir avec
ce petit programme. Mais imaginez que vous avez une application bien
plus importante. Supposons, par exemple,
qu'une application vous indique le montant
d'argent que vous avez en banque. Il est préférable pour
la banque de signaler qu'une erreur s' est produite lors du chargement de
votre compte plutôt que échouer
silencieusement et de vous dire
que vous avez un montant
négatif de 50 000$ votre compte,
tant pour le développeur l'utilisateur de l'application L'erreur explicite est beaucoup plus informative qu'une sortie étrange
arbitraire. L'avantage supplémentaire pour
le développeur est que l'erreur personnalisée
vous
indiquera en fait où un événement
inattendu s'est produit. Cela facilite également beaucoup le
débogage. C'est tout pour cette vidéo. Nous avons parlé d'exceptions qui arrêtent
délibérément des programmes
avec un message d'erreur personnalisé. Bien qu'à première vue, cela puisse sembler une
chose terrible à ajouter à votre programme. Mais en fait, ils contribuent à garantir la stabilité
du programme en fournissant
des vérifications de bon sens et en
fournissant des conseils
au développeur en
cas de bogue Voici le lien vers le
code de répulsion utilisé dans cette vidéo. Je te verrai dans le prochain.
16. HashMap: Bienvenue, amis. Dans cette vidéo nous allons
parler de la carte de hachage L'exemple d'aujourd'hui est assez court et peut tenir dans un seul fichier. La première chose
que je veux que vous remarquiez est cette importation
en haut du fichier. La carte de hachage est une structure de
données incluse dans le package
Java Util, qui est un package intégré Voyons maintenant
comment déclarer un Hashmap. Comme d'habitude, nous déclarons d'abord le type de la variable
qui est un Hashmap Ensuite, nous utilisons ces
crochets inclinés pour spécifier les types de clés et de
valeurs dans cette carte Le nombre entier
entre crochets indique le type des clés La chaîne entre crochets indique le type
des valeurs. Une clé est essentiellement
quelque chose que nous allons utiliser pour rechercher des valeurs. Pensez par exemple à la liste
contextuelle de votre téléphone. Lorsque vous souhaitez rechercher le numéro de téléphone de
votre ami, vous devez d'abord rechercher
son nom. Lorsque vous cliquez sur le nom, votre téléphone affiche le numéro de téléphone de
votre ami. Le nom de votre ami est une clé qui correspond à un numéro de téléphone
qui est une valeur. Dans ce cas, nous allons
mapper des entiers à des chaînes Notez également que nous avons utilisé un entier
majuscule I
ici au lieu de t
minuscule. Lorsque nous
déclarons des types entiers contenus dans d'autres
objets comme clé dans une carte, nous utilisons un entier majuscule I, mais sinon un entier
majuscule et T
minuscule sont
pratiquement interchangeables. Voyons maintenant comment
instancier une carte de hachage. Notez que nous
incluons toujours les crochets, mais que nous n'y mettons
rien. En effet, cette
syntaxe indique à Java de simplement déduire les types
de clés et de valeurs Sur le côté gauche
de cette tâche, Java saura
créer une carte de hachage avec des clés entières
et des valeurs de chaîne Sur la ligne suivante, jaune indique que nous
mappons maintenant un sur le
jaune, tandis que le point de la carte mis sur le brun signifie que
nous mappons deux sur le brun. Lorsque nous imprimons un point sur la carte, nous l'imprimons en jaune. Lorsque nous imprimons un point sur la carte, nous imprimons en brun. Cela semble assez simple
et c'est généralement le cas. Une chose que je tiens à souligner
ici, c'est que ces entrées et ces sorties se produisent
en temps constant. Nous n'avons pas vraiment
parlé de ce que signifie cette notation O d' un,
car ce n'est pas vraiment l'
objectif de cette classe. Vous n'avez pas vraiment besoin de savoir
en détail ce qui se passe, mais je vais vous en donner
un bref aperçu. La
carte de hachage et de hachage est en fait un mécanisme de
programmation qui permet à
l'ordinateur de stocker
des objets de manière à ce qu' il soit très facile et rapide de les
récupérer ultérieurement. Il faut encore du temps pour récupérer
et stocker ces objets, mais le temps est pratiquement
négligeable dans la plupart des cas d'utilisation Les cartes sont très utiles
pour stocker des données. Bon,
c'est tout pour cette vidéo. Nous avons parlé de la carte de hachage, qui est une structure de données qui stocke et associe les clés aux valeurs Tout cela se fait
en temps constant, qui
signifie que la latence requise
pour écrire et lire la carte n'augmente pas beaucoup à mesure que nous augmentons le
nombre d'éléments sur la carte. Voici le lien vers le
code de répulsion utilisé dans cette vidéo. Je te verrai dans le prochain.
17. Addenda de carte: Bienvenue, mes amis. Dans cette
vidéo, nous allons passer en revue une fonctionnalité supplémentaire de
Java liée aux cartes de hachage Voici l'exemple que nous avons eu dans la vidéo précédente avec un
peu plus de code. Tout d'abord, importons
Java Util Dot Map. Jetons ensuite un coup d'
œil à cette ligne. En bas, nous déclarons
une variable appelée x et lui donnons un type de
carte, entier, entier. Nous l'instancions à l'
aide de la carte 1234. Quelques points à noter ici. Tout d'abord, une carte n'est pas la
même chose qu'une carte de hachage. Une carte est en fait une interface, et une carte de hachage est une
implémentation concrète de
cette interface Ensuite, une carte créée avec
map of sera immuable, ce qui signifie que vous ne pourrez pas modifier ses clés ou ses valeurs
une fois créée Cette carte de syntaxe semble amusante, mais elle équivaut essentiellement
à mapper la clé un à la valeur deux et la clé
trois à la valeur quatre. Si nous en obtenons
un, nous en aurons deux. Comme un correspond à deux, si x point obtient deux, nous obtiendrons une valeur nulle car
deux est une valeur et non une clé. Comme la clé deux n'
existe pas, nous obtenons un résultat nul. Enfin, le dossier trois nous en
donnera quatre, car les clés et les valeurs
alternent dans la carte de l'appel de création et nous
indiquons trois après la valeur deux C'est tout pour cette vidéo. Je voulais juste
vous présenter un moyen rapide
d' instancier
une carte si vous ne voulez pas abord
créer la carte,
puis la remplir de clés et valeurs une par une
pour récapituler rapidement Les cartes créées de cette
façon sont immuables. Lorsque nous le faisons, nous alternons les clés et les valeurs dans
la carte d'appel. Voici le lien vers le code de
répulsion dans cette vidéo. Je te verrai dans le prochain.
18. HashSet: Bienvenue, mes amis. Dans cette vidéo, nous allons
parler du hash set L'exemple d'aujourd'hui est assez similaire
à celui de la dernière vidéo. Il tient dans un seul fichier, et même la syntaxe est assez
similaire. Allons-y. La première chose que
vous devez remarquer est que, tout comme la carte de hachage, ensembles de
hachage doivent être
explicitement importés Les ensembles de hachage se trouvent également dans
le package Java Util. Examinons ensuite la déclaration de
variable. Nous déclarons un ensemble de hachages, puis entre ces crochets
inclinés, nous
déclarons le type des éléments qui y seront
contenus Nous utilisons un entier majuscule I puisque nous encapsulons les
entiers dans un conteneur, tout comme les listes ou les cartes de hachage Lors de
l'instanciation des ensembles de hachages, nous n'avons pas besoin de
spécifier le type des éléments sur
le côté droit
de l'affectation Nous pouvons simplement mettre des crochets
angulaires vides, et Java déduira le
type des éléments à partir
de la déclaration de variable sur le côté gauche de l'affectation La méthode publicitaire nous permet de
stocker des articles dans le set. Notez que Java
ne vous permettra pas de mettre un objet autre
qu'un entier dans l'ensemble. Vous ne pourrez pas saisir de
chaînes ou de valeurs d'investissement. Vous obtiendrez une
erreur de compilation si vous essayiez cela. Ici, si nous essayons d'en ajouter 35 alors que nous l'avons déjà
fait plus tôt, rien ne changera réellement. C'est l'une des principales
caractéristiques des ensembles de hachage. Les ensembles de hachage ne peuvent
contenir que des objets uniques. Si vous essayez d'ajouter deux fois
le même élément, Java n'émettra aucune erreur, mais il ne fera
rien de différent. Nous avons également une méthode de taille, et vous pouvez probablement
deviner à quoi cela correspond. Il renvoie simplement le nombre
d'éléments de l'ensemble. Dans ce cas, il y en a deux. Comme nous n'en avons que
35,91 dans l'ensemble, la méthode contenue
renvoie vrai ou faux selon que
l'
élément demandé se trouve déjà dans l'ensemble C'est vrai pour 35 et
c'est faux pour 36. Vous pouvez également supprimer
des éléments du set. Si vous appelez des objets
qui suppriment 35, 35 ne figurera
plus dans le set. Nous pouvons confirmer en appelant
les articles contenant 35, qui retourneront faux. Maintenant, un dernier
point à retenir pour vous. Tout comme les cartes de hachage, les ensembles de hachage utilisent
également le mécanisme de hachage Vous n'avez pas besoin de connaître les
détails, mais sachez simplement que ces appels contiennent des éléments d'
ajout et de suppression, se produisent
tous en temps constant. Cela signifie que le temps nécessaire
pour exécuter ces méthodes n' augmente
pas de manière significative à mesure que
la taille de l'ensemble augmente. Cela peut être très utile
lorsque vous souhaitez utiliser une structure de données pour des recherches et un stockage très
rapides. Supposons, par exemple,
que vous souhaitiez vérifier si une certaine publicité a déjà été diffusée pour un utilisateur. De cette façon, nous pouvons toujours
diffuser des publicités uniques. Eh bien, une façon de le
représenter est que chaque objet utilisateur a un
ensemble de hachage qui lui est associé Cet ensemble contient
les
objets publicitaires que cet utilisateur
a déjà vus. Ce n'est qu'un exemple de base. Et nous aurons un autre cas d'utilisation des ensembles de hachages dans le projet, que vous verrez très bientôt Très bien, et
c'est tout pour cette vidéo. Dans cette leçon, nous avons
parlé des ensembles de hachage qui nous permettent de stocker de
la valeur pour des recherches ultérieures. Ils ont également des droits
de lecture permanents, ce qui les rend très utiles
dans divers cas d'utilisation, comme l'
exemple de publicité unique dont nous avons parlé. Voici le lien du dépôt
du code dans cette vidéo. Je te verrai dans le prochain.
19. Procédure pas à pas 3 de Minesweeper: Bienvenue, mes amis. Dans
cette vidéo, nous allons passer en revue l'une des parties les plus marquantes du projet En utilisant ce que nous avons appris
dans les dernières vidéos sur Java intégré. Faites défiler la page jusqu'à cette méthode appelée rassembler
les cellules vides voisines. Jetons un coup d'œil
à ce qu'il fait. Cette classe Q liée au blocage Q peut ne pas
vous sembler familière, ne vous inquiétez pas pour ça. Ce n'est pas très pertinent
pour le cours. Tout ce que vous devez vraiment savoir à ce
sujet ici, c'
est que cela nous aide à effectuer ce que l'on appelle BFS, ou Breadth First search C'est le souffle, comme dans B, R, E, A, D, T, H. Nous n'en avons pas
parlé dans le discours. Et il n'est pas vraiment
nécessaire que vous sachiez comment cela
fonctionne spécifiquement. Mais n'hésitez pas à le rechercher
sur Google si vous êtes curieux, car c'est
un concept très cool. Dans cette méthode, notre
recherche BFS collecte toutes les cellules vides adjacentes à la
ligne et à la colonne fournies Une fois qu'il a collecté toutes les cellules
vides
adjacentes, il recherche les cellules vides adjacentes aux cellules vides que
nous avons déjà collectées. Ensuite, nous continuons à
rechercher des cellules vides adjacentes à ces
cellules vides, et ainsi de suite. Comme vous l'avez peut-être deviné,
cela fait partie du code qui gère
le fait de
taper sur une cellule vide N'oubliez pas que lorsque vous
tapez sur une cellule vide, nous recevons généralement une grande partie
du tableau pour nous Cela se fait via cette méthode, qui indique au programme
où se trouvent toutes les cellules vides adjacentes à la cellule sur laquelle vous avez
tapé Avant de poursuivre, je tiens
à souligner que certains d'entre vous peuvent être un peu frustrés par
ces étapes. Peut-être avez-vous l'impression,
pourquoi n'avons-nous pas parlé de BFS
dans les vidéos explicatives Pourquoi nous présente-t-on de
nouvelles structures de données et de nouveaux
algorithmes dans le cadre de ce projet ? Eh bien, il y a plusieurs
raisons à cela. Le principal est qu'
une grande partie du métier de programmeur consiste
à être capable de lire du code inconnu, le
comprendre au moins
partiellement, puis de le modifier. Il n'est pas vrai qu'il existe une quantité limitée de
Java que vous pouvez apprendre Et ce n'est qu'une fois
que
vous l'aurez appris que vous serez prêt à maîtriser
tous les codes du monde. La vérité est qu'il y a une tonne de gens intelligents. Et les gens utilisent toutes sortes d'
algorithmes et
de codes difficiles à comprendre. Il n'y a pas de quantité magique de Java que vous devez connaître avant d'être prêt
à affronter le monde. Apprendre à travailler
avec du code que vous ne connaissez pas à 100 % est
une réalité quotidienne. Si vous avez atteint ce stade dans
le cours, je suis heureuse que vous soyez toujours là et que vous
appreniez à apprendre avec moi. Très bien,
examinons enfin
de plus près certains
éléments clés de cette méthode. Regardez cette variable appelée, en particulier la ligne
ici qui indique la division des pôles. Cela permet de supprimer
une chaîne de la structure de
données, de la séparer en
composants à l' aide du délimiteur, puis d'enregistrer le résultat de cette division en coordonnées
disvariables Par exemple, si un élément
du Q était une chaîne B,
le résultat de la
division par le serait
un tableau à deux éléments
dont le premier élément serait
a du Q était une chaîne B,
le résultat de la
division par le serait
un tableau à deux éléments
dont le premier élément et le deuxième
élément B. Ici, vous pouvez voir
que dans notre cas, A est en fait
un index de ligne et B est en fait
un index de colonne Nous utilisons ces indices pour
sélectionner une cellule de notre tableau, puis c'est à nous de le faire. Il est en fait très difficile de comprendre ce que nous
devons faire ici. Si vous n'avez jamais vu BFS, ne vous découragez pas
si vous êtes perplexe. Mais je vais vous dire ce
qui se passe ici. Dans cette boucle qui suit
le to do, nous avons cette ligne A plus j. Comme vous pouvez probablement le deviner, Ad ajoutera la chaîne,
nous la donnons à Q. Une chose que vous ne
remarquerez peut-être pas immédiatement, c'est que nous pouvons ajouter des éléments à Q. Et puis nous ne quitterons jamais cette boucle qui vérifie
si Q est vide En gros, l'idée est que nous ne
voulons effectuer
cette boucle imbriquée ici, au plus qu'une fois, pour
chaque cellule du tableau Mais à l'heure actuelle, si vous avez
déjà vu la ligne A dans la colonne B, il se peut
que vous ajoutiez
accidentellement un B à Q et que vous retrouviez cette boucle
imbriquée Nous devons donc garder une trace de toutes les cellules que nous avons
déjà visitées. Nous voulons stocker
les cellules que nous avons déjà vues dans la structure de
données, puis exécuter cette
double boucle imbriquée
uniquement la cellule
en cours
n'a pas encore été visitée Connaissez-vous
une structure de données que nous avons découverte qui permet une insertion rapide
et des recherches rapides ? Pensez-y, je mettrai
la vidéo en pause et je
répondrai en 321, la réponse est un ensemble de hachages Nous pouvons stocker les cellules que nous avons déjà visitées dans un ensemble de hachages Cela signifie que si vous rencontrez une cellule qui ne figure pas
dans le jeu de hachage, cela signifie
que vous n'en avez jamais
rencontré auparavant De cette façon, nous pouvons nous
assurer de n'exécuter cette double boucle imbriquée qu'une seule fois sur
chaque cellule Voici ce que nous devons
faire Tout d'abord nous allons instancier notre
ensemble de hachage appelé scene Alors ici, nous allons d' abord vérifier si nous avons
déjà vu cette cellule ? Nous pouvons utiliser la méthode sets
contains pour T. Ensuite, nous enroulons l'intégralité de
cette boucle à
quatre imbriqués à l'intérieur d' ici et la retournons
en négatif Si nous n'avons pas encore
vu la cellule donnée, nous l'ajoutons au jeu de hachage de
la scène car
nous avons maintenant visité cette cellule Maintenant que nous avons
visité cette cellule, nous effectuons notre boucle. Maintenant, nous nous assurons que
cette boucle
ne sera plus jamais exécutée. Pourquoi est-ce le cas ? Eh bien, voyons voir, 1 seconde. Je crois que j'ai fait une erreur dans cette
indentation. Allons-y. OK. Pourquoi est-ce que cela fonctionne ? Imaginons que nous rencontrions une cellule qui n'a jamais été vue
auparavant. Ce ne sera pas à
l'intérieur de la scène. Nous l'ajoutons à la scène, puis nous effectuons
cette double boucle. Supposons que nous
ajoutions accidentellement la cellule que nous venons
de voir à l'intérieur de Q. Ensuite, lorsque nous
parcourons
la boucle, encore une fois, nous allons faire sortir la cellule que nous avons
déjà vue hors du que. Ensuite, nous allons vérifier si la scène ne contient pas de pop. Eh bien, comme nous avons
déjà ajouté la cellule que nous avons vue dans la
scène qui s'est installée ici, alors au moment où nous reviendrons à cette instruction if
au prochain tour, redeviendra fausse. Nous ne pourrons pas
exécuter cette boucle double imbriquée sur cette
cellule une autre fois. C'est tout pour cette vidéo. Nous avons maintenant accompli notre tâche. Il ne nous reste plus qu'une pièce pour pouvoir jouer à notre jeu. Je vous verrai dans la prochaine vidéo.
20. Procédure pas à pas 4 de Minesweeper: Bienvenue, mes amis. Dans cette vidéo nous allons enfin
terminer notre jeu. Lorsque vous aurez terminé
avec cette vidéo, vous devriez pouvoir jouer
au jeu de manière interactive et partager le lien avec vos amis pour qu'ils puissent également jouer. Très bien, pour la première
partie de cette présentation, nous allons
revenir sur Board Java En haut de ce fichier, vous devriez voir que cette carte de lettres à num est définie. Rappelez-vous que lorsque
vous jouez au jeu, nos commandes prennent la forme. Action, ligne, colonne comme a, B. Notre ligne et nos colonnes
sont saisies sous forme de lettres, mais nous devons convertir
ces lettres en index. Et notre tableau de déminage, nos index,
vont commencer
de haut en bas, de
gauche à En d'autres termes, A
correspond à l'index zéro, aux
cartes à l'index un, aux cartes à l'index
deux, etc. Ici, il suffit de définir ces mappages.
Faisons-le. Nous avons un mappage vers zéro, mappage vers une
chose rapide à noter, le fait que j'ai laissé une nouvelle ligne entre chaque paire de valeurs, les valeurs clés ne sont en fait
pas nécessaires. Vous pouvez également simplement
les mettre sur une seule ligne. Je l'ai juste mis en différentes
lignes pour le rendre plus beau. Assurez-vous également que vos clés
sont entourées de
guillemets doubles. Si vous mettez des guillemets simples, il s'agit en fait d'un type
Java différent appelé caractère. Ensuite, nous allons
passer à Java principal, faire défiler la page vers le bas jusqu'à l'endroit où nous
avons une ligne entière égale. C'est ici que nous effectuons la
conversion de la lettre en chiffre. Rappelez-vous que dans la vidéo
précédente où nous avons parlé de ce
tableau de commandes ici, lorsque nous le divisons par un espace, nous divisons la commande utilisateur
en trois éléments. La commande est le
premier élément, la lettre de ligne est
le deuxième élément et la lettre de colonne
est le troisième élément. N'oubliez pas que nos indices
commencent à zéro. Cela signifie que la lettre
de la ligne sera à l'index 1. Dans les commandes, récupérons le mappage numérique
de la ligne en faisant une lettre au
tableau sur nu map get commands one here. Cette carte de lettres à engourdissements est celle que nous venons de
définir ici Il va prendre la
lettre de ligne saisie par l'utilisateur
, puis récupérer l'index
numérique auquel cette lettre correspond et
que lettre correspond et
que nous venons de définir dans
l'autre classe De même, faisons la même chose pour
les commandes Letter to
Numb Mapget du tableau de
colonne Nous devons maintenant ajouter quelques améliorations et
corriger
une faute de frappe que j'ai commise dans vidéos
précédentes de Board Java où nous avons implémenté le regroupement des cellules vides
voisines, changement de scène en cellule de scène À la dernière ligne de
cette méthode, nous nous attendons
en fait
à l'existence d'une variable appelée cellules de scène. C'est ma faute, je m'excuse. Transformons la
scène en cellules de scène. Enfin, dans les
classes de cellules que nous avons implémentées lors de l'une des
premières étapes à ce sujet, assurez-vous
que le cas est tapé avant
le cas En effet, une fois que
vous appuyez sur une cellule, son état est définitif. Vous ne pouvez pas le signaler ou le désélectionner. Cependant, si son drapeau apparaît
en premier dans la méthode à deux chaînes, cela signifie que si vous abord
une cellule
puis que vous la touchez, le tableau affichera toujours le symbole triangulaire du plateau au lieu de
l' état tapé, car il coche
le drapeau avant
le taureau tapé Ne vous inquiétez pas si c'est un peu
confus, c'est un bogue délicat. Le but principal de ce projet
était de pratiquer le codage, pas de trouver des bogues obscurs.
Ne t'inquiète pas pour ça. Essayons maintenant de cliquer sur Exécuter et jouer à notre jeu. Sympa. Il semble que le
jeu fonctionne. Des
cellules numériques sont révélées, des cellules
vides sont
révélées aux bons endroits. Nous pouvons également essayer de signaler, et nous obtenons un drapeau
au bon endroit Très bien,
c'est tout pour cette vidéo. Merci d'être arrivé jusqu'ici. Vous pouvez maintenant jouer au jeu
et le partager avec vos amis. Je vous verrai dans la prochaine vidéo.
21. Module 2: Bonjour encore une fois. Bienvenue à
la fin de ce cours. Félicitations. Vous avez désormais
établi un tarif de mine fonctionnel par jeu qui peut générer
plus de 1 billion de configurations. Et vous pouvez
les utiliser pour défier vos amis et les mettre
en valeur sur votre CV. Et d'ailleurs, je
n'exagère pas, je veux vraiment dire
plus de 1 billion Tu peux vérifier mes
calculs. Vous avez également appris plusieurs manières
de concevoir du code. Utilisation de l'héritage,
des classes abstraites et des interfaces. Vous avez également découvert des structures de données
utiles telles que les cartes de hachage et les ensembles C'est peut-être difficile de me
croire en ce moment,
mais au fur et à mesure que
vous
progresserez
dans votre carrière, vous découvrirez que de nombreuses technologies
avancées reposent simplement
sur éléments de base tels que l'héritage et les structures de données de
base, comme celles que vous avez
apprises dans ce cours. Tu dois juste
me croire sur parole pour le moment. Mais j'espère qu' un jour tu comprendras ce que je veux dire. Plus important encore, la programmation est une compétence que tout le monde
apprend continuellement. Je ne promets pas de vous
avoir enseigné tout ce qu'il faut
savoir sur la programmation Java, mais j'espère
vous avoir donné une idée plus claire des principes fondamentaux afin
que vous soyez bien outillé pour
approfondir votre apprentissage par vous-même, ce soit dans le cadre de
mes prochains cours ou de ceux de quelqu'un d'autre. Encore une fois,
félicitations pour avoir terminé le cours, et je vous souhaite bonne
chance jusqu'à la prochaine fois.