Transcription
1. Introduction: Bonjour. Je m'appelle Derek et je vous souhaite
la bienvenue dans mon cours sur Java. Vous avez probablement vos
raisons d'être ici. Peut-être avez-vous récemment
consulté
Job Clinton pour faire défiler la page jusqu'à la section des
qualifications et rendu compte qu'ils exigeaient que
vous connaissiez Java et d'autres langages de programmation
comme condition préalable de base. Vous avez peut-être étudié les fourchettes de rémunération et rendu compte que
les ingénieurs logiciels sont payés très généreusement. Ou peut-être voulez-vous simplement
apprendre quelque chose d'
intéressant pour
démarrer la nouvelle année. Quelle que soit la raison pour laquelle
vous vous êtes retrouvé ici, Java est une excellente compétence à apprendre. Mais qu'est-ce que Java ? Java est un langage de programmation performant et
populaire, ce qui signifie que vous serez capable
d'écrire des programmes rapides. Vos compétences seront très
recherchées. Java est également facile à
prendre en main et transférable, ce qui signifie qu'une fois que
vous aurez appris Java, l'apprentissage d'autres langages de
programmation sera
encore plus facile. Maintenant, tout cela sonne bien, mais il existe des tonnes d'autres classes de
programmation. Pourquoi devraient-ils choisir celui-ci ? Eh bien, nous avons beaucoup de choses
en réserve pour vous. Tout d'abord, tout
le code source ce cours est prêt à être utilisé dans un environnement en ligne, ce qui signifie qu'il vous suffit appuyer sur le bouton vert Exécuter. Inutile de passer des heures à vous
cogner la tête contre votre ordinateur à essayer de
comprendre ce qui ne va pas avec
votre configuration locale. En un clic, vous êtes prêt à voir le
résultat de vos programmes. Nous avons également un
projet de CV très visuel prêt pour YouTube, ce qui signifie qu'à la
fin de ce cours, vous aurez quelque chose
à montrer à vos amis et à
mettre sur votre CV. Nous avons des exemples de code concrets dans chaque leçon afin que
vous ne soyez pas confus par des concepts abstraits. Les concepts
sont présentés avec une présentation visuelle facile à suivre. Enfin, je serai activement
maintenu dans ce cours. N'hésitez donc pas à poster des questions
si les choses ne sont pas claires. Avant de vous laisser
entrer dans le contenu du cours, je devrais probablement d'abord me
présenter. Je suis ingénieur
logiciel professionnel et, tout au long de ma carrière, j'ai travaillé dans certaines
des entreprises technologiques les plus célèbres et les plus
précieuses
au monde. J'ai une expérience concrète de la
fourniture de produits
techniques concrets, dont vous
avez peut-être déjà rencontré
certains. Avant d'être ingénieur
logiciel. J'ai enseigné l'
informatique
au premier cycle à l'université de Californie Berkeley, où nous
résolvons régulièrement des milliers d'
étudiants ce semestre. Course a été désigné comme l'un des
cinq meilleurs du pays par Bloomberg. Et je suis actuellement
l'un des professeurs de moins de 61 ans les plus populaires, une
chaîne YouTube du ministère a été visionnée environ 900 000
fois en 2022. Pendant mon séjour à Berkeley, je souhaite également obtenir de nombreux prix
d'enseignement et j' reçu le distingué
GSA Award en 2020, qui a été décerné aux 13
meilleurs professeurs et l'ensemble de l'informatique département sur
plusieurs centaines. Enfin, je suis
également titulaire d'un
diplôme d'études supérieures en informatique de Brooklyn. Comme vous pouvez le constater, j'aime tout ce qui concerne la technologie et
j'adore enseigner. Je suis très heureuse de vous
avoir avec moi pour le trajet. Une dernière chose avant de
commencer le cours, je vous demande de
créer un compte sur repl it.com et de vérifier votre e-mail
une fois que vous l'aurez fait. Maintenant, je sais que je sais. Peut-être que vous venez de créer un compte
Skillshare et que
vous n'êtes probablement pas d'
humeur à en créer un autre. Eh bien, comme je l'ai mentionné plus tôt, nous avons configuré un
environnement en ligne avec lequel vous pouvez jouer et
créer votre projet. Et croyez-moi, l'alternative
est bien pire. L'alternative à l'environnement
en ligne serait configurer un
environnement de développement local sur votre ordinateur. Il existe un
million de et
la résolution des problèmes peut prendre des
heures. Je vous demande donc de
consacrer quelques minutes dès maintenant pour créer
un compte ici. C'est tout pour moi dans cette vidéo, je vous retrouve dans la prochaine. Si vous souhaitez
accéder aux diapositives. Le lien sera affiché dans
la description du cours.
3. Méthodes: Bienvenue, mes amis. Dans cette vidéo, nous allons
parler de méthodes. Tout d'abord, qu'est-ce qu'une méthode ? Une méthode est à
peu près tout ce qui exécute une action
au sein d'une classe. Et la définition de
l'inaction est assez large. Ça peut être n'importe quoi. Cela
peut être une simple arithmétique. Il pourrait y avoir un algorithme d'apprentissage
automatique en cours d'exécution. Il peut s'agir du rendu d'une image. Les classes contiennent des méthodes, et méthodes contiennent toute la
logique d'un programme. Maintenant, les méthodes doivent être déclarées avant de pouvoir commencer à y
écrire de la logique. Cette déclaration comporte quatre éléments
. Tout d'abord, nous avons le modificateur
d'accès. Nous en avons quatre types :
public, privé, privé et protégé. modificateur d'accès
sur une méthode Mirth fonctionne exactement de la même
manière qu'il fonctionne pour les classes. Si l'axe n'est pas
explicitement indiqué, la méthode utilise par défaut
package private, comme le ferait une classe. Une méthode publique est une méthode qui peut être référencée à partir de n'importe quelle classe. La méthode privée du package Panda est une méthode
accessible uniquement si elle est référencée à partir d'une méthode d' une classe au sein du même package. Rappelons également que promis
précédemment, j'expliquerai privé et protégé une fois que nous aurons commencé à
parler de méthodes, eh bien, il s'avère que nous
devons en savoir encore plus sur Java avant de pouvoir
parler de protégé. Nous allons donc laisser
celui-ci de côté pour le moment. Cependant, nous pouvons parler de code
privé marqué comme privé uniquement accessible
au sein de la même classe. Donc, par exemple, si je déclarais que la
méthode X est privée, cela signifie
que seules
les
autres méthodes de la même classe seraient
autorisées à référencer la méthode X. Les méthodes d'autres classes
quel que soit leur package, ne serait pas autorisé à faire
référence à une méthode privée. Ensuite, nous avons la statique. Nous pouvons choisir d'omettre le mot
statique dans notre déclaration, auquel cas la méthode
sera par défaut non statique. Maintenant, ne vous inquiétez pas de ce que signifie réellement
statique pour l'instant. Malheureusement, vous aurez
besoin de plus de contexte sur Java avant de
pouvoir le comprendre. Donc, pour l'instant, sachez simplement
que le mot clé statique existe et qu'il vient après
le modificateur d'accès. Ensuite, nous avons le type de retour qui doit toujours être présent. Le type de retour est, comme son nom l'indique, le type de la valeur
renvoyée par une méthode. Dans ce cas, rien n'est
renvoyé par cette méthode. Nous disons donc que son
type de retour est nul. Maintenant, vous êtes peut-être un peu
confus quant à ce que
signifie le fait pour une méthode
de renvoyer quelque chose. La valeur de retour d'une
méthode est la valeur de sortie. Par exemple, imaginez que nous ayons
une méthode appelée add et qu'elle ne fait qu'
ajouter deux entiers ensemble. Donc, par exemple l'
addition de 1,2 nous donne trois. En programmation, nous
appellerons ces trois la valeur renvoyée par
la fonction add. La valeur de retour est
synonyme de la valeur de sortie. Et dans ce camp et
dans notre exemple d'annonce, le type de la
valeur de retour serait un entier, puisque trois est un entier. Enfin, nous avons
le nom de la méthode. Les noms peuvent généralement être
ce que vous voulez qu'ils soient. La seule restriction,
je crois, est que le premier caractère du nom de la
méthode doit être une lettre. Parlons maintenant des types en Java. Comme nous l'avons dit dans la diapositive
précédente, chaque méthode doit
renvoyer du type. Il est donc important que nous
comprenions quels peuvent être certains
de ces types. abord, nous avons une chaîne, qui est un texte lisible par
l'homme entre guillemets doubles. Souvenez-vous que dans la diapositive précédente, nous avions Hello World , juste ici. Il s'agit d'un texte
lisible par l'homme à double quota. Il s'agit d'un exemple de chaîne. Ensuite, nous avons un entier, un int, qui est le
langage Java pour entier. Nous avons également des nombres flottants, qui sont la façon dont Java
prononce un nombre avec
une virgule décimale, comme 1.3. Par exemple nous avons des booléens qui sont des valeurs qui ne peuvent
être que vraies ou fausses. Nous avons également des types de tableaux, qui ressemblaient à des crochets, crochets ou des
crochets booléens. Un tableau d'éléments est
essentiellement une collection ordonnée
d'éléments du type. Donc, par exemple, si nous
spécifions entre crochets, cela signifie
que cette valeur sera une
collection ordonnée d'entiers. Et si nous avons un
crochet booléen, un crochet, alors ce sera une collection de valeurs vraies ou fausses. Java a bien plus
de types que justice, mais ce sont quelques-uns des types les
plus courants que vous verrez. Et ils constitueront
une bonne base pour le reste
de ce cours. Ensuite, nous devons
parler des arguments de méthode. Un argument de méthode est simplement
une manière formelle de dire les entrées ou
les paramètres d'une méthode. Les arguments de la
méthode sont indiqués
entre parenthèses après le
nom de la méthode. Et le type Java
des arguments doit être explicitement spécifié. Par exemple, nous avons ici un type de tableau de chaînes et on
nous donne le nom
de l'argument args. Cela signifie que lorsque
nous appelons cette méthode, nous devons lui donner une entrée
de type tableau de chaînes. Sinon, Java refusera de compiler le code
et ne s'exécutera pas. Il y a quelques
points subtils dont vous devez être conscient. La première est que cette méthode principale ici est très spéciale. généralement d'une application Java, nous aurons plusieurs fichiers s'agit généralement d'une application Java,
nous aurons plusieurs fichiers
et nous devrons
spécifier un point d'entrée. Sinon, Java n'
aurait aucun moyen de savoir quel morceau de code
commence à s'exécuter en premier. Dans ce cas, nous
préciserons que nous voulons que la classe helloworld
soit notre point d'entrée. À ce moment-là, Java
rechercherait une méthode principale ayant
exactement cette signature, public static, void main avec un argument de
type tableau de chaînes. Il exécutera cette
méthode si elle existe en tant
que point d'entrée initial
dans le programme. Sinon, Java
générera une erreur indiquant qu'aucune méthode
principale n'est définie. Ensuite, si vous souhaitez qu' une méthode prenne
plusieurs arguments, nous devrons saisir
explicitement chacun de ces arguments et les
séparer par une virgule. Dans cet exemple d'annonce, nous avons deux arguments, x et y, et nous indiquons les
types Int pour les deux. Et cette fonction
add renvoie simplement le résultat de l'ajout de ces
deux nombres, renvoie x plus y. titre de remarque, notez
que lorsque nous spécifiez un type de retour et la signature de la
méthode, par exemple ici, nous doit
inclure une ligne dans cette méthode qui
indique explicitement le retour dans le Maine, par exemple nous avons un vide, ce qui
signifie que nous ne renvoyons rien. Notez qu'aucune ligne
de cette méthode ne dit return. Troisièmement, c'est tout
à fait normal de n'avoir aucun argument. Vous devez simplement
mettre un ensemble vide de parenthèses après
le nom de la méthode. Maintenant, vous pensez peut-être que
cette exigence de
taper explicitement tout
en Java est vraiment fastidieuse et n'
existe que pour vous ralentir. Mais si c'était vrai,
Java ne serait pas l'un des langages
de programmation
et de l'industrie du logiciel les plus populaires aujourd'hui. La raison pour laquelle nous avons ces
exigences est qu'elles permettent à
Java d'effectuer ce que nous
appelons la vérification au moment de la compilation. Avant d'exécuter un programme Java, votre ordinateur doit d'abord convertir le code
en code octet. Nous appelons ce processus
compilation. Lorsque la
compilation est terminée et que vous exécutez le programme, vous exécutez en fait le
bytecode produit. Maintenant, l'avantage
d'avoir une
étape de compilation avant d'exécuter
le code est que le compilateur Java
est capable d'analyser votre code et d'effectuer
quelques vérifications de base. L'une de ces
vérifications de bon sens consiste à vérifier que tous les types spécifiés dans
votre logique sont cohérents. Par exemple, comme nous
l'avons mentionné plus tôt ici, attend deux entiers. Imaginez si j'essayais de
transmettre le chiffre deux, une chaîne, Hello World,
comme arguments à une annonce. Eh bien, cela n'aurait aucun sens. Comment ajouter le chiffre deux à un texte Hello World. L'avantage de Java est donc qu' il exécutera ces vérifications de
bon fonctionnement au moment de la
compilation et vous avertira de toute erreur avant que
le code ne soit exécuté. Dans d'autres langages sans vérification au
moment de la compilation, il se peut qu'il y ait un problème
dans votre code dont vous ne serez pas informé
avant son exécution. Et cela pourrait être
très dévastateur si votre code est déployé, par exemple, dans une banque ou peut-être sur Google, qui est utilisé par 1
milliard de personnes chaque jour. Parlons maintenant du corps
de la méthode. D'abord. Le corps de la méthode est simplement tout le code
entre crochets. n'y a pas vraiment de
restriction quant à ce que vous pouvez faire dans le corps et la méthode que vous
utilisez peut être aussi longue que vous le souhaitez. Quelle que soit la logique que
vous décidez d'appliquer. La principale chose
à vérifier est que le type de valeur
de retour doit correspondre au retour
spécifié dans la déclaration de méthode. Ici, nous en retournons une, qui est une variable
que nous avons déclarée et initialisée avec
la valeur x plus y. Puisque x et y sont tous deux des entiers, l'ajout de deux
est également un entier. Par conséquent, le renvoi d'une
somme est
conforme à notre exigence de
renvoyer un int dans cette méthode. Le point suivant
que je tiens à souligner est que la
ligne de retour est terminale. La compilation Java
échouera si vous essayez de placer du code après la ligne de
retour dans une méthode, ce qui est logique puisque la valeur de retour est la valeur de
sortie de la méthode. Pourquoi exécuter une logique supplémentaire alors que vous avez déjà
généré une valeur finale ? Nous devons également parler
un peu des variables que vous créez et
utilisez dans une méthode. Tout comme les arguments de méthode, les variables que vous avez définies
dans la méthode doivent être saisies explicitement
lorsque vous les créez. Et vous pouvez les nommer
comme vous le souhaitez tant que le premier caractère
du nom est une lettre. Après avoir déclaré la
somme de la variable sous la forme d'un int, par exemple, nous ne pouvons plus changer son
type dans la même méthode. Je ne peux donc pas faire quelque chose comme si
int sum était égal à x plus y. Et puis dans la ligne suivante, faire une somme de chaînes égale Hello World. Bien que vous ne puissiez pas
modifier le type de somme, vous pouvez modifier sa valeur. Et lorsque vous le faites, vous n' avez
pas besoin de le saisir explicitement. Donc, une fois que la
somme entière de la mine est égale à x plus y, je peux faire quelque chose comme si la somme était
égale à un sans la, sans la déclaration
de type explicite. Et d'ailleurs, ces
trois affirmations
ne sont vraies que dans
le cadre de la même méthode. Je pourrais avoir une méthode complètement différente
appelée Soustraction. Et soustrayez, je pourrais déclarer que la somme est une
chaîne si je le souhaite. Cette variable devrait
rester une chaîne
au sein de cette méthode. Les variables
de méthode d'une méthode sont indépendantes des
variables de méthode d'une autre méthode. Maintenant que nous savons
comment définir les méthodes, voyons comment nous les utilisons. C'est ce que nous appelons un appel de méthode. Lorsque nous avons référencé
le nom de la méthode et passé des arguments
entre parenthèses, comme vous pouvez probablement le
deviner, sur 12 le code renvoyé x plus
y sera exécuté. Et cette
valeur renvoyée va
maintenant être liée à X dans le Maine. D'ailleurs, cette chose que
nous utilisons depuis toujours, le système point out, point print
LN, est également une méthode. Il consiste en une référence
au nom d'une méthode et comporte des parenthèses dans lesquelles nous passons un argument pour notre voyage
à imprimer à l'écran. Dans ce cas, la valeur
de x, qui est trois. La raison pour laquelle nous avons besoin de
tous ces points aura plus de
sens dans la future vidéo. Quiz pop. Comment Java sait-il imprimer la valeur trois ? Dans ce cas, au lieu du
caractère littéral x que nous avons
transmis à l'impression,
allez-y et mettez la vidéo en pause. Je révélerai la réponse en 321. La raison pour laquelle Java
sait en imprimer trois est que ce x ne l'est pas Nous avons cité le X avec des
guillemets doubles autour de celui-ci. Java traiterait x comme
un caractère littéral x, puisqu'il n'est pas entouré de guillemets
doubles Java comprend que x est un nom de variable auquel une
valeur est attachée. Il
évaluera donc d'abord ce qu'est x ,
puis affichera le
résultat de cette évaluation. Voici les liens vers les
exemples de code utilisant cette vidéo. Comme nous avons abordé une bonne
partie du contenu dans cette vidéo, je vous demande de
consulter ces liens. Cliquez, forchez, ondulez et
bricolez le code. Il n'est pas nécessaire que ce
soit quelque chose de fantaisiste. Essayez simplement d'ajouter
des variables aux corps des méthodes ou de modifier le type de retour et la déclaration de méthode. Et au fait, n'oubliez pas
d'ajouter des points-virgules. Les lignes Java doivent
se terminer par un point-virgule sauf si vous ouvrez un nouveau bloc de code avec
des crochets ondulés.
4. Replit une démonstration: Dans cette vidéo, je
souhaite vous donner un bref aperçu de l'environnement
Ripple. Et ce que je veux dire quand
je dis que je vous
encourage à modifier le code. Tout d'abord, assurez-vous d'avoir créé
un compte sur repl it.com. Je sais que c'est un peu ennuyeux de
créer un autre compte, mais
l'alternative est de configurer un
environnement de programmation local sur votre ordinateur. Le problème, c'est que je ne sais pas quel
ordinateur vous avez. Je ne sais pas quel système d'exploitation
vous utilisez et je ne sais pas quelles sont les variables d'
environnement, les alias que vous avez configurés
sur votre ordinateur. Quand j'enseignais
à l'université de
Berkeley , il
me fallait parfois plus d'une heure pour configurer un
environnement local pour un petit groupe d'une
dizaine d'étudiants. Et étant donné que les classes de partage de
compétences ont
fondamentalement une capacité
illimitée, les frais
associés à la configuration elle seule
prendraient beaucoup de temps. Il s'agit d'un cours sur Java, pas sur les ordinateurs et les
réponses, il a déjà
configuré Java pour vous. Je pense qu'il s'agit d'une ressource extrêmement précieuse
que vous pouvez utiliser.
De plus, elle est gratuite pour
nos cas d'utilisation. Maintenant, si nous consultons ces
liens dans les diapositives, voici à quoi cela
ressemble lorsque nous
consultons le lien dans la diapositive. Une fois que vous avez créé un compte
REPL, allez-y et cliquez sur le bouton
Grappled ici. Nous avons maintenant une copie du
projet sur votre compte. C'est le code de la
vidéo sur l'anatomie de la programmation. La barre latérale vous
permet d' explorer la
structure des fichiers du projet. Nous pouvons cliquer dans le dossier pour développer son contenu
et cliquer sur Insérer un nom de fichier pour
afficher son contenu ici. Dans cet exemple, la méthode
principale affiche simplement Hello World. Alors vérifions la santé mentale. Allez-y et cliquez sur
le bouton vert. Vous pouvez ignorer les textes
cryptiques ici. Il s'agit simplement de REPL, son
système sous-jacent, qui émet des commandes de construction et d'exécution. Essayons maintenant de créer une autre ondulation et d'y
apporter des modifications. Voici le code de
la vidéo sur les méthodes. Allons-y et essayons de
faire la même chose. Voici donc le lien. Encore une fois. Cliquez sur Fork Ripple
et créons-le sur notre compte. Voyons maintenant ce que nous pouvons faire. Tout d'abord, il suffit de vérifier
le bon fonctionnement à l'aide du bouton vert et de
s'assurer que ces valeurs de la
méthode principale sont imprimées. Bon, nous pouvons maintenant voir que nous avons imprimé
le numéro trois. Et si vous
regardez le code,
cela devrait, cela
devrait avoir du sens. Nous avons sur 12 et
nous sommes en train d'imprimer le résultat de l'ajout de
1.2, soit trois. Voyons maintenant si nous pouvons
ajouter deux appels de méthode ensemble. Ce serait donc le premier exemple
de modification du code. Disons que nous avons
ajouté un à plus un. Puisqu'en appeler un
renverra un numéro un. Il
semble raisonnable d'en
ajouter un au
résultat de l'ajout de 1.2. Allons-y et exécutons-le. Maintenant, vous voyez que
nous avons une erreur. Cela indique que nous avons 21
mots et non une déclaration, faites les autres comme
prévu, un point-virgule. Comme vous l'avez peut-être remarqué, toutes les lignes Java se terminent
par un point-virgule, l'
exception de celles qui sont ouvertes,
de nouveaux blocs de code
tels que les déclarations de méthodes. Il
serait donc peut-être prudent de notre part d'ajouter un point-virgule
à la fin. Maintenant, allons-y et
réexécutons ce code. OK, nous avons donc toujours cette erreur, pas une erreur de déclaration, mais au moins nous nous sommes
débarrassés de l'erreur du point-virgule. Donc, ne pas faire de déclaration est
une grosse erreur. Alors allons-y
et recherchez-le sur Google. Allons-y,
copiez-collez ceci. Accédez à Google et passez à Java. Ce n'est pas une déclaration. Nous cliquons sur le
premier résultat Stack. Overflow est une ressource extrêmement utile pour
la plupart des programmeurs. Et nous pouvons faire défiler la page vers
le bas jusqu'à la réponse ici. Et remarquez ce
qu'ils disent. Ils disent. Java restreint les types
d'expressions
autorisés et ce que l'on appelle des déclarations
d'expression. Cela interdit les déclarations sémantiquement
dénuées de sens comme zéro ou a plus b.
Hé, devinez quoi ? N'est-ce pas exactement ce que
nous faisions tout à l'heure ? Nous ajoutons un à un point-virgule
plus un, qui est fondamentalement la même
forme qu'un point-virgule plus b. Si nous faisons défiler la page un peu plus vers le bas, vous verrez qu'ils
contiennent une citation de la spécification du langage Java. Certains types d'
expressions peuvent être utilisés comme des
déclarations en les faisant suivre par des points-virgules. Et puis nous jetons un coup d'
œil à la liste ici. Eh bien, nous avons une
assignation qui est répertoriée comme un exemple
d'expression valide. Revenons donc à notre
code et transformons-le en une expression d'affectation
qui ressemblerait à ceci. Y est égal à ajouter un à plus un. Allons-y et
exécutons-le encore une fois. Et maintenant, le code se compile
et s'exécute correctement. Nous ne voyons pas le
résultat de l'ajout de 12.1 car nous
ne l'avons pas imprimée. Allons-y, ajoutons
cette ligne et recommençons. OK, et maintenant nous avons un quatre, ce qui est logique parce que
nous avons ajouté un à deux, puis
un autre, soit quatre. Essayons maintenant de
trouver une méthode, une autre méthode
qui n'a pas le mot clé static
et voyons ce qui se passe. Alors peut-être que cela appelle ce
public à revenir. Et encore une fois, notez que j'ai
omis le mot clé static. Essayons maintenant de voir
ce qui se passe si nous faisons 12 plus un plus deux. Allons-y et
exécutons ce code. Intéressant. Nous avons une autre
erreur Java cette fois. La méthode non statique ne peut pas être référencée à partir d'un contexte
statique. Ils ont donc même ce point direct sur
la méthode
non statique à l'origine de l'air. C'est donc une erreur
Java qui est en fait
légèrement plus utile. Ils vous indiquent que les méthodes
non statiques ne peuvent pas être référencées à partir de méthodes statiques. Et la deuxième est notre méthode
non statique. Maintenant, nous n'avons pas encore
parlé de ce que signifie statique. Alors ne t'inquiète pas pour ça. Nous allons en
parler dans une prochaine vidéo et ce message d'erreur
aura plus de sens. Ensuite, le principal point à retenir est l'importance de
bricoler le code. Même si nous avons cassé le
code à plusieurs reprises, nous apprenons des choses sur Java qui nous
aideront plus tard
. Il est préférable de
commettre ces erreurs dès maintenant sur de nombreux projets
associés à ces vidéos afin de ne pas
vous perdre plus tard lorsque vous travaillerez
sur des projets plus importants.
5. Contrôle: Bienvenue, mes amis. Dans cette vidéo, nous allons
parler du contrôle. Pour exécuter un flux logique plus
complexe en Java, nous devons d'abord comprendre
certains opérateurs courants. Tout d'abord, nous avons quelques opérateurs
arithmétiques de base qui s'
expliquent d'eux-mêmes. Ce sont les symboles du plus, moins et du temps, et ils fonctionnent exactement
comme vous vous y attendez. Ils ajoutent, soustraient et
multiplient respectivement. Le symbole de la barre oblique est l'opérateur de division de
Java. Mais il convient de noter
que la division sur des
entiers en Java est une opération de division plancher, une opération de division plancher, ce qui signifie qu'elle est arrondie
à l'entier inférieur le plus proche, par exemple 3/2, et le langage normal est 1,5. Cependant, à Java, trois, en
Floride, deux, c'est un. Comme nous arrondissons à partir de 1,5%, le symbole est appelé
modulo ou mod en abrégé. Il renvoie le reste
d'une division, par exemple 14 mod quatre est deux. Pourquoi ? Parce que quatre, c'est 143 fois et il ne nous reste que
les deux autres. Si vous ne savez pas
ce qu'
est un reste , je vous recommande de le rechercher, puis de revenir à cette vidéo et de rejouer les
dernières secondes pour confirmer que 14 mod
quatre font bien deux. Le signe égal correspond à la façon dont nous attribuons des valeurs aux variables
que nous avons vues plus tôt, comme int x égal à un. Nous avons également des opérateurs
booléens, comme leur nom l'indique, ce sont des opérateurs qui renvoient
vrai ou faux. abord, nous avons des
opérateurs assez explicites supérieurs à, inférieurs à,
supérieurs ou égaux à, et inférieurs ou égaux à. Ce point d'exclamation passe de vrai à faux et de faux à vrai. Dans
la diapositive suivante, nous vous expliquerons comment fonctionne
la syntaxe précise
de cette méthode. Maintenant, nous avons deux égaux. Cela signifie renvoyer vrai s'il est égal, renvoyer faux s'il n'est pas égal. Rappelez-vous ceci, puisque
c'est un peu délicat, signe
double égal est
utilisé pour comparer l'égalité. Le signe égal unique est
utilisé pour attribuer des valeurs. double esperluette
signifie renvoyer vrai si les deux conditions sont vraies,
sinon renvoie faux. Et cette double ligne droite
signifie qu'il faut renvoyer vrai si une des conditions est vraie,
sinon renvoyer faux. Cet opérateur n'est peut-être pas
familier à la plupart des gens. Voici donc où il se trouve.
Sur un clavier Logitech. Il se trouve généralement à côté
des touches de support. Regardons quelques
exemples d'utilisation. Premièrement, un plus deux est évidemment 3,1 moins deux est
évidemment moins un. Rien de compliqué là-dedans. Maintenant, pour le quotient
où nous avons 3/2, rappelons que la division Java
sur les entiers est pour la division 3/2 est un. Puisque nous
arrondissons à partir de 1,5, produit est égal à six. Rien de compliqué là-dedans.
Trois fois deux font six, et Java ne fait
rien de spécial avec ça. Le reste est égal à
un parce que deux devient cinq deux fois et il nous reste
un après avoir obtenu,
après avoir multiplié deux par deux,
ce trait de soulignement booléen
vrai, vrai zéro
est égal à vrai parce que nous a ajouté ce
point d'exclamation juste avant un faux. Ainsi, le point d'
exclamation transforme les fausses expressions en expressions vraies et les
expressions vraies en
fausses expressions. Donc, c'est vrai, soulignement
vrai un est également vrai parce que trois est en effet
supérieur à moins un. vrai trait de soulignement deux
est également vrai car nous nions que zéro
est égal à un. Eh bien, zéro n'est pas égal à un. Donc, cette expression entre
parenthèses va
renvoyer false. Alors l'inversion de
cette tendance sera vraie. Donc, True Underscore
Two devient vrai. Faux trait de soulignement zéro
est égal à faux. Car n'oubliez pas que la
double esperluette ne renvoie la valeur vraie que si les deux
expressions sont vraies. Vrai, le trait de soulignement zéro est vrai. Cependant, l'inversion du vrai trait de soulignement 1
sera fausse. Il n'est donc pas
vrai que les deux soient vrais, et donc le
résultat est faux. Enfin, le trait de soulignement vrai
trois sera égal à vrai parce que nous appelons cette
double ligne droite, elle renvoie vrai si l'une
des conditions est vraie. Dans ce cas, le faux
trait de soulignement zéro est faux. Cependant, le vrai trait de soulignement
zéro est vrai. Par conséquent, comme l'une
des conditions était vraie, l'expression entière
est considérée comme vraie. Maintenant que nous avons abordé les opérateurs de
base, voyons comment contrôler le flux de logique
au sein d'un programme. Tout d'abord, nous avons
le modèle if-else. Nous plaçons une
expression booléenne
entre parenthèses immédiatement
après l'opérateur IF. Si cette expression prend ici
la valeur vraie, nous exécuterons
toute
la logique entre accolades qui suivent
immédiatement l'expression
booléenne. Dans ce cas, renvoyez x plus y. Cette expression
prend la valeur false. Ensuite, nous ignorerions tout le code
contenant les accolades ici, et exécuterions plutôt
le code entre accolades du cas
else ici, dans ce cas, renvoie zéro. Souvenez-vous d'une vidéo précédente où j'ai mentionné que le retour est terminal et que nous ne devrions
pas avoir de ligne de code
après une ligne de retour. Alors pourquoi est-ce que nous avons plusieurs
lignes de retour ici ? Pensez-y et je
révélerai la réponse en 321. La raison en est qu'un seul de ces blocs de code est exécuté chaque fois que la méthode est appelée. Ces blocs de code s'
excluent mutuellement 100 % du temps. Le point subtil du fait que les mines à
retour sont
terminales est qu'elles ne
le sont que pour le bloc de code dans lequel elles se trouvent. Et cela a du sens
si vous y réfléchissez. Cet exemple de méthode a été déclaré comme
renvoyant un entier. Imaginez si nous n'écrivions que
cette ligne de retour x plus y, mais que nous n'avions pas
cette ligne de retour zéro. Imaginons ensuite
que nous transmettions un x tel que cette expression
soit considérée comme fausse. Ensuite, nous sauterions cette ligne de
retour et arriverions
au bloc else où nous n'avons plus de retour
zéro, alors cette méthode ne
renverra rien. Et alors cette méthode ne
respecterait pas
cette promesse de renvoyer un entier. Cela conduirait donc à un échec de compilation
Java. Voici un autre modèle if-else, mais cette fois en utilisant certains opérateurs dont nous avons
parlé plus tôt. Encore une fois, nous mettons l'
expression booléenne entière entre parenthèses. Si x mod deux est égal à un, ou y mm R2 est égal à zéro. Ensuite, nous exécutons l'intégralité
du bloc de code renvoyé X plus Y. Sinon, si les deux conditions
sont fausses, nous renvoyons zéro. Voici un autre exemple, introduisant cette fois un nouvel opérateur. Sinon, si le nom de l'
opérateur est assez intuitif et qu'il fait ce à quoi
vous pourriez vous attendre si cette expression booléenne
devait être évaluée à faux. Il ignorerait la ligne de retour x plus y, puis essaierait d' évaluer l'expression booléenne contenue dans la ligne else-if. Si cette expression x mod
trois est égale à un, donne la valeur vraie,
alors nous renvoyons x. Sinon, si cette
expression était fausse, nous passerions à renvoyer x
et passerions au cas contraire, auquel cas nous revenons à y. Maintenant, parlons
du schéma sauvage. Parfois, vous pouvez
trouver utile d' exécuter un certain
bloc de code plusieurs fois. Supposons, par exemple, que vous souhaitiez
imprimer des
nombres de un à mille. Une façon de le faire
serait d'écrire system.out.print
LAN 1 000 fois. Mais une autre façon de
le faire serait d'
écrire un système unique,
point out print LN, et de l'inclure dans
un bloc de code générique. Voici donc un exemple. La façon dont cela fonctionne est que nous évaluons d'
abord l'
expression ici. Et bien que n soit
supérieur à zéro, si cela est vrai, nous
exécutons tout le code contenu dans
ce bloc de code. À la fin du bloc de code, nous sommes revenus au point de départ et avons de nouveau évalué cette
expression. Est-ce que n est supérieur à zéro ? Si c'est le cas, nous exécutons à nouveau le bloc de
code. Et puis nous répétons, en
revenant à cette expression booléenne encore et encore jusqu'à ce qu'elle soit fausse. Cette syntaxe vous est peut-être un
peu inconnue. Décomposons-le en
commençant par cette droite, n est égal à n moins un. Rappelons que l'opérateur égal signifie attribuer une
valeur à une variable n. Mais avant de pouvoir
attribuer une valeur à n, nous devons d'abord
comprendre quelle est la valeur de cette
expression, n moins un. Donc, en gros, cela permet soustraire d'abord
un à n, puis une fois que c'est fait, d'
attribuer cette valeur à n. Donc, en fait, nous
diminuons simplement la
valeur de n d'un. Donc, si n est égal à cinq, nous évaluons cinq moins 15, moins un est quatre, puis nous attribuons la
valeur quatre à n. Donc n est maintenant pour ces deux
autres droites et moins, moins et moins est égal à un, ce
sont en fait
deux abréviations pour la même chose, n est égal à n moins un. Ainsi, l'ensemble de ce
bloc de
code décrémente effectivement n de trois à
chaque exécution. syntaxe similaire existe si vous souhaitez augmenter
la valeur de n, nous pouvons simplement faire
n plus plus et
plus est égal à un et
n est égal à n plus un. J'aimerais également
émettre un avertissement. Java effectue de nombreux
contrôles d'intégrité au moment de la compilation. Mais une chose qui
ne permet pas de vérifier si votre boucle
se terminera. Par exemple, imaginez que ces trois lignes soient
toutes incrémentées. Nous augmentons la
valeur de n. Ainsi, n plus plus et plus sont égaux à
un et n est égal à n plus un. Maintenant, imaginez que nous
transmettions également une valeur de n déjà
supérieure à zéro, alors ce bloc de code
augmentera n encore plus. Et cette expression, juste ici, et supérieure à zéro, ne
sera jamais fausse. Et donc, ce bloc de code va fonctionner indéfiniment. Si cela se produit, votre code ne produira pas d'erreur et le compilateur n'en produira pas non
plus. Il continuera à fonctionner indéfiniment jusqu'à ce que vous reconnaissiez le
problème et que vous arrêtiez le code. Soyez donc attentif lorsque
vous écrivez des boucles et assurez-vous que votre condition
finira par prendre fin. Voici notre schéma
de contrôle final pour cette vidéo. Voici un exemple. Nous en avons quatre
suivies de trois expressions entre
parenthèses et délimitées par des points-virgules. La première expression est
en cours d'initialisation. La variable i n'
existe pas encore dans cette méthode, nous la déclarons et
lui attribuons une valeur zéro. Ensuite, nous avons l'expression
booléenne, similaire à l'
expression booléenne de la boucle while. Il s'agit d'une
expression booléenne qui va
être évaluée avant
l'exécution du bloc de code. Si c'est vrai, nous
exécutons le bloc de code. Si c'est faux, nous sortons
du bloc de code et
exécutons code qui vient
après cette boucle for. Enfin, nous avons changé d'État. Cet I plus plus est exécuté
après l'exécution du bloc de code. Donc, puisque nous partons de zéro et que nous courons
jusqu'à ce que I ne soit plus inférieur à n et que I augmente d'un à
chaque itération. nous imprimons
simplement
des nombres de zéro à n moins un. Voici quelques autres
exemples de boucles à quatre voies. Notez ici que nous
pouvons initialiser i, une
ligne de code entièrement distincte. Si aucune initialisation n'est
requise pour la boucle for. Permettez-moi simplement de mettre un
point-virgule et de laisser la première
expression d'initialisation vide. Nous avons ici un autre exemple. Je veux que vous preniez
particulièrement note de l'initialisation ici. Rappelez-vous de notre leçon précédente qu'une fois qu'une variable
a été déclarée, références
futures
à cette variable n'ont pas besoin d'être
saisies pour être spécifiées. C'est la raison pour laquelle
nous disons ici seulement I est égal à trois, mais pas int I est égal à trois. Les mêmes règles s'appliquent à la
fois à l'
expression d'initialisation et aux
expressions autonomes en dehors des parenthèses de la boucle for. Maintenant, vous vous
demandez peut-être quelle est la différence
entre une boucle for et
une boucle while, si
ce n'est que la syntaxe
est différente ? Eh bien, la réponse est que c' en fait
la même chose. En fait, la seule
différence majeure réside dans leur syntaxe. Ne réfléchissez donc pas trop aux différences
qui pourraient exister
entre les deux. Voici le lien vers le
code utilisé dans cette vidéo. Comme toujours, veuillez
cliquer sur le lien, cliquer pour saisir
et expérimenter le code. Une chose que j'aimerais
que vous essayiez cette fois, c'est que si vous
rencontrez des erreurs Java que vous pourriez trouver un peu
cryptiques, je
vous encourage à copier et coller ce message
d'erreur dans Google. La cause première des messages d'erreur est généralement assez similaire. Et vous trouverez souvent des résultats
très utiles sur les forums
de programmation
que Google dirige C2.
6. Objets Partie 1: Bienvenue, mes amis. Aujourd'hui, nous allons
parler d'objets. Maintenant, je me suis rendu compte
que, cela semble vraiment stupide, que nous allions
parler d'objets. Mais je te promets que
tu vas apprendre quelque chose de précieux à
la fin de cette leçon. Maintenant, avant d'entrer dans
le contenu de cette vidéo, laissez-moi essayer de vous
convaincre pourquoi vous
devriez vous intéresser aux objets. Jusqu'à présent, nous n'avons traité que de l'
aspect fonctionnel de Java, comme les méthodes
et la logique de contrôle. Cependant, Java est
en fait ce que nous appelons un langage
orienté objet. Cela signifie que nous considérons nos
programmes comme des objets dotés comportements plutôt que comme un
ensemble de fonctions. Cela peut être un peu
difficile à comprendre. Une analogie à laquelle vous pourriez penser est
la façon dont vous regardez un jeu vidéo. Disons Mario, par exemple au cas où vous ne
connaîtriez pas Mario. Voici une capture d'écran de
l'un des jeux Mario. Ce gars, c'est Mario. Et le principe du
jeu est de devoir encore
surmonter un tas d'obstacles
pour atteindre une princesse. Et ces drôles de
champignons ici, ils bougent généralement et s'ils te touchent,
tu perds une vie. Maintenant, un jeu Mario est évidemment
un morceau de code, non ? Il y a probablement un code qui vérifie la
distance entre le champignon et Mario. Et à distance, il y a
moins d'un certain seuil. Ensuite, on en soustrait un
à la vie de Mario. Mais ce n'est pas ainsi
que nous pensons de ce jeu. Nous ne considérons pas ces
champignons comme des méthodes qui permettent vérifier
constamment la distance qui nous sépare de Mario. Et nous ne pensons pas qu'un Mario un ensemble de méthodes
qui
calculent constamment sa vitesse verticale
et horizontale. Nous pensons simplement à Mario comme une entité unique qui fait preuve d'un comportement de saut et de
course. Et nous considérons ces
champignons comme des entités qui essaient activement
de nous empêcher de sauver la princesse. paradigme est
le même que celui que nous
avons entre Java en
tant que langage fonctionnel Java en tant que langage orienté objet. Même si nous ne
codons pas un jeu vidéo, les développeurs trouvent
utile de considérer leur code comme des objets discrets présentant un comportement plutôt que comme un ensemble de fonctions
abstraites. Au fur et à mesure que vous travaillez sur des projets Java de
plus en plus importants, il devient beaucoup plus
facile de comprendre le
programme dans son ensemble. Si vous avez un design solide orienté
objet, parce que c'est
ainsi que les humains perçoivent le monde comme une
collection d'objets. Voici un exemple
de classe qui
présente une programmation
orientée objet, ainsi qu'une méthode principale qui utilise cette classe
comme objet. Tout d'abord, je tiens
à souligner que malgré une syntaxe peu familière, il y a en fait
beaucoup de choses que nous avons déjà abordées. Ici. Nous avons des forfaits,
des cours publics. Nous avons une méthode principale qui sert de
point d'entrée au programme. Et nous avons ici des
déclarations de méthode. Et nous avons
ici un bloc if else avec une expression booléenne. La quantité de choses que
nous devons savoir pour
comprendre la programmation
orientée objet n'
est donc comprendre la programmation
orientée objet pas mal du tout. Parlons de ce bloc
de code ici. C'est ce que nous
appelons un constructeur. Une façon de
savoir qu'il s'agit d'un constructeur est qu'il n'y a
pas de type de retour et la déclaration de méthode
et le nom de ce bloc de code correspondent
au nom de la classe. Mais à part le fait
que la déclaration de ce bloc de code est
différente de celle d'une méthode. Agit essentiellement comme une méthode. Et ce bloc de code est
exécuté lors de l'instanciation. L'instanciation consiste à créer une nouvelle instance
d'un objet. Il peut être un peu difficile
de comprendre les
cas en termes
de cette classe Dog. Rappelons-nous plutôt
nos exemples précédents. Lorsque nous créons une variable
entière. Imaginez que nous ayons deux
variables entières, x et y. Peut-être que x est égal à un
et y est égal à deux. Puisque x et y sont tous deux des nombres entiers, vous pouvez les considérer comme deux instances
du type entier. Seulement, ils ont des valeurs différentes. De même, vous pouvez imaginer que nous pourrions avoir deux
variables, x et y, toutes deux de
type Dog et ayant des valeurs
différentes pour
leur nom et leur âge. Une instance d'objet est
exactement ce à quoi elle ressemble. C'est une version d'un objet. Nous verrons
comment instancier un objet dans la vidéo suivante. Pour l'instant, tout ce que vous devez savoir c'est que lors de
l'instanciation, ce bloc de code sera la
première chose exécutée. Et nous parlerons également de
ce que cela signifie réellement. Ce nom est égal au nom et
ce point est égal à l'âge. Voici des exemples de ce que nous appelons des variables d'instance. Pour être plus précis, ils déclarent des variables d'
instance, mais ne les initialisent pas
à une valeur particulière. Nous pourrions donner ces
variables et leur valeur
initiale lors de la déclaration,
par exemple, le
nom de la chaîne privée est égal à Bob, ici même sur cette ligne. Cependant, nous déléguons généralement l'initialisation
de la variable au constructeur, car
le constructeur sera de toute façon
la première
chose appelée. Et ce n'est peut-être pas une bonne idée de nommer
tous nos chiens, Bob. Ce serait
extrêmement déroutant pour tous nos chiots. Comme vous pouvez le constater, comme
toute autre variable en Java, ces variables d'instance doivent avoir un type explicitement
déclaré. Ils ont également besoin de modificateurs d'accès, tout comme les classes et les méthodes. Il existe deux différences
importantes
entre les variables de méthode et les variables d'
instance. La première différence est que les variables d'
instance persistent
entre les appels de méthode. Une variable de méthode n' existe que tant que la
méthode est en cours d'exécution. Une fois qu'une méthode renvoie toutes ses valeurs variables
sont effacées de la mémoire. Pour les objets, ces valeurs de
variables d'instance seront conservées tant que l'
instance d'objet existe. Cela aura plus de
sens lorsque nous verrons un exemple d'
instanciation d'objets dans la vidéo suivante. La deuxième différence
réside dans leurs règles d'accès. Les variables de méthode
ne sont accessibles que dans le bloc de code le plus interne
dans lequel elles sont créées. Par exemple, si nous avions une boucle while
dans la méthode getName. Et à l'intérieur de cette boucle, nous avons créé une variable. La variable
ne serait accessible dans le bloc
de code de la boucle while. Toutefois,
les variables d'instance sont accessibles à partir de toutes les
méthodes non statiques de la même classe. Nous allons
parler de ce que signifie
réellement la statique dans
la vidéo suivante. Mais pour l'instant, tout ce que vous
devez savoir, c'est qu' une méthode non statique
est une méthode qui n'a pas statique avant type de retour et
la déclaration de méthode ne soient
déclarés. Comme vous pouvez le voir ici, nous pouvons renvoyer la valeur du
nom et de l'âge à partir de
ces méthodes ici. Ces variables d'instance
sont accessibles à ces méthodes car ces
méthodes ne sont pas statiques Le préfixe de ce point indique à Java que nous faisons référence à une variable d'
instance appelée name. Maintenant, vous pourriez
penser que c'est une exigence ridicule d' avoir dû ajouter encore
plus de règles de langage pour faire référence aux variables d'instance. Mais il y a une bonne
raison à cela. Peux-tu me dire ce que c'
est ? Mettez la vidéo en pause et je révélerai
la réponse en 321. La raison en est que nous pouvons
avoir des conflits de dénomination entre les variables d'instance
et les variables de méthodes. Un exemple de cela se trouve en fait ici dans le constructeur. Le nom de la variable déclaré dans les arguments
du constructeur. Si je devais omettre le préfixe dans
cette ligne, this.name est égal à nom, alors nous aurions
simplement le nom égal au nom, ce qui ne fait rien car le
nom est déjà égal au nom. Ce préfixe
est donc important pour distinction entre les variables d' instance et les variables de
méthodes. Si ce
préfixe n'existe pas et qu'il existe une variable de méthode
portant le même nom que la variable d'instance, Java supposera que vous faites référence à la variable de
méthode. Voici le code
utilisé dans cette vidéo. Comme toujours,
cliquez sur le lien, cliquez sur Fork Ripple
et testez. Si vous rencontrez des messages d'erreur
cryptiques, essayez de coller votre message
d'erreur dans Google et voyez ce que d'autres
personnes ont à dire. Sinon, n'hésitez pas à poster
des questions dans ce cours.
7. Objets Partie 2: Bienvenue, mes amis. Dans cette vidéo, nous allons
terminer notre discussion sur
les objets. Nous avons parlé de l'instanciation d'objets
dans la vidéo précédente. Voyons comment cela fonctionne. Tout d'abord, rappelez-vous que le
constructeur du chien ressemble à ceci. Il comporte deux arguments, le
nom et l'âge. Dans notre classe principale, nous créons deux instances de
la classe sombre de cette manière. Tout d'abord, conformément à la tradition
Java, nous précisons explicitement le type de la variable que nous créons, qui est le type sombre. la partie suivante, cela
ressemble presque à un appel de méthode, sauf que nous avons
ce mot clé, new. Le nouveau mot clé associé à l'appel du constructeur indique
à Java d'allouer d'abord de la mémoire pour
une copie de l'objet chien. Et une fois que cette mémoire
a été allouée, elle appelle le constructeur. Exécuter n'importe quel code figurant dans
la définition du constructeur. Après avoir exécuté ces
deux lignes de code, Bobby et Sam ont désormais
leur nom et leur âge
enregistrés dans les instances du premier chien
et du deuxième chien. Puisque nous enregistrons ces données dans leurs variables d'instance
qui sont conservées. Parlons maintenant de l'électricité statique. Voici le cours sur les chiens
de la dernière vidéo, mais avec quelques modules complémentaires. Nous avons ajouté le mot clé static entre le modificateur d'accès et le type dans la déclaration de méthode
et de variable. N'oubliez pas que les variables
et les méthodes sans
mot clé statique ou non statique également appelées
variables d'instance et méthodes d'instance. Comme leur nom l'indique, les variables d'
instance et les méthodes d'instance sont spécifiques aux instances
d'un objet. Cependant, les variables statiques et les méthodes
statiques sont à l'opposé. Ils ne peuvent pas être liés à une instance
spécifique d'un objet. Ce sombre exemple pourrait vous
aider à comprendre. Si vous voulez connaître le
nombre de pattes d'un chien, avez-vous besoin d'un chien en particulier
pour répondre à cette question ? Bien sûr que non. Vous savez que les chiens ont en
général quatre pattes. Le nombre de pattes
d'un chien n'est pas spécifique à un
cas particulier d'un chien. En revanche,
si vous voulez connaître le nom ou l'âge du chien, nous avons besoin d'un chien très précis
pour répondre à cette question. méthodes
et les variables d'instance sont donc spécifiques à des
instances particulières de la classe. Les méthodes et
variables statiques s'appliquent à toutes les instances de la classe. Voyons comment nous interrogeons
les méthodes
statiques par rapport aux méthodes d'
instance. Comme l'attribut non legs est un attribut public
et statique, nous pouvons demander à y accéder directement
avec dog point non legs. Notez que le chien n'est pas une instance spécifique
de la classe de chiens. La classe de chiens elle-même n'
a ni nom ni âge. Nous pouvons également accéder à
get numb tails directement à la classe point
sans instance. Cependant, pour vieillir, nous devons y accéder via
une instance spécifique. Deuxième chien, puisque seuls
des cas spécifiques de chiens sont
associés à des données d'âge. Notez également que nous
pouvons toujours accéder à des méthodes et des variables
statiques à partir d'une instance d'un objet. Et encore une fois, si vous
y réfléchissez, c'est assez intuitif. Je ne peux pas vous dire l'âge
du chien sans chien en particulier, mais je ne peux pas vous dire
combien de pattes et queues ont les chiens en général, si je vous donne une référence médicale
précise. Voici le code
utilisé dans cette vidéo. Comme toujours,
cliquez sur le lien correspondant à l' ondulation et modifiez
le code pour voir ce qui
fonctionne et ce qui ne fonctionne pas.
8. Commentaires: Bienvenue, mes amis. Dans cette vidéo, nous allons
parler des commentaires. Parfois, le code Java
peut être très confus, surtout si vous avez
un bloc de code qui appelle d'autres méthodes et que ces méthodes
appellent encore plus de méthodes. Cela pose des problèmes plus tard , car vous
constaterez que
vous aurez parfois du mal à comprendre votre code juste après quelques jours. Et si vous envisagez de
collaborer avec d'autres personnes, vous devez vous assurer
que vos collaborateurs sont également en mesure de comprendre
votre code. Afin de faciliter
la lisibilité du code, Java permet
aux développeurs d'ajouter notes
lisibles par l'homme à leur
code. En voici un exemple. Les commentaires en ligne sont précédés d'une double barre oblique et
sont généralement ajoutés soit après le code la même ligne, soit sur la ligne
immédiatement au-dessus du code Le commentaire décrit
les textes qui tombent. La double barre oblique est un
texte lisible par l'
homme qui n'est pas
exécutable par Java. Il existe uniquement pour
aider le lecteur humain, ce que fait le programme
à comprendre le code adjacent. Voici un autre exemple. C'est ce que nous appelons
un commentaire de document Java. Il existe des outils qui génèrent de la documentation pour votre code en scannant les fichiers la recherche de commentaires
respectant ce format. Nous n'allons pas utiliser d'outil de
documentation Java dans ce cours, mais il est bon que vous
sachiez comment rédiger descriptions de
méthodes claires et
jolies. Java, doc, commentaires
ou multiligne. Ils commencent par une barre oblique, une
étoile et une barre oblique. Les lignes intermédiaires ne doivent comporter qu'un seul astérisque
au début. En général, les commentaires Java
Dot contiennent une description détaillée de
la méthode, comme celle que nous avons ici, suivie des balises Program
et at return. Si nous avions plusieurs arguments, nous aurions plusieurs balises
app par m. Chacun doit d'abord nommer le
périmètre qu'il décrit, suivi d'une description
de l'argument. La balise de retour est présente pour les méthodes non nulles et contient une description
de ce qui est renvoyé. Il n'est pas nécessaire de respecter
strictement ce format si vous ne générez pas de
documentation l'
aide de l'outil Java doc. Mais même si ce n'est pas le cas, il est généralement recommandé de
suivre ce format
chaque fois que vous le pouvez. Voici le code
utilisé dans cette vidéo. Accédez au lien, cliquez sur
Fork, Ripple et
bricolez le code.
9. Tableaux et listes ArrayLists: Bienvenue, mes amis.
Félicitations pour avoir atteint ce
stade du cours. Dans cette vidéo,
nous allons
parler de tableaux et de listes de tableaux. Il y a quelques vidéos. Lorsque nous avons
abordé les types Java pour la première fois, nous avons mentionné le type de tableau, mais nous n'avons pas vraiment donné trop de détails
sur ce que c'est. Aujourd'hui. Nous allons revoir les tableaux de manière beaucoup plus détaillée. Rappelons que nous avons
vu pour la première fois un tableau de chaînes dans la signature
de méthode de la méthode principale. Voici une façon de
créer un tableau. Si vous connaissez déjà les valeurs
que nous voulons utiliser pour initialiser, nous pouvons le remplir directement manière en spécifiant le
type du tableau, dans ce cas un tableau d'entiers, et en incluant le des valeurs
et des accolades comme ça. Si vous ne savez pas encore quelles valeurs
vous souhaitez utiliser, nous pouvons d'abord initialiser
un tableau de zéros avec le nouveau mot clé et
en spécifiant la longueur
du tableau entre parenthèses. Ensuite, lorsque nous sommes prêts
à remplir le tableau, nous pouvons définir les éléments
directement comme suit. Quelques points à noter ici. abord, la longueur d'un tableau est fixe et ne peut pas être
modifiée une fois qu'il est créé. Ainsi, le tableau un et le tableau deux auront une longueur de
trois et ils le seront toujours. Donc. Ensuite, les indices des tableaux
commencent à zéro. Dans de nombreux langages,
dont Java, de zéro pour
presque toutes les indexations entre les structures de données nous allons également partir
de zéro pour
presque toutes les indexations entre les structures de données. Maintenant, si vous souhaitez imprimer tous les éléments
du tableau un par un, nous créons une variable I pour faire référence à l'
index du tableau. Et nous incrémentons cette valeur I d' une unité jusqu'à ce que nous atteignions la
longueur du tableau, que nous pouvons rechercher en
utilisant cette longueur d'attribut. Nous pouvons accéder à un
élément individuel du tableau à l'aide ces crochets et d'un
index compris entre 01 et deux, qui faisaient référence
respectivement aux premier, deuxième et troisième éléments du tableau. Ce sont donc des tableaux. Ensuite, nous avons les ArrayLists, qui sont une
version plus flexible des tableaux. Semblable aux tableaux. Les listes matricielles sont également des
collections ordonnées d'éléments. Cependant, une distinction
conceptuelle importante est que ArrayLists sont redimensionnables et que les ArrayLists ont également une syntaxe
différente. Explorons ces différences. La première est que les ArrayList
sont initialisés ainsi. L'élément
entre crochets indique le type d'élément de
la collection ordonnée. Et il suffit de fournir
explicitement le type sur le côté gauche de
l'initialisation. Cette ligne instancierait une ArrayList de longueur zéro. J'ai également remarqué que nous utilisons un entier
majuscule ici
au lieu d'un int minuscule. C'est ce que nous appelons
une boîte à taper en Java. Ce n'est pas très pertinent
pour ce cours, nous n'avons
donc pas besoin d'y consacrer
trop de temps. Nous appelons le type int
un type primitif, et le type entier avec un I
majuscule, un type de référence. Les entiers et les entiers sont généralement interconvertibles et
mappés l'un à l'autre. Par exemple, une valeur int de un correspondrait à une valeur
entière de un. Tout ce que vous devez vraiment savoir, c'est que l'entier
de type de référence avec un I majuscule est nécessaire pour certaines structures de données
telles que ArrayLists. Étant donné que ArrayLists ne peut accepter types de
référence comme éléments. C'est exactement la façon dont
Java a été conçu. Alors ne vous attardez pas trop dessus. Gardez-le simplement à l'esprit. Si
vous avez déjà essayé d'utiliser une liste matricielle la prochaine fois
que vous ferez vos courses. Ensuite, voici comment ajouter des
éléments à la liste. Donc, un est à l'indice
012 correspond à l'indice un, moins sept est à l'indice
2,19 est à l'indice trois. Nous pouvons également supprimer des
éléments de la liste, ce qui supprimera l'élément à l'index spécifié et
réduira la taille de la liste d'une unité. Dans ce cas, nous allons
supprimer l'indice deux,
qui, dans notre exemple sera la valeur
de moins sept. Ainsi, après avoir exécuté cette ligne, nous aurons la valeur
un à l'indice zéro, la valeur 12 à l'indice un et la dévaluation 19 à l'indice deux. Étant donné que toutes les valeurs après l'indice deux seront décalées une unité pour tenir compte de la suppression. Une autre différence est la façon dont nous obtenons la longueur du tableau. While I erase avait une longueur d'attribut
public. Les listes de tableaux ont une
méthode publique appelée taille. Nous avons également un point de liste à placer ici au lieu de crochets
pour accéder aux éléments. Nous présentons
de nombreuses méthodes et attributs spécifiques pour effacer une
ArrayList dans cette vidéo, qui peut être un
peu écrasante. Si c'est ce que tu ressens. Ne t'inquiète pas. L'informatique n'est pas une discipline basée
sur la mémorisation. Si vous oubliez
quelque chose de petit, ou si vous essayez de trouver
des fonctionnalités supplémentaires pour ces structures de données, recherchez-le
simplement sur Google. Les résultats de Google pour les questions de base sur la
programmation sont généralement très pertinents, car nombreuses personnes avant
vous avaient probablement les mêmes questions lorsqu'
elles ont commencé à programmer. Enfin, j'aimerais vous montrer une méthode abrégée
pour parcourir la liste. Ce bloc de code fait exactement la même chose
que ce bloc de code situé au-dessus de l'élément int
indique à Java que nous traitons chaque élément
de la liste comme une variable appelée élément de type int. et la liste des deux-points indique à Java qu'il s'agit de la
liste sur laquelle nous voulons itérer. En passant, nous aurions également
pu écrire le type sous forme d'entier
avec un a majuscule ici. N'oubliez pas que int et integer sont
généralement interconvertibles. Nous n'avons eu besoin d'utiliser un
entier avec un I majuscule que
lorsque nous avons déclaré le type de la ArrayList apparaître initialement. Quoi qu'il en soit, lors
de la première itération de ce bloc de code, l'
élément
sera lié à un seul. À la deuxième itération, il sera limité à 12. Vous avez compris l'idée. Java gère simplement
l'incrémentation de la variable d'index à votre
place avec cette syntaxe simplifiée. Maintenant, vous vous demandez peut-être, ArrayList peut faire tout ce
que les tableaux peuvent faire. Et les ArrayLists ont même des fonctionnalités supplémentaires
puisqu'elles peuvent être redimensionnées. Alors pourquoi les
développeurs Java n' ont-ils pas simplement supprimé ou
effacé du langage ? Mettez la vidéo en pause et je
révélerai la réponse en 321. La raison en est que l'utilisation
d'une
ArrayList au lieu d'un tableau entraîne des compromis
en termes de performances . listes de tableaux contenant des types de
référence sont généralement un peu plus lentes que les tableaux utilisant des types primitifs. la plupart des cas d'utilisation, cependant, le
compromis en termes de performances n'est pas suffisamment
perceptible pour
faire la différence. Mais c'est quelque chose qu'
il
faut garder à
l'esprit si vous travaillez sur un sujet sensible à la latence, exemple si vous
programmez un laser de très haute précision ou si vous essayez de créer un
négociation boursière ultrarapide. Mais voici le code
utilisant cette vidéo. Accédez au
lien, cliquez sur Fork, Ripple et
bricolez le code.
10. Sudoku: Bonjour, mes amis. Félicitations pour avoir terminé toutes les
vidéos pédagogiques de ce cours. Aujourd'hui, nous pouvons utiliser ce que
nous avons appris pour créer un jeu visuel interactif que vous pouvez partager sur mon
CV et avec vos amis. J'ai créé un lien vers un document assez
complet dans l'onglet Projets
et ressources. Allez-y et cliquez sur ce lien. Et cela devrait
vous mener à ce document. Je vous laisse lire
la majeure partie de ce document pendant votre temps
libre, mais je vais
le parcourir brièvement pour que vous ayez au moins une idée générale de
ce qui se passe. Je voudrais commencer en disant que ce projet n'est pas
censé être super, facile ou terminé en 10 minutes. Je sais que certains des
autres cours cette plateforme sont très simples, comme écrire un cours
comportant trois méthodes. Mais je ne pense pas vraiment que vous
allez en apprendre autant si c'est tout ce que vous faites après avoir visionné
ces vidéos. Ce projet peut donc
nécessiter plus de réflexion que d'autres projets si vous avez suivi d'autres cours de Java
sur cette plate-forme, mais ne vous découragez pas. Il a été conçu de cette façon. Vous pouvez ainsi vous familiariser avec une véritable mission de codage qui vous encourage
réellement à comprendre la programmation
orientée objet. Assurez-vous de lire ce document dans
son intégralité. Il est probable que vous ayez de nombreuses questions sur
le projet auxquelles vous trouverez
déjà des réponses ici.
Avant de commencer. Assurez-vous d'avoir créé un compte sur repl it.com et d'
avoir vérifié votre e-mail. Sinon, vous ne serez pas en mesure
de biker et
de modifier les fichiers. Une fois que vous l'aurez fait, rendez-vous sur
ce lien et participez au tirage au sort. Ce projet que nous avons lié
ici s'appelle un squelette. Cela signifie qu'une partie du code a
été créée pour vous. De nombreuses méthodes ont été laissées blanc et comportent un commentaire pour blocs de code dont le commentaire « todo » signifie que vous
deviez renseigner le
code de cette section. Dans ce projet, vous
allez implémenter Sudoku au cas où
vous ne le connaîtriez pas. J'ai écrit une description de ce jeu dans la section de
présentation ici. Ici, j'ai écrit
une brève description de chacun des fichiers
de ce projet. L'ordre dans lequel ils
sont répertoriés est l'ordre dans lequel vous
devez terminer le projet. Vous devez d'abord vous débrouiller, puis ramer, puis
bloquer, puis monter sur une planche. Le principal a déjà
été fait pour vous. Ici, j'ai écrit ce que
je viens de vous dire de manière explicite. Après avoir terminé chaque cours, vous devez exécuter tous
les tests unitaires et vous assurer que les
tests unitaires se rapportent au cours que vous
venez de terminer. D'abord. Une fois que vous avez rempli la cellule, vous devez vous assurer que toutes les unités sont
liées à la vente. Une fois la ligne terminée, vous devez vous assurer
que tous les tests unitaires associés à la cellule et à la
ligne sont réussis, etc. La section suivante
vous explique comment
exécuter le test. Dans le panneau de gauche de la section
des outils de Repl it, vous pourrez accéder aux outils. Outils. Et après avoir
cliqué sur l'onglet Outils, vous devriez pouvoir
voir les tests unitaires. Une fois que vous avez cliqué sur les tests unitaires, vous devriez pouvoir
voir cette fenêtre apparaître, qui contient un bouton Exécuter le test. Même si nous n'avons pas encore
commencé à coder. Faisons simplement le
test unitaire et voyons ce qui se passe. Revenons à
notre squelette de Sudoku. Passons, encore une fois,
à l'onglet Outils. Nous cliquons sur Tests unitaires
et nous cliquons sur Exécuter des tests. Après avoir cliqué sur Exécuter les tests, nous pouvons passer à
l'onglet console. Je l'ai déjà ouvert ici, mais au cas où ce n'est pas le cas, vous pouvez le trouver dans la section
des outils. Donc, dans les outils, vous accédez à la console. Et maintenant, nous pouvons voir le résultat. Dans ce cas, aucun test sur
20 n'a réussi (voir les erreurs ci-dessus). C'est donc une bonne chose. Cela signifie que tous nos
tests sont réellement significatifs. Pensez-y. Si l'un de nos tests
réussissait alors qu'aucun code n'a
encore été écrit, ce serait un très mauvais signe. Cela signifierait
que le test ne teste rien du tout. Ainsi, une fois
le projet terminé, tous ces tests devraient réussir. la section suivante, j'ai écrit quelques conseils de débogage au cas où vous auriez des problèmes. Cependant, comme vous êtes
probablement novice en programmation, ce n'est pas grave si vous
ne parvenez pas à résoudre le problème seul. Si vous rencontrez des problèmes, deux options s'offrent à
vous. La première option consiste à jeter un
coup d'œil à la solution, que j'ai publiée tout
en bas de ce document. La deuxième option consiste à publier une question sur le
cours Skillshare sous l'onglet de discussion. Et je
te recontacterai dès que possible. Enfin, après avoir
réussi tous les tests unitaires, vous pouvez cliquer sur le
gros bouton vert. Le jeu
devrait ressembler à ceci. Voici ma solution. Vous cliquez donc sur le bouton vert. Une fois la compilation terminée, il exécute le programme
et imprime
ce tableau de Sudoku sur lequel
certaines valeurs sont remplies. Maintenant, nous pouvons jouer à ce jeu. Supposons, par exemple que nous aimerions
mettre le nombre, disons deux, en dislocation. Ce
sera donc la ligne numéro un, puisque cette rangée de
périodes, la ligne zéro. Voici donc la première ligne, et voici la colonne une,
car celle-ci, ici, c'est la colonne zéro. Supposons que 11 soit deux. Et vous pouvez voir que deux d'entre eux
sont maintenant disloqués. Si nous voulons annuler cela, nous pouvons effacer 11 car
11 est la coordonnée que nous effaçons et nous la
retrouverons vide. Maintenant, essayons de
mettre un neuf ici, ce qui ne devrait pas fonctionner car nous en avons déjà un neuf
dans ce bloc. Nous avons réglé 11 sur B9. Cela
vous dit que le bloc zéro a plusieurs noms et qu'il ne vous permettra
pas d'y mettre un neuf. Si vous êtes frustré
et que vous ne voulez plus
terminer un puzzle de Sudoku, vous pouvez simplement taper solve. Et maintenant, il va résoudre
tout le tableau pour vous. Et il quittera
le programme en
vous indiquant que vous devez exécuter à nouveau
le bouton Exécuter Si vous voulez un nouveau puzzle Il est possible
que les
tests unitaires que j'ai écrits
ne soient pas complets. Je suis assez certain que
si vous réussissez un test unitaire, vous devriez pouvoir exécuter
le jeu avec succès. Cependant, si vous réussissez tous les tests unitaires et que vous ne parvenez
toujours pas à exécuter
le jeu correctement. Je vous recommande de comparer
votre solution avec celle
que j'ai publiée. Lorsque vous constatez l'écart, veuillez publier une note dans le cours
Skillshare afin que je puisse corriger le squelette ou le test unitaire
s'ils doivent être corrigés. Encore une fois, n'oubliez pas de
lire ce document dans son intégralité et de vous y
référer fréquemment. C'est tout ce que j'avais
à dire à propos de cette vidéo. Amusez-vous lors de votre première
véritable mission de codage.
11. Transition: Bonjour à tous. Je suis Derek, et merci d'avoir
regardé mes vidéos J'ai travaillé d'arrache-pied ces derniers mois et je viens de publier un nouveau
rapport destiné aux citoyens. Je vais mettre le lien
dans la description. J'ai remanié le cours pour proposer diapositives
plus professionnelles
et, dans l' ensemble, une meilleure qualité
de production J'ai ce trépied, par exemple,
qui tient mon appareil photo. Il existe un nouveau projet
qui intègre les leçons de ce cours. Mais cette fois, j'ai inclus des vidéos
de présentation
intermédiaire afin que vous ne soyez pas complètement perdu Ce cours que vous
venez de terminer couvre les connaissances
fondamentales de Java qui
sont essentielles à l' écriture de programmes
de travail Cependant, si vous avez déjà essayé de
faire évoluer votre code lumière de
circonstances imprévues ou en raison de l'évolution des exigences, vous constaterez que c'est vraiment
difficile à faire. La gestion de la complexité
du code est donc une
compétence essentielle pour un programmeur Et nous abordons
de nombreux concepts que vous devriez
connaître si vous
décidez de poursuivre des études formelles en
programmation ou si vous
décidez de partir à la recherche d'
un emploi. J'espère que vous avez apprécié
les leçons de ce cours et que vous déciderez de continuer votre voyage avec
moi dans le prochain, je vous verrai dans la prochaine vidéo.