Transcription
1. Introduction: Bonjour les gars et bienvenue. Je m'appelle Michael.
Je suis photographe, directeur de la photographie
et physicien. Et dans ce cours,
je vais explorer avec vous quelques
trucs et astuces que vous pouvez certainement utiliser pour améliorer votre codage ou votre
programmation. Niveau. Rise
s'occupera principalement de Java. Et ce cours est destiné à des groupes de personnes de
niveau intermédiaire. Cela signifie que vous avez une
certaine compréhension
de base de ce qu'est Java. Mais nous sommes encore en train de développer
certains principes fondamentaux. Je viens de faire une étape intermédiaire. Il y a donc un peu de contexte que
vous devez avoir. J'espère vous voir
dans la prochaine leçon.
2. Déclarations conditionnelles: Très bien les gars, je suis content
de vous avoir parmi nous. Et juste un rappel que
ce cours suppose que vous avez déjà quelques bases
du codage en Java, n'est-ce pas ? Et ce que nous allons faire, c'est
simplement commencer par énoncés conditionnels, juste ici, juste
ici, des énoncés conditionnels. Et n'oubliez pas que c'est un
commentaire juste là. Et nous
commencerons particulièrement par la déclaration if else. Si Dadadadada veut dire qu'on met une
condition juste là, puis on dira
autre chose là-bas. Et puis nous avons également mis une condition de ce qui devrait se passer, n'est-ce pas ? Et intrinsèquement, Java
est bien capable de prendre en charge un certain nombre de conditions logiques
issues des mathématiques, non ? Que ce soit
des conditions logiques comme peut-être quelque chose comme moins que, disons moins que. Et rappelez-vous que
nous montrons, mathématiquement
parlant, nous montrons moins fait par quelque chose
du scénario suivant. Nous disons que a est inférieur à
b, par exemple, n'est-ce pas ? Et puis nous pourrions
avoir un autre scénario où nous aurions
moins ou égal à, n'est-ce pas ? Et celui-ci devrait évidemment être de
la façon suivante, où nous devrions dire que peut-être a est inférieur ou égal à b. Ensuite, nous pourrions également avoir
un scénario où nous parlerons de supérieur à, supérieur à, qui
serait alors appelé a
étant supérieur à b. Et vous pouvez certainement être
en mesure de suivre en haut ce que je
vais dire un x
supérieur ou égal à, qui serait alors référencé
ou montré plutôt de la
manière suivante où nous disons le même modèle est
supérieur ou égal à b. Ensuite, nous pourrions également
avoir un scénario où vous parlez de ce qui est égal à quelque chose et comment nous
parlons de cela alors que nous disons, a est égal à fait, laissez-moi simplement faire ceci. Eh bien, je dis que a est égal
à a est égal à b, non, et je répète que non. A est égal à b. Le codage de
a est égal à b signifie que vous dites que a
doit être remplacé par b. Cela signifie égal, signifie
littéralement insérer. Vous voyez, mais quand vous
dites égal, égal, cela signifie que vous faites référence
à la notation mathématique
ou égal à, n'est-ce pas ? C'est ce que vous
voudriez
peut-être mettre dans le scénario
des conditions. Sinon, vous pourriez
montrer que quelque chose
n'est pas égal à quelque chose
en disant pas égal à. Ensuite, disons que
a est égal à b. Il y a
donc un
certain nombre de conditions
que vous pouvez utiliser. Et en fonction de ce que
vous voulez, vous pouvez proposer différentes performances ou
actions à réaliser, d'accord ? Et une autre chose dont vous devez simplement être conscient
est que Java lui-même possède les instructions
conditionnelles suivantes. Voici donc les instructions
conditionnelles. Depuis Java même. Nous avons si la condition. Nous avons la
condition if, condition. Et c'est pour quoi faire ? Il s'agit de spécifier un
code à exécuter. C'est aussi simple que ça en fait. Si une
condition spécifiée est vraie, si la condition est vraie, n'est-ce pas ? Donc, je serais essentiellement capable d' avoir cette condition si, non ? Permettez-moi de le
mettre entre parenthèses, juste pour qu'
il se distingue en tant que condition elle-même. Vous ne pouvez pas le
confondre comme s'il ne s' agissait que d'une phrase
continue. Non. Nous l'utilisons pour pouvoir le faire. Je pourrais même mettre cette utilisation ici. Nous utilisons f pour cela, puis
nous pouvons également utiliser else, else pour spécifier un code
à exécuter également. Très bien, laisse-moi juste faire ça. Mais si une condition est
fausse, tu le vois ? Voilà, c'est parfait. Si condition est vraie, rien d'autre ne signifie que si
la condition est fausse. donc comme ça que tu l'utilises. Et puis nous pourrions également
parler de else if, qui est également une condition. Par conséquent, je devrais
mettre un support. Sinon si nous utilisons else if. Et avec la
condition. Et c'est à ce moment que nous voulons spécifier une condition
à tester. À tester. C'est si la condition est fausse, non ? Donc, ce qui se passe
généralement, c'est que aurait probablement quelque chose
comme cette condition en premier, qui est la condition if. Et ensuite, il
y aurait autre chose si. Et puis, finalement, nous
aurions eu celui-ci d'autre. C'est si toutes les
conditions se produisent, alors nous passons finalement à l'autre. C'est généralement dans cet ordre
que l'on s'inquiète. Nous allons certainement examiner cela peu de temps après. Il s'agit simplement d'une présentation
de ces méthodes. Et puis nous avons aussi une condition de
commutation qui est utilisée pour spécifier qu'il y a une
condition là-bas, n'est-ce pas ? Typo, qui est
certainement utilisé pour spécifier quels sont les
nombreux blocs de
code alternatifs à exécuter. Cela s'avère très pratique, en particulier dans le domaine de l'apprentissage
automatique ou de la science des données ou
quoi que ce soit d'autre. Vous vous retrouverez à l'utiliser
beaucoup de fois, juste pour approfondir l'idée de
l'instruction if. Laisse-moi te donner un petit quelque chose d' intéressant, Garrett. Jetons un coup d'œil
à ce qui suit. Disons simplement que nous
examinons si maintenant si c'est la condition. Et avec cette condition if, ce que nous allons
faire c'est écrire ceci.
3. Si des déclarations conditionnelles: Ce que nous allons faire, c'est
simplement
mettre une condition
ici et dire si. Ensuite, nous mettons notre
condition si, par exemple trois est supérieur à un. C'est un exemple. La question est, maintenant, si c'est
le cas, que devrait-il se passer ? Que devrait-il se passer
si c'est le cas ? Donc, vous pouvez dire que c'est mixte, par
exemple, système. N'oubliez pas de le mettre
correctement système. Dot out, dot, print, LN, print. Imprimons une chaîne indiquant que premier nombre est supérieur au
deuxième chiffre. Bon ? Donc, essentiellement, ce que je
dis à mon,
mon, mon Java ici, c'est que
si le premier nombre, qui est trois, est
supérieur au deuxième, si cette condition est vraie, alors cela devrait être imprimé. C'est ce que je dois voir. Et si c'est faux, la question est de savoir si c'est faux,
alors que devrait-il se passer ? Eh bien, rien parce que
je ne
lui ai pas dit ce qui devrait
se passer si rien, si cette condition est fausse. Essayons donc de l'
exécuter et voyons que Java sera capable d'imprimer ce que nous attendons d'elle. Le premier chiffre est
supérieur au second. Ne vous laissez pas émouvoir
par ce HelloWorld. C'est à cause de
ça ici. Je pourrais simplement le supprimer très
simplement. Nous n'en avons pas vraiment besoin. Honnêtement. Je pourrais le relancer
juste pour que nous soyons convaincus que nous avons
simplement ce premier chiffre supérieur au
deuxième chiffre. Vraiment bien. Considérons donc le scénario
suivant. Moi, j'ai mis le mien ici
et j'ai mis mon 3M. Maintenant, prédisons
ce qui devrait se passer. En soi, nous savons qu'un n'
est pas plus grand que trois. Cela signifie donc que cette
première condition n'est pas vraie. Et n'oubliez pas que si
condition est utilisée pour spécifier un code qui est vrai, si cette condition est vraie, alors le code sera exécuté. Mais dans notre
scénario ici, cette condition
n'est pas vraie, n'est-ce pas ? Alors ne voyons rien. Pourquoi rien ? C'est parce que la condition est fausse.
Vraiment faux. Mais Java se demande, maintenant si c'est faux,
que dois-je faire ensuite ? Puisque nous n'avons pas précisé ce qu'il devait faire ensuite, nous n'avons rien
résumé. Ce que nous devrions faire, c'est
dire autre chose. Nous pourrions dire autre chose si,
ou nous pourrions dire autre chose. Mais je vais commencer par autre chose. Cela signifie que si la première
condition n'est pas vraie, si elle est fausse,
que devrait-il se passer ? C'est là que les autres entrent en jeu. Et puis je dis système, out, point, out, point, print LN. Et nous avons le premier chiffre, plus petit que le second. Voyons voir maintenant, exécutons-le. Essentiellement, nous
disons que si c'est faux, cela devrait être maintenu. Maintenant, si cette condition n'
est pas vraie, cela
signifie évidemment qu'elle est fausse. Et donc, si c'est faux, cela devrait
être testé, non ? Cela signifie que si nous ne
faisons pas le premier, sinon nous
allons faire ce qui suit. Alors lançons-le et
voyons ce que nous obtenons. Walla, premier chiffre,
plus petit que le deuxième chiffre. C'est certainement vrai d'
après ce que nous voyons ici, le premier chiffre est
plus petit que le second. Et nous pouvons jouer avec
autant de valeurs si nous le voulons. On pourrait même
jouer avec 100. Et voyons 103,
lequel est le plus grand ? C'est certainement des centaines, donc cela signifie que le
premier chiffre doit être supérieur
au second. Voyons voir. Voilà, ça y est. Le premier chiffre est supérieur
au deuxième, non ? Donc c'est certainement la
déclaration if là-bas, d'accord.
4. Erreurs associées aux déclarations conditionnelles: Ensuite, il suffit de prendre note qu'il y a des erreurs
que les gens feront. Parfois, prenez le mode
qui si vous utilisez majuscules, si comme ça, cela signifie quelque
chose d'autre de différent, alors nous vous donnerons une erreur. C'est très important
de le noter, n'est-ce pas ? Vous pouvez donc penser à cela, ou plutôt à Teslas que
nous venons de faire ici. Non seulement pour les nombres, vous pouvez même tester
les variables. Et si vous ajoutez des variables
comme, par exemple, disons que int x
est égal à 25, comme ça. Et je dis que int y est égal à 79. Alors contrairement à droite, un
point-virgule là-bas. Et puis je l'ai
mis en condition. Maintenant, j'ouvre simplement le
crochet et je dis simplement que x est inférieur à y, par exemple. Ça va ? Si c'est le cas, que devrait-il se passer ?
Cela devrait se produire. Système. Ensuite, je dis
dot out dot print LN. Par conséquent, nous
disons simplement que x est plus grand. Supposons que x est inférieur à, x est inférieur à y. Par exemple,
si c' est vrai, si c'est
vrai, alors c'est le cas. Maintenant, que
prédisons-nous de ce qui se passera ? Eh bien, sont intrinsèquement, nous pouvons
voir que x est définitivement plus petit que y parce que
x vaut 25 et y est 79. Et donc ce que nous attendons
de voir, c'est que nous voyons là-bas, c'est, cela devrait être
considéré comme vrai. Cela est vrai. Si cette condition est vraie,
c'est ce qui va
être imprimé et c'est vrai. Par conséquent, nous nous attendons
à voir que x est inférieur à y. C'est ce
que nous nous attendons
à voir. Maintenant, ce que nous voulons faire ici, rappelez-vous, c'est vouloir mettre cela dans les
commentaires juste pour nous assurer que nous n'obtenons pas de
réponses de la
chose précédente. Nous voulons juste cette
portion et le X
des données d'alto est inférieur à y, non ? Génial ! J'espère que c'est
logique pour vous les gars. C'est écrit la chose la plus
importante.
5. Déclaration d'autre: Et à ce moment-là, nous allons simplement passer rapidement
à autre chose et voir si nous pouvons simplement activer l'instruction L. Très bien, nous
ne faisons que comprendre la déclaration else encore plus loin. L'accent a été mis principalement
sur le F. Maintenant, nous allons nous concentrer principalement sur
la déclaration else. Comme je l'ai déjà mentionné,
l'instruction else est juste utilisée pour spécifier un bloc de code à exécuter si la
condition est fausse, n'est-ce pas ? Vous pouvez donc penser à
cela comme si, par
exemple, nous devions dire fin
et ensuite nous parlons du temps. Cela équivaut peut-être à
40 minutes, peut-être, non ? Et nous disons ensuite, si le temps est inférieur à 60
minutes, une heure, n'est-ce pas ? Si, si le temps est inférieur à 60 minutes, que devrait-il se passer ? Eh bien, si c'est le
cas, je suis en avance. L'étudiant est LE peut-être s'il s'agit d'un
cas où un étudiant arrive en
retard pour un examen, qu'il
soit 40 minutes en avance, ou plutôt 40 minutes de
retard ou 60 minutes. 60 minutes au-delà du temps. Évidemment, l'étudiant
est éloigné, mais il s'agit simplement de savoir
lequel est le meilleur entre les deux. Donc, nous imprimerions probablement
quelque chose comme « hé, si le temps est
inférieur à 60 minutes, alors l'étudiant n'
est pas si en retard. Sachez si cela est conseillé, mais j'espère que l'étudiant ne
sera pas du tout en retard. L'étudiant n'est pas si tard. C'est si c'est
moins de 60 minutes. Et voyons voir. Souvenez-vous, c'est parce que
le premier
apparaît ici parce que nous
n'y avons pas mis de commentaires. Permettez-moi donc d'
y mettre des commentaires et nous pourrons ensuite nous concentrer sur le second sans
aucune distraction. Donc là, il est caché et l'étudiant n'est pas aussi
étendu ici que nous pouvons le voir. C'est parce que encore une fois,
la variable ici, ce que fait Java, c'est
qu'elle comprend. Rappelez-vous que nous avons parlé de la
façon dont le signe égal et signifie
essentiellement
insérer tout ce que je vois le temps, j'ai inséré 40 dans temps chaque fois que le temps est
mentionné à
Java, java comprend rapidement
que c'est C'est pas vraiment le moment. Ce n'est pas vraiment le
moment dont nous
parlons est 40 si le nombre entier, tous les nombres entiers pour t. Et donc, selon une condition que nous avons ici, l'étudiant n'est pas mort. Et puis on le peaufine. Nous le peaufinons. Comment le peaufiner ? Nous disons autre chose maintenant, nous disons autre maintenant. Else. Cela signifie que si
cette condition
n'est pas respectée, l'étudiant est en retard. Ami, Ellen, l'étudiant est en retard. Cela s'appliquerait dans le scénario
suivant. Imagine que je disais laquelle Alia est imprimée avec quelques minutes
de retard ou 40 minutes de retard ? Lequel est relativement Ellie, évidemment 20 minutes, non ? Par conséquent, l'étudiant est désormais le chef de file s'il a
40 minutes de retard. Par exemple, dans notre
scénario ici, cela signifie donc que c'est pour t moins de 20, pas aucun, c'est ce que
nous disons ici. La condition est si pour
t est inférieur à 2040, représenté par le temps,
la variable du temps. Si c'est le cas, c'est ce qui
va être imprimé. Mais ce n'est pas vrai. Ce qui est vrai maintenant, c'est que
pour t est supérieur à 20, et donc cela tombe dans l'instruction else
parce qu'ici c'est faux, et donc tout ce qui est faux ici sera exécuté ici. Alors lançons-le et voyons si nous
prévoyons que l'étudiant est en retard, le tour est joué. Ça y est. Voilà, nous l'avons. L'étudiant est en retard. C'est beau. J'espère que c'est encore
plus logique pour vous les gars.
6. Else..if déclaration conditionnelle: Va vite dans l'autre. Permettez-moi simplement de mettre
cela en commun. L'autre, si c'est le
ELF, la condition else-if. Et avec la condition « sinon si », en fait, ce
qui se passe ici c' est que nous avons le scénario
suivant, n'est-ce pas ? Là-bas. Nous l'avons, par exemple, nous allons appliquer exactement
ce que nous venons de faire ici. Emportez-le avec
nous ici pour mieux comprendre. Permettez-moi donc de mettre celui-ci en commentaire parce que nous
n'en avons plus besoin. Je pourrais toujours simplement
simplement consoler ça et
oui, c'est bon. Nous n'avons donc pas
suivi le scénario. Maintenant, réfléchis-y. Et si, si Le temps
est inférieur à dix, alors c'est ce qui imprimera LE ou peut-être Bonjour.
Changeons ça un peu. Juste pour comprendre. Mieux. L'après-midi, par exemple. Ou là, c'est le soir. Soirée. Cela signifie que peu importe
le temps que j'ai ici, c'est une situation assez binaire. Si c'est moins de dix heures, c'est moins de
dix heures, c'est l'heure du matin. S'il est supérieur à dix, même en cas de désastre automatiquement. Bon ? Mais alors l'autre
s'il vient et dit :
« Hé, et si je veux dire autre chose ? Si ? Disons « sinon si ». Ensuite, nous mettons notre
condition et nous cellules si le temps est inférieur à, si
c'est juste
moins de 30 minutes ? Eh bien, dans ce cas, ce qui va se passer, c'est que tu me
laisses juste copier cette ligne ici afin que nous n'ayons pas à l'écrire chaque
fois que nous la voyons. Ici, ce serait
juste l'après-midi. Après-midi. Donc, littéralement, ce qui se passe ici, c'est que nous disons que si l'heure est inférieure à
dix heures, c'est le matin. S'il est moins de 30 heures
de l'après-midi. Et s'il est supérieur à quoi ? Que T, ce qui signifie qu'il n'est pas moins de dix et qu'il
n'est pas moins de 30, alors ça veut dire qu'il est
supérieur à Theta, non ? Et vous vous demandez probablement
pourquoi nous aurions besoin de la LCF ? Eh bien, tu vois quand tu le
fais juste si alors sinon, c'est une situation très arbitraire ou plutôt
très binaire, te
limite tellement
parce que c'est vraiment une option, un, je le serai. Mais la beauté
de else-if est qu'elle vous
permet d'ajouter
plus de conditions. Vous pouvez donc
ajouter autant d'options a, B ,
C, D, E que vous le souhaitez. Vous pouvez ajouter autant
d'autres si vous le souhaitez. Maintenant, si j'ai un moment,
disons que j'ai eu un
moment, c'était quoi ? Littéralement cinq. Peut-être. Si j'en ai cinq, c'est
moins de dix, non ? La première condition
est remplie. Cela signifie ce
qui fonctionne en Java que vous pourriez me dire, mais alors cinq équivaut également à
moins de 30, E13. Imprimez ce message. Eh bien, quand Java l'exécute,
il commence d'autres choses littéralement à partir d'
ici, vérifie ici. Est-ce vrai ou non ? Et puis si ce n'est pas
vrai, il passe à autre chose. Mais si c'est vrai, alors Java
exécutera simplement code qui
se
trouve ici, n'est-ce pas ? Mais si c'est plus
que ça, il viendra ici. Donc, dans ce scénario, nous avions prédit être dans
le premier scénario. Par conséquent, nous nous attendons à
ce qu'il nous parle de l'argent et des données du matin. C'est parce qu'il a couru
ce premier c'est, remarquez que hé, cinq c'est
moins que dix, donc de l'argent. Mais que se passe-t-il si j'ajoute plus dix ? On en fait 15 maintenant ? Maintenant, il est supérieur à dix. Cela signifie qu'il va vérifier la
première année et dire : «
Hé, c'est faux,
ce n'est pas vrai. Et une fois cela fait, à
quoi sert-il ? Il saute et va ici et
vérifie que les poules sont là. Qu'en est-il de cette zone ? Sinon, si le temps est inférieur à 30, 15
est inférieur à 30. Et ça dit : Oui, ça l'est. Et par conséquent, il va
imprimer l'après-midi. Alors lançons-le et voyons. C'est l'après-midi. Et certainement vrai, capable de
voir la tendance si je
devais augmenter cela en imprimant ici et en améliorant
simplement cinq maintenant,
cela signifie que vous allez d'abord vérifier
ici et dire, Est-ce que c'est un cinq de moins que le tour ? On dira que c'est possible
que c'est faux. Et puis passez à autre chose et vérifiez que
cinq moins de 13
n'est pas vrai aussi. Et
maintenant, vous dites simplement faux. Ensuite, il reviendra finalement
à l'autre ici et dira, si celui-ci n'est pas satisfait et que
celui-ci n'est pas satisfait, alors il va certainement
se solidifier ici. Donc, cela
sera vrai ici et nous prédisons, par conséquent, que notre
code ici sera exécuté, notre chaîne sera affichée ici, notre texte sera affiché
ici pour être quoi ? Soirée. Alors
lançons-le et voyons. Et voilà, ça y est. J'espère que cela
vous a aidés et je vais
passer à autre chose maintenant.
7. L'opérateur ternaire: Bon ? Donc, la prochaine que
nous
examinerons est toujours la déclaration
inconditionnelle, mais je veux juste vous montrer façon
plus efficace de
traiter l'ensemble des instructions
conditionnelles sinon. Et cela
nous amène à ce que nous appelons, je vais utiliser
l'opérateur ternaire. Et ne t'inquiète pas. Nous allons
bientôt expliquer cela, mais ça s'appelle le Java. Permettez-moi juste de dire
Davon en sténographie. Si c'est autre chose D'accord, donc c'est le coup de
Java et le mal. Cela ressemble donc plus à un raccourci qui est essentiellement un
opérateur ternaire. Et vous vous
demandez probablement ce que l'opérateur entend lui-même. Voici comment nous l'épelons. C'est un opérateur ternaire. Et un opérateur ternaire n'est en
réalité qu'un
opérateur ternaire parce qu'il se compose de trois opérandes. opérandes sont, vous les
verrez bientôt comme moi, alors que je leur enverrai des textos. Pensez donc au scénario
suivant, qui est celui que nous avions. Pense à ça comme ça. Supposons que vous ayez quelque chose
comme la fin et l'heure, comme nous l'avons fait dans le premier
scénario et que nous avons donné une valeur
de 30 par exemple. Et puis dites que si le temps
est inférieur à Twain t, alors ce qui devrait se passer c'est que nous
devrions l'imprimer, non ? Il devrait imprimer quoi ? Peut-être une bonne journée. Ou si ce n'est pas le
cas, que devrait-il se passer ? Alors nous écrivons autre chose,
puis nous disons,
c' est littéralement
ce que nous venons de faire. Nous pourrions imprimer l'impression et maintenant nous pourrions imprimer
peut-être une bonne soirée. Oui, celui-ci va bien, nous en avons déjà parlé et rien n'est particulièrement
dérangé maintenant moins parce que nous l'avons
déjà fait avant. Et je vais vraiment
passer une bonne soirée parce que 30 c'est plus que 20. C'est une longue façon d'
écrire de cette façon. En utilisant des opérateurs ternaires
, ou plutôt cette règle abrégée
que nous allons utiliser. Vous pouvez simplement remplacer
tout cela au lieu de l'
écrire de cette façon, vous pouvez écrire littéralement comme ceci
et simplement dire que l'heure de fin
est un outil équivalent. Permettez-moi simplement de les mettre en opérateur ici et de dire que l'
heure de fin est égale à trois, comme nous l'avons dit dans le cas précédent. Ensuite, nous modifierons
cette déformation de cisaillement du lit. Ensuite, nous disons « résultat ». Et puis nous disons, c'est équivalent
au temps, d'accord, qui est inférieur à t. Ensuite nous avons
littéralement mis un point d'
interrogation là-bas. Juste comme ça. Et nous avons
mis le point d'interrogation. Nous avons même ceci ici
où nous disons bonne journée. Juste comme ça, mets même un point. Et nous n'avons pas vraiment besoin d'un chien
, c'est juste le moyen
de mettre un point. Et puis nous pourrions aussi passer quelque chose comme
Bonsoir ici. Mais juste en tant que chaîne, parce que c'est comme ça que
nous le définissons. C'est une ficelle. Soir. Ça va ? Ensuite,
il suffit de le fermer comme ça. Comme vous pouvez le constater,
il n'y a pas d'erreur. Cela signifie la vie de Darwin. Je comprends ce que tu dis. Et puis j'ai juste mis une impression et un résultat
étranges. Donc, au lieu de
l'écrire de cette façon, comme vous pouvez le voir, cela
prend combien de lignes ? 12345 ici, trois lignes. Je me demande probablement pourquoi, quoi bon s'il fait la même chose avec le point ? Eh bien, plus vous plongerez profondément
dans l'ensemble du codage, vous verrez que
parfois vous arrivez à trouver des milliers
de lignes que vous voyez. C'est donc plus facile
parfois si vous pouvez trouver des formes
abrégées de ces
lignes ou codes, n'est-ce pas ? Revoyons voir,
bonsoir. Tu vois ça ? Donc,
il y a une application de
la règle de raccourci
ou de l'opérateur ternaire, n'est-ce pas ?
8. Commutez des énoncés conditionnels: Cela nous amène
au point suivant. Permettez-moi simplement de faire quelques commentaires. Notre point suivant
concerne
la déclaration conditionnelle de switch. Instruction conditionnelle Switch. Ainsi, pour de telles
instructions conditionnelles, nous les utilisons pour sélectionner l'un des
nombreux blocs de code
à exprimer. comment cela fonctionne. façon dont cela fonctionne
est essentiellement comme ceci. Voici une erreur parce que ce
type devrait être en bas. Ouais. Oui, c'est bien. Maison d'assaut, qui fonctionne
essentiellement. C'est comme ça, non ? Le code du commutateur,
laisse-moi juste le mettre. Nous allons faire
quelques commentaires ici. Le code de recherche. L'expression switch
est plutôt évaluée, n'est-ce pas ? La valeur de l'expression est comparée
aux valeurs de chaque cas. Très bien, donc comparaison des valeurs de chaque cas
est faite, non ? Ensuite,
s'il y a une correspondance, par
exemple, s'il y a une correspondance, nous aurons la troisième étape, c'
est-à-dire que s'il y a une correspondance, le code sera exécuté. Et il y a quelques mots, des
mots-clés comme break. La pause, nous utilisons des mots-clés
comme celui-ci ici, le break et default. Ce sont quelques mots clés que
nous utilisons, c'est facultatif, non ? Et il y a quelques
mots clés à noter. Et je vais les élaborer humides. On continue, non ? Et la chose clé à noter
ici est vraiment, comme nous allons le voir, particulièrement maintenant
avec un exemple, c'
est
vraiment la veine principale. Donc un exemple,
disons que nous parlons de, hé, ils sont par défaut, par exemple, ou plutôt des cinq et de
préférence cinq sur quatre. Et puis nous parlons d'un
interrupteur et puis nous disons, jour, c'est comme ça
que nous le faisons d'ailleurs. Et nous allons simplement ouvrir notre déclaration s'il existe une déclaration
conditionnelle, nous l'exécutons dans le
cas numéro un. Et dans le cas numéro un, nous
examinons le cas numéro un. Nous pouvons descendre et
ensuite nous dire,
c' est le premier cas, puis imprimer le lundi,
par exemple, les jours de la semaine. Et si ce n'est pas le cas, si, si quoi, notre
condition n'en est pas une, par conséquent, vous
n'imprimerez pas lundi. Nous allons dire
à Java de sortir de cette boucle
ou de ce
cas conditionnel ici et de passer au cas numéro deux et de cocher deux. Donc, il prend avec
ces valeurs ici, il essaie de les faire correspondre il essaie de les faire correspondre à celles que nous avons
initialement là-bas. Il va donc venir ici et
me permettre de le copier et de l'utiliser que je puisse le faire
beaucoup plus rapidement et dire que
ce sera mardi, le deuxième jour de la semaine. Et dans le cas numéro, je veux dire, nous
allons certainement faire une pause. Donc, si vous ne mettez pas de pause, cela va frapper le diable ne comprendra pas
correctement comment
faire correctement ou quoi
faire dans ce scénario. Tu vois ? Il est donc toujours sage de l'utiliser de la manière suivante. Très bien, donc nous avons le
point ici épuisé. Nous avons une journée sauvage et
une pause. Et nous avons le kaizen avant d'être
donné jeudi. Avec pause. Ouais. Donc, comme vous pouvez le voir
, il y a certainement plus de lignes
ici C'est du mucus avec la spécification de tout un
tas de conditions. Lloyd, affaire numéro cinq, je pense que je vais probablement m'arrêter
à Kids numéro sept. Alors supporte-moi ici. Vendredi. C'est vendredi là-bas. Et juste
une pause café ici aussi et le cas, laissez-moi simplement copier
tout cela devrait être beaucoup, beaucoup plus rapide comme ça. Affaire numéro six et
affaire numéro sept. Et voici samedi
et dimanche. dimanche. Bon. Donc, ce que nous attendons de cela, puisque nous
vérifierons la journée là-bas, ce qui va se passer, c'
est que Java va parcourir, vérifier, prendre le numéro cinq et le
scanner avec tous ces conditions ici,
c'est la condition 1234. Et quand il y
a une correspondance de cinq, comme vous pouvez le voir, il obtient déjà
un Metro Five. Il y en a cinq ici
et il y en a cinq, qu'il
soit déjà
surligné. Il sera imprimé vendredi. Alors lançons-le vendredi. Très bien, tellement beau. C'est généralement ainsi que
nous nous
débrouillons tout le code Java. Code Java complet en ce qui
concerne les instructions conditionnelles, c'est-à-dire les instructions conditionnelles.
9. Boucles Java: Très bien, la prochaine chose
que nous allons
examiner est ce que nous appelons les boucles Java. Il s'agit d'une boucle Java, en particulier nous allons
commencer par les boucles while, ce qui
signifie qu'un certain
nombre de boucles. Mais nous allons nous concentrer
sur la boucle while. Et les boucles elles-mêmes. Molécule comme
la façon dont nous définissons la boucle en anglais, c'est quelque chose qui est presque, pourrait-on dire répétitif. Ils peuvent exécuter un
bloc de code
tant que la
condition spécifiée est atteinte. Ils sont très pratiques
car ils permettent de gagner du temps, réduire les erreurs dans le code
principal plus lisible. Et le code Java, ce sont les mêmes textes qui peuvent être vus de la
manière suivante. Permettez-moi donc de mettre
le commentaire ici juste pour que
nous puissions inclure un commentaire ici. Tu vois, c'est bien. Très bien. La syntaxe pour cela
serait donnée par, laissez-moi juste l'avoir ici pour nous, la syntaxe sera donnée
par la condition while. Comme vous le savez, j'adore mettre les conditions
entre parenthèses comme ça. Il suffit d'être éradiqué et vous savez comment
mieux les utiliser. Et évidemment, nous allons
ouvrir quelque chose là-bas et ensuite nous avons
un code à exécuter ici. Ensuite, nous allons
le fermer avec ce type ici. Cela signifie donc que c'est probablement
tout
ce dont vous pourriez avoir besoin et fermez-le
simplement là-bas. Très bien. Un exemple de cela
serait quelque chose comme ça. Permettez-moi donc de dire, par exemple, int I est équivalent à un. Et je dis, je donne une
condition alors
que j'ai moins de cinq
ou cinq ans, pourquoi pas ? C'est ce qui devrait se passer. Système. Dot out, dot, print, print I. Très bien. Alors qu'est-ce qui se passe ici ? Ce qui se passe jusqu'à présent, c'est que
nous disons à notre code
que même si j'ai moins de cinq ans, continuez à faire ce qui suit. Continuez à montrer la valeur de I. Et ne vous arrêtez pas là. Augmenter. Et c'est moi
qui mets l'augmentation. Je dis « e plus plus ». Je dis un placard comme celui-ci. Continuez à monter. Faites un incrément de
plus un à chaque fois. Donc Java va en prendre un, comparer à
cinq et voir que, hé, c'est moins de cinq,
puis ce que vous allez faire, vous prenez la valeur de
11 et vous l'imprimez comme un, puis descendez et ajoutez un à lui-même à nouveau
, puis revenez en arrière pour dire, maintenant j'ai un plus un. Maintenant, il y en a deux. Et voici comment démontrer
qu'il en sera un, puis un. Ensuite, vous aurez un plus un. Et puis tu auras
un plus un plus un. Ensuite, vous aurez un
plus un plus un plus un plus un. Et puis il s'
arrêtera là. Par conséquent, les valeurs que
vous obtiendrez seront essentiellement un plus deux plus
trois plus quatre. Tu vois ça ? Alors lançons-le pour
nous et voyons ce que nous obtenons. Voilà, 1234. Telles sont les
valeurs que nous obtenons. Et rappelez-vous simplement que la raison pour laquelle nous nous sommes
arrêtés à quatre heures et nous n'allons pas au-delà ou comme sur un cinq ou
quoi que ce soit d'autre. C'est simplement parce que nous avons
dit moins de cinq. Si nous avions dit moins
ou égal à cinq, cela aurait été
différent parce que cela signifie que cinq est inclus. Mais dans ce cas,
cinq ne sont pas inclus. Maintenant que c'est vrai, cela nous
permet de voir la différence. Tu verras qu'il arrive à cinq. Voyons voir, des données
de un à cinq. Maintenant, tu vois ça. C'est donc juste une
façon de contourner ce problème. Juste un peu de
prudence ici, s'il te plaît, souviens-toi de ça. Laisse-moi juste te le mettre. N'oubliez pas d' augmenter la variable utilisée
dans la condition. Ne présumez pas, bien sûr,
ne présumez pas cela. Cela suffit à
faire monter l'
œil. Non, ça ne l'est pas. Ce n'est vraiment pas le cas.
Et il ne saura même pas quand arrêter est
votre risque de faire une boucle de fin, sans fin, laissez-moi simplement supprimer cela et
réduire quelque chose. Ouais. Si je cours de cette façon, voyons ce qui se passe ici. Il continue à fonctionner 111111. Pourquoi est-ce qu'il fait ça ? Il continue à le
faire parce qu'il va simplement rester à un niveau
infini de celui-ci. C'est pourquoi mon ordinateur
a même du mal à voir qu'
il continue de tomber en panne. Je peux même faire défiler vers le bas ou vers le haut. Franchement, je ne peux pas La seule chose que j'ai à faire
à ce stade, c'est de
pouvoir refaire. Et je vais arrêter
ça ici aussi. Je l'ai arrêté et relancé. La raison pour laquelle cela
s'est produit, c'est parce qu'il
prend la valeur d' un et qu'il répète ensuite pour vérifier à nouveau contre
la volonté de l'un. Et à chaque fois, il continue de prendre la Villa d'un et de
prendre ce bouton cinq, mais un vaut moins de cinq. Alors, que dois-je faire ? Je devrais imprimer I, qui en est un. Et ça me donne ça
encore et encore. C'est donc une boucle infinie. Il continuera à le
faire. Cela ne s'arrêtera tout simplement pas. Vous devez donc avoir certaines de ces conditions en
dessous pour le donner, quand doit-il s'arrêter ? Comment devrait-elle savoir
qu'elle doit s'arrêter ? Attends. Donc, lorsque vous
lui donnez cet incrément, vous dites de continuer à monter, continuer jusqu'à ce que
vous atteigniez la colonne vertébrale, la déclaration ici,
et c'est vrai. C'est là que tu arrêtes. Vous voyez que c'est très
précieux et très important de comprendre
cela également, n'est-ce pas ? Et juste couplé à la condition
while est ce que nous appelons la condition par défaut. Et juste les quatre conditions. Laisse-moi juste les déplacer, les
mettre ici. Magnifique. Les quatre conditions sont donc calmes. L'une de ces conditions
qui sont
beaucoup utilisées et comment elles fonctionnent
vraiment, c'est comme ça. Laisse-moi juste te le poser. Nous l'appelons la boucle Java for. Et nous utilisons celui-ci lorsque
vous savez exactement combien de fois vous voulez
parcourir un bloc de code. Au lieu d'une boucle while. While loop, si vous ne savez pas, quand cela s'arrêterait-il, n'est-ce pas ? C'est comme si tu
imposais une restriction. Mais pour, tu
sais vraiment ce qui est le début, tu sais quelle est la fin. Et la syntaxe que nous utilisons pour
celui-ci est la suivante. La syntaxe est vraiment la suivante. Nous disons que pour mon défilement vers
le bas, nous en voyons quatre. Nous avons mis la déclaration un, la déclaration deux. Ensuite, nous avons également mis la
déclaration trois. Gardez à l'esprit qu'
entre les deux,
nous mettons des
points-virgules au lieu de
simplement des virgules comme ça. Nous mettons des points-virgules. Et puis, comme vous le savez, nous ouvrons toujours ici et vous
voulez fermer également. Et là, nous avons juste
un code à exécuter. Exécuté. Vous vous
demandez probablement à ce stade ce que l'on appelle statement1. Qu'est-ce que la deuxième déclaration, qu'est-ce que cela signifie
, qu'est-ce que tout cela signifie ? Eh bien, il s' agit vraiment de
cette instruction, ce qu'elle fait c'est une instruction qui est
réellement exécutée une fois avant que l'exécution
du code de bloc ne soit exécutée. Une fois avant l'exécution du code. Ensuite, déclaration deux. D'autre part, il définit ce qui
définit la condition. Condition, définit la condition
d'exécution du code. Et enfin la
déclaration trois. La troisième déclaration est tout au sujet, c'est juste que c'est la
dernière étape que vous pourriez dire exécutée après le froid signifie après que le code a été
exécuté, bien sûr, non ? Donc, un exemple de cela serait probablement
quelque chose comme ça. Voyons si nous pouvons simplement le
trouver ici et dire, car x est égal à 0. Ensuite, nous disons la déclaration deux. Nous disons que I est inférieur
ou plutôt pas I, x est inférieur à sept. Et finalement
on se dit : « Hé. Je suis le x continue d'augmenter de la
manière suivante, ce qui signifie qu'il a un incrément. Et nous n'avons qu'à ouvrir
les parenthèses là-bas. Et nous imprimons, nous imprimons simplement x. Donc, juste pour prédire ce qui va
se passer, nous définissons essentiellement
la valeur de
x à partir de , à partir de, à partir de 0. Nous définissons que x est égal à 0. Ensuite, nous lui donnons une condition pour dire que x est inférieur à 0. Ensuite, continuez à
faire ce qui suit. Qu'est-ce qui devrait continuer à se produire ? Il suffit de continuer à en ajouter un,
car c'est x plus plus, ce qui signifie un incrément de un. Donc le couponing passe, encore une fois, encore, encore. Donc, ce que Java va faire, c'est
qu'il prend la première valeur, vérifie contre sept et voit
que nous n'avons que 0, non ? Ensuite, à partir de là, il
sera juste à partir de 0. Il y aura un incrément
de 0 plus un. Encore une fois, continuez à le
faire, 0 plus un plus un. Et puis encore 0
plus un plus un, plus un plus un, et ainsi de suite et ainsi de
suite jusqu'à ce qu'il passe complètement
à six parce que c'est moins de sept, il ne
devrait pas atteindre sept. C'est donc de 0 à 6. Cela signifie donc que lorsque nous exécutons ceci, nous devrions simplement voir des valeurs
allant jusqu'à six. beau, ça y est. C'est exactement ce à quoi
nous nous attendions, et c'est exactement ce qu'
il a fait, non ? Alors c'est tout simplement incroyable,
c'est tout simplement incroyable. exemple auquel vous pouvez
certainement penser ou simplement trouver une valeur
serait celui-ci. Permettez-moi de commenter
ceci et mais, mais, euh, c'est vrai. Il suffit de commenter cela et considérons le scénario
suivant. Et si vous aviez, par exemple, pour la fin, il est définitivement temps. J'adore le français de ma part. Plutôt sympa. Je dis que c'est inférieur ou
égal à peut-être dix. Et puis je passe
à l'acte final simplement à monter
de deux
au lieu d'en faire un. Tu vois ça ? Donc maintenant je monte de deux,
puis je dis « système éteint », print LN » et les responsables
disent « Hé, imprimez-le ». Et ce qui va se passer ici, c'est que vous pouvez
probablement prédire, si nous allons
avoir le suivant. Nous allons avoir 0, puis nous allons avoir
un incrément de plus deux. Ce sera donc 0 plus deux. Ça va ? J'espère que vous
voyez déjà où cela va nous mener. Nous allons être à 0. Et puis plus deux,
plus deux, d'accord ? L'incrément est vrai,
ce n'en est pas un, non ? Cela signifie donc notre augmentation. Chaque étape sera juste par deux. Nous l'avons donc maintenant à six heures. Il n'est toujours pas plus grand que dix. Donc ça va enfin s'arrêter
là aussi, comme deux plus deux plus deux. Et trouvez que c'
est huit, non ? Et ce qu'il va
réellement faire, c'est comme ça qu'il va réellement se passer. Maintenant, je
vous dis juste qu'avec le recul ai pas
déjà
fait plusieurs fois. Il vérifiera et dira 0, puis vérifiera et définira maintenant pour enregistrer la valeur de
true, l'imprimer. Il affichera une valeur de 0,
une valeur de deux. Ici, il affichera la
valeur de deux plus deux, soit quatre ici il affichera la valeur de deux plus deux
plus deux, soit six. Ici, il affichera la
valeur de deux plus deux plus deux plus deux plus deux,
soit huit. Et quand il arrive, dit que
c'est dix heures. Il le fera passer par
scan et dira, attendez, dix est dix inférieur
ou égal à dix. Ensuite, la réponse est oui. En fait, c'est parce que
c'est égal à deux. Tu vois ça ? Il devrait donc même être
capable de prendre cette valeur également. En fait, je n'avais pas vu que
je mettais un signe égal ici, mais comme il y a
un signe égal, oui, il va
certainement s'inscrire. C'est dix, donc il
affichera 0246810. Alors lançons-le et voyons par
nous-mêmes, il y a 0248610. Et gardez à l'esprit que
si je supprime le signe égal, il s'arrêtera à huit
, ce sera de 0 à huit. Loi Var, c'est-à-dire les données. C'est tout simplement incroyable. Magnifique. Le prochain qui voudrait
certainement se pencher est appelé Java each loop. Java chaque boucle, d'accord ? Et pour celui-ci, est comme
ça que nous l'avons en Java chaque boucle,
c'est comme ça que nous écrivons chacune,
chacune à partir de l'anglais en
fait. Pour chaque groupe. C'est pour chacun, pour chacun, pas seulement
pour chacun, car chacun devrait être pour
chacun tout le temps. Très bien, donc pour celui-ci, la syntaxe est
vraiment de la nature suivante. Nous disons quatre, puis nous mettons
le type d'une variable. Et nous avons mis le nom de la
variable ici. Et juste là,
nous avons mis un nom de tableau. Et on l'ouvre comme ça. Ensuite, nous
avons simplement notre code. Ici. C'est du code à
exécuter comme toujours. code à exécuter
est juste là. Et oui, juste pour garder à l'esprit que tu
dois fermer ça, non ? N'oubliez pas que vous
voudriez probablement avoir quelque chose
comme ça ici. Très bien, c'est très important. Et juste, juste comme ça, Essayons de voir
un exemple de cela. Supposons que nous ayons une chaîne contenant des noms
de coûts, n'est-ce pas ? Et laissez-moi simplement le faire parce que mon clavier n'en possède pas
intrinsèquement,
donc je dois toujours modifier mes votes clés
pour le faire. Si vous utilisez un ordinateur ou
un Mac qui n'a pas
la place de nombreux boutons, vous pouvez toujours changer de
clavier ici. Tu t'en souviens ? Alors ? Nous pouvons toujours
venir aux voitures ici. Et nous avons juste, par
exemple, Volvo. Nous pourrions avoir, par exemple, BMW. Oui, tu as dit que ça
pouvait être VW, Volkswagen. Il se pourrait que les
Américains adoreraient celui-ci. Cela pourrait certainement être
Honda, au Japon. Vous pouvez donc également l'
avoir. Et puis juste ici, que faisons-nous, que faisons-nous ? Eh bien, nous ne l'
ouvrons pas vraiment à ce stade. C'est quand nous commençons
à utiliser les quatre que nous commençons à ouvrir les
choses pour le moment, c'est juste une liste d'entiers, un tableau contenant
une liste de données. Donc c'est chaîne, chaîne I. Ensuite, nous disons cos. Ouais. Ensuite, on l'ouvre. Maintenant. Maintenant, c'est
le moment d'ouvrir. Et puis nous disons « système out dot print »,
par exemple, n'est-ce pas ? Donc, simplement, cela signifie
donc dans ce scénario, exécutons-le et nous
voyons là le beau. Cela signifie donc que pour chacune
des choses que
nous voyons dans une liste, des listes
continues comme celle-ci, nous avons pu
présenter chacune d'entre elles. Cela signifie donc que Java a pu
passer par chacun d'entre eux. façon dont Java interprète
cela est comme ceci. C'est presque comme si cela
était représenté par une valeur de 0. Et puis la valeur
un, la valeur deux ici. Mais si trois valent quatre, et simplement en faisant cela, nous vous disons
que c'est une chaîne. Imprimez la valeur un, puis il comprendra. Donc, l'un est en fait une
chaîne et il représente, il représente une chaîne de Volvo. Donc, il imprimera Volvo, représenté par la valeur de 0, puis viendra à un
et c1 est BMW puis arrive à deux et c2 comme vw, puis C arrive à
trois, puis
S3, S4, puis arrive à quatre. Et la C4 est une Honda, non ? Ben le mien que j'ai commencé avec
0 et c'est comme ça qu'en Java compte commence
toujours
à partir de 0 et monte. Cela ne s'arrête pas là et voit nécessairement comme un 0. C'est donc quelque chose
d'autre à garder à l'esprit et à voir sa valeur, car nous sommes toujours sur ce sujet très
intéressant. Un sujet intéressant.
10. Pause Java et continue, tableaux: Très bien les gars, donc la prochaine
chose que nous
allons certainement vouloir aborder aura à voir
avec ce que nous appelons Java break and continue. Donc Java break and continue, ça fait toujours partie de ce que
nous sommes encore en ce moment. Ça fait toujours partie de ça. Et ce que nous
allons faire avec ça, tu verras aussi. Pour cela, nous avons déjà
vu l'instruction break utilisée dans une situation extraterrestre de ce dont nous avons
parlé. Et nous l'avons utilisé évidemment
pour sortir d'une
instruction switch, non ? Nous pouvons également utiliser l'instruction break pour sortir d'une boucle. Sautez hors de la boucle. Et évidemment, ce
sera un commentaire. Ça va ? Et la meilleure façon de le
démontrer serait, disons que vous avez quelque chose
de la nature suivante. Tu devais dire « tomber ».
Et puis tu dirais « fin ». I est équivalent à, disons est équivalent à 0. Et comme vous vous en souvenez, chaque fois que vous en avez quatre, vous
devez avoir trois déclarations. Permettez-moi donc de définir quelques
autres affirmations pour moi-même ici et de voir ce que je
peux en tirer. Ça va ? Très bien, et ainsi de suite. Et puis nous disons, si E
équivaut à quatre, non ? Quatre comme ça, que
devrait-il se passer ? Ensuite, il devrait y avoir un
saut hors de cette boucle. Nous l'avons donc. Et puis que dois-je faire ensuite ? Je dis juste « système point out », point print LN », et j'
ai l'œil là-bas. Très bien, passons
simplement par ici et voyons ce que
nous en retirons. Et voilà, nous l'avons. Nous avons les valeurs
comprises entre 0 et 3. Et la raison en est que nous avons simplement
indiqué notre code ici,
notre logiciel, java pour
faire cela, commence à partir de 0. Et tant que cette condition est remplie, avoir
un nombre inférieur à dix avec
des incréments de un à chaque fois. Que devrait-il se passer ? Ce
qui suit devrait se produire si je suis équivalent à pour
le moment où je passe à
la valeur quatre, puis arrête. Vous voyez ce que fait Java. Il commence à 0, fait
cela et remarque que, hé, nous sommes 0 c'est
définitivement moins de dix. Ensuite, il
imprime la valeur de tous les chèques ici également. Certainement, il va vérifier ici et vérifier et dire que, Hey, je suis 00 n'est pas égal à quatre. Il n'est donc pas nécessaire
de venir à cette pause. Il va sauter et venir ici
et imprimer la valeur de 0, puis monter d'un,
puis prendre la valeur de un, la
vérifier par rapport à la balise et voir
si elle est plus grande ou inférieure à, et voir qu'elle est inférieure à. Ici encore,
vérifiez-le par rapport à quatre et vérifiez si un est égal à quatre. Et il découvrira évidemment
qu'il n'est pas égal à quatre. Donc, ce qu'il fera,
il sautera à nouveau, affichera la valeur de un,
ainsi de suite, jusqu'à ce qu'il atteigne le lieu de,
de, jusqu'à ce qu'il
atteigne la valeur de quatre. Quand il arrive à
la valeur de quatre, suivi est toujours
satisfait, non ? Mais quand cela devient odieux, voyez que quatre est égal
à quatre et ensuite neutre. Donc, je vais rompre. Cela s'arrêtera ici et on viendra imprimer
cette valeur ici. Tu vois ça ? Il n'est donc pas nécessaire d'imprimer cette
valeur ici. Mais si je devais
dire, par exemple, si je devais supprimer ou si je
devais avoir cette impression ici et dire simplement si je
devais l'imprimer ici. Si je devais imprimer ceci
et le mettre à quatre ici, il devrait imprimer la valeur de I. Il enregistrerait certainement la valeur de quatre qui
était là, n'est-ce pas ? Mais oui, c'est tout à
fait logique. Je l'espère maintenant. Ensuite, nous
allons continuer et parler de ce qui se passe. Voici notre commentaire. Donc, la prochaine chose dont nous
voulons parler est certainement la suite Java. Ils vont de pair. C'est une pause et on continue. L'
instruction continuous interrompt donc une itération dans la boucle. Si une condition spécifiée
se produit et continue avec l'
itération suivante de la boucle. C'est donc presque comme si nous
sautions cette zone que nous cherchions
peut-être à obtenir. Par exemple, dans le
problème même que nous avons ici, les différentes situations
que nous avons ici. Copions simplement ça et
collez-le ici. Au lieu de faire
une pause ici, si
j'avais mis
peut-être continuer ? Quel en est l'effet ? C'était l'effet d'
avoir définitivement continué là-bas. Et il y a un petit problème, comme vous pouvez le voir avec
mon code ici. C'est bon maintenant que nous l'exécutons. Et maintenant pas 0123,
il n'y a pas de faux. Nous sautons jusqu'à 56789.
Tu vois ça ? C'est parce que nous avons dit que lorsque quatre est
égal à quatre, contigu, c'est-à-dire il n'est pas nécessaire de l'imprimer. Il suffit de le sauter et de
revenir à cela également. C'est pourquoi il ignore la
valeur de quatre. Donc, essentiellement, c'est
comme ça que continue fonctionne. Des gens géniaux. Ensuite, la prochaine chose que nous
voulons examiner est probablement l'
une des plus essentielles
en matière codage, qui a
tout à voir avec ce nous appelons les tableaux, les tableaux java. Alors laisse-moi juste te le poser
. Tableau Java. C'est ça, non ? Et avec les tableaux Java, nous utilisons des tableaux pour
un certain nombre de choses. Honnêtement. Nous pouvons les utiliser, par
exemple, pour stocker, stocker plusieurs valeurs
dans une seule variable. C'est ce qui fait la beauté. rendu peut se caler. Par exemple, il peut stocker
une collection de voitures, collection de tailles de
personnes différentes, toutes sortes de statistiques, vous pouvez
vraiment
les conserver et les stocker
dans une catégorie, peut-être la taille des personnes. et les
différentes couleurs que vous voyez. La chose clé à savoir est que lorsque vous voulez déclarer un tableau, vous devez d'abord définir le type de variable
avec des crochets. Et comment faites-vous cela ? Eh bien, essentiellement, tu le
fais comme ça. Évidemment, je vais
faire un exemple, mais je veux juste vous aider à vous
familiariser avec la syntaxe. J'ai mon carré ici. Permettez-moi de changer le clavier
et c'est ici. Laisse-moi juste l'ouvrir.
Je peux le copier et le coller d' une manière que je connais parce que
je l'avais déjà utilisé, je crois aujourd'hui à un moment donné. Non, je ne l'ai pas encore utilisé. Pas de problème. On va juste le
donner comme ça. Et laisse-moi voir sur mon clavier où je peux trouver un
moyen de fermer ça. Donc, oui, c'est
celui là. Très bien. C'est beau. Très bien.
Nous allons donc comme ça aussi. Excellent, excellent. Donc si vous êtes dans une
situation comme la mienne où vous n'avez pas trop de choses à
explorer sur votre clavier. Vous pouvez toujours utiliser ce fond de repère
visuel avec. Et puis tu as des voitures, non ? Et c'est un chapelet de voitures. Et avec cette chaîne de voitures, vous pouvez
vraiment y stocker autant de voitures que vous le
souhaitez. Parce que lorsque nous avons fait cela, nous avons déclaré
une variable qui contient un tableau de chaînes
pour que les entiers y ajoutent des valeurs. Nous pouvons simplement utiliser un
tableau littéral et lire
les valeurs dans une
liste séparée par des virgules entre accolades. Comment faisons-nous cela ? Eh bien,
voici maintenant l'exemple. Alors laisse-moi juste crier
et on dit ficelle. Permettez-moi de prendre littéralement cet exemple qui devrait être
plus facile à faire avec ce que j'ai déjà des voitures de traction et n'ai pas changé
de clavier. Génial ! Donc des screencasts et ensuite nous
disons que c'est un outil équivalent. Ensuite, plaçons
nos voitures là-bas. Nous pourrions avoir, par exemple,
Toyota, Ford de la part de mes amis
américains. Mais comme tu peux le voir, c'est en rouge. Pourquoi est-ce en rouge ? Parce qu'il ne l'identifie pas comme une chaîne. Nous devons donc mettre ces
guillemets. Génial ! est donc le cas. Ça y est. Ensuite,
nous pourrions avoir Toyota, nous pourrions avoir FADH, nous pourrions avoir Ferrari,
nos Italiens. Nous pourrions avoir une Mercedes Benz. Nous pourrions avoir autant de
voitures que nous le voulons, mais je pense que ce sera
suffisant pour le moment, vraiment. Et voilà, c'est aussi
simple que cela. Et cela ne fonctionne pas
uniquement pour les objets
orientés chaînes de caractères,
ou pour les sujets de chaîne. Nous pourrions également le faire
un peu pour les entiers, c'
est-à-dire
aussi pour les valeurs, n'est-ce pas ? Et pour ce faire, nous le faisons simplement, passant simplement à la chaîne, nous allons simplement copier cela. Et nous avons int. Maintenant, nous avons ceci
et nous disons mon numéro. Nous pouvons déclarer une
variable Nino comme ça. Ensuite, nous ouvrons et commençons à
stocker des valeurs de dix à 20 à 30 à 40. C'est à nous d'être aussi libres et explorateurs que
nous le voulons, n'est-ce pas ? C'est donc une bonne chose. Nous commençons toutes ces valeurs en un seul endroit, mes chiffres, n'est-ce pas ? Supposons que, par exemple, vous souhaitiez accéder aux éléments
de ce tableau, n'est-ce pas ? Laissez-moi simplement
l'écrire pour nous. Accédez aux éléments du tableau. Comment ferait-on cela ? Eh bien, pour faire ça, ou je devrais le faire
, par exemple, disons que je voulais
accéder aux éléments de ce tableau ici,
c'est cette zone. Comment est-ce que je pourrais faire ça ? Eh bien, tout que
j'aurais à faire c'est que
je vais juste dire system out dot print LN, préférence comme les
imprimer de cette façon. Ensuite, en
les sélectionnant comme coûts avec nos éléments ici et ici. Entre mes deux
carrés là-bas. Ce que je fais c'est que je peux choisir
ce que je veux faire ressortir, non ? Souvenez-vous que lorsque Java le sait, il connaît ce S. Ce
S correspondant à 0, l'ensemble S correspondant à deux comme un plutôt ce
correspondant à, ce correspondant à trois, et ainsi de suite et ainsi de suite. Vous voyez que si je
devais dire, par exemple, 0, ce que Java obtient de cela, c'est que je dois imprimer la première
carte que je trouve, n'est-ce pas ? Parce qu'il commence à
compter de l'oral pour commencer à
afficher les sorties à partir de 0. Alors allons-y. On devrait voir une Toyota, voilà. C'est-à-dire que nous avons
une Toyota, non ? Si je devais dire trois, par
exemple, trois
signifie que si c'est 0, c'est un, c'est deux,
c'est 33 devraient être des coudes. Alors lançons-le et voyons si nous obtenons des courbes,
en effet, des échéances. Ouais, génial. Mercedes Benz en action, non ? Imaginons que
tu veuilles peut-être le faire. Vous voulez changer, disons que vous voulez peut-être
changer un élément de tableau. Un élément de tableau. Comment ferais-tu ça ? Eh bien, pour changer
un élément de tableau, vous suffit de spécifier l'élément que
vous souhaitez modifier, n'est-ce pas ? Donc, par exemple,
disons que je voulais changer Ford en ayant
beaucoup pour aujourd'hui. Changeons cela
uniquement pour le prêt. Disons que les voitures,
puis sélectionnez combattu, lequel est à 123 ou quatre. n'y a pas de force
10123 en fait. Donc nous allons simplement choisir le
premier, qui est 01, qui représente
combattu, puis disons Cars 01 et ensuite les
remplacer par. Que diriez-vous d'Aston Martin ? Quant à Martin ? Aston Martin, l'idée bénigne et
déviante d'un peu fan de voitures,
vraiment de voitures de sport. C'est-à-dire que nous pourrions avoir une rediffusion en avant avec
une Aston Martin, non ? Au moment où
nous l'aurons,
tout ce que nous avons à faire, c'est de simplement
imprimer à nouveau cancer. Donc on pourrait juste dire
au lieu d'imprimer tonne numéro trois, qu'en
est-il de ça ? si je reprenais ce type et que je le plaçais ici maintenant après le changement et que je l'
enregistrais simplement en tant que kirwan. C'est parce qu'il y avait autrefois
des combats là-bas. Mais cela a changé. C'est devenu une montagne de pierre. Nous devrions avoir
nos stomates maintenant, Aston Martin DB neuf. C'est donc ça la beauté. Maintenant, vous vous demandez probablement
pourquoi j'ai dû changer ça. Eh bien, disons que c'
était le cas. En fait,
disons qu'il y en a un juste ici. Laissons-le et ensuite nous
verrons ce qui va
se passer là-bas. Il s'est encore battu. Pourquoi est-ce que c'est ? C'est parce que c'est Java. Il lit le code ici. Cela commence ligne par ligne. Ça date de 187188. Donc, en ce qui concerne 188
ou 1921, quand je lui dis de lancer et de me donner
la valeur que l'on a ici, il avance
parce qu'il n'est pas encore compris ou plutôt reçu des informations que
cela devrait changer. Ce changement ne
se produit que dans la ligne 194. C'est pourquoi j'ai dû
faire ce que j'ai fait et simplement placer ici pour
que, lorsque je l'exécute, il comprenne
maintenant qu'à 1, il
y avait un changement. Maintenant Cao Huan veut dire et Aston
Martin doit avoir neuf ans, non ? C'est ainsi que nous procédons si nous
voulons modifier l'élément ROE. Mais que se passe-t-il si nous
voulons déterminer quoi ? Et si nous voulons
déterminer la longueur d'un tableau , par exemple, pour une
raison ou une autre, il est
possible que vous
souhaitiez connaître nombre d'éléments
présents dans un tableau. Et pour cela, tout ce que vous
avez à faire en 3D est simplement d'utiliser la propriété length. Et comment utilisons-nous
la propriété length ? Eh bien, fais-le. Permettez-moi donc d'utiliser la même
chose que nous avons utilisée ici, le système qui a pensé. Alors je vais juste venir ici. Au lieu d'imprimer des
voitures comme ça, je vais juste dire « voitures
et longueur », non ? Donc, quand je fais cela,
il devrait me dire combien d'éléments sont présents. Gardez à l'esprit. Cela ne compte pas à partir de 0123. Non, non, non. Il s'agit de compter nombre de valeurs
en premier lieu. Il compte 0 et x1, il est passé à un, S2, S3 à S3, et son
contenu trois vaut quatre. Donc, il devrait produire quatre éléments dans
le tableau, n'est-ce pas ? Parce que je lui demande
combien d'éléments se trouvent dans les zones où il est dit
quatre éléments dans la diarrhée, ce qui est vrai, c'est
1234, donc, non ? Donc c'est vraiment ce que j'
espère que cela aide vraiment.
11. Boucle de rayons Java: Ensuite, la prochaine chose que
nous voulons examiner est ce que nous appelons le Java. La boucle de tableau Java est certainement quelque chose
que nous voulons examiner maintenant. Et nous pouvons parcourir éléments de
notre tableau avec
une boucle pour les coûts. Et nous pouvons même utiliser la propriété length pour spécifier combien de fois
la boucle doit être exécutée. Bon ? Réfléchissons donc, par
exemple, à la
même situation que celle dans laquelle nous
avons notre chaîne ici. Supposons que, par exemple, nous voulions juste faire une petite
boucle là-bas, n'est-ce pas ? Essaie juste de faire
un peu de boucle. ce que nous pouvons faire. Nous pourrions simplement le prendre ici et le placer là où je
peux facilement y accéder, en particulier celui-ci, le
premier sur les voitures, S1 sur la cause. Très bien, laisse-moi
juste essayer de le réécrire. Moi-même. Juste par ici. Très bien. Voici le bras, la cause. Voici donc notre Again, laissez-moi réécrire ça encore une fois. Je pense qu'il s'est supprimé
lui-même java array loop. Disons que j'ai ce
qui suit. Disons que j'ai une chaîne et que j'ai
aussi ce qui suit. Cette formation à côté de cela, j'ai la
chaîne suivante avec les voitures et laissez-moi simplement mettre celle-ci maintenant entre parenthèses parce que je n'en ai plus vraiment
besoin. Donc je vais juste descendre d'
ici et déplacer celui-ci. Maintenant. Déplacez un
peu de travail en cours ici,
mais cela devrait être fait dans une minute. Ça va ? Donc, ce que je fais, c'est maintenant que je présente un
peu de boucle ici. Je dis que int I est égal à 0. Et là, je
dis que c'est moins cher. Et puis ils sont
longs, bien sûr. Et à ce moment-là, je dis
juste « je plus, plus ». Et je l'
ouvre pour que nous puissions l'utiliser. Et au fur et à mesure que
je l'ouvre,
juste comme ça, je vais juste
imprimer et mettre cette méthode d'impression ici juste pour pouvoir
déterminer ce qui se passe réellement ici. Cette fois, je ne vais
certainement pas imprimer en termes de longueur de voiture et plutôt que utiliser le E qui a déjà
été placé là-bas. Mais je vais certainement
vouloir le placer également dans mes carrés parce que c'est un tableau dont
nous parlons ici. C'est un tableau, nous ne
voulons donc pas le perdre de vue. C'est donc mon œil
et c'est prêt. Laissons ça et voyons
ce que nous allons trouver. Et c'est le cas, nous avons les éléments suivants. Nous avons Toyota, nous avons Ford, nous avons, nous avons des groupes, non ? Donc, en substance, ce que nous avons dit ici, c'est que nous avons
utilisé
cette technique de cette propriété length pour
pouvoir imprimer
tout ce qui s'y trouve tant qu'il ne dépasse
pas lui-même, comme tant qu'il ne
sort pas de sa liste de tableaux, cela devrait
continuer à se produire. Bon ? Ensuite, d'un autre côté, nous pourrions aussi simplement
parler de la façon d'utiliser R at, comment regarder à
travers, euh, un tableau avec quatre chacun, avec une instruction pour chaque, si vous voulez écrire pour chaque boucle, si
tu veux, c'est ça. La syntaxe pour cela se produit
clairement de
la manière suivante. Nous le faisons simplement. On pourrait dire pour annuler quatre avec des
majuscules inférieures. Ensuite, nous écrivons le
type de la variable avec laquelle
nous travaillons. Et puis il y a une
variable ici. Et puis nous
restons simplement le nom du
tableau, le nom du tableau également. Ici, il n'y a pas d'espace entre les deux. Et nous ouvrons ce à
quoi nous
voulons faire face. Tu vois ça ? Évidemment, nous n'aurons pas
à le fermer également. On
demanderait donc un exemple de cela en faisant quoi, par
exemple, utiliser
exactement la même chose. Permettez-moi simplement de les mettre dans Commons. Mets ça en commun. Bon ? Laisse-moi prendre
tout ça. Nous allons certainement
l'utiliser à nouveau ici. Supposons que nous ayons la même
série de coûts ici. Donc, ce que nous pourrions dire, c'
est que nous pourrions dire pour ce train que je suis la syntaxe des coûts
avec la cause. Et
en ouvrant également nos parenthèses, nous avons le système dot out, dot, print LN, print LN. Ensuite, nous pouvons simplement
l'imprimer, par exemple. Nous pouvons simplement imprimer ce que
je veux. Ensuite, nous essayons de le lancer. Et voyons ce que nous obtenons. On arrive à la
même chose, non ? Donc c'est juste une méthode de, vous pourriez dire que je suis une question
de technique si vous voulez. Vous pouvez certainement
les utiliser aussi librement que vous le
souhaitez vraiment C'est juste une question de technique
et de préférence sur la façon dont vous préférez que votre code ressemble. Ensuite, la prochaine chose que
nous allons examiner, laissez-moi simplement mettre cela dans Commons. La prochaine chose que
nous
examinons certainement est appelée tableau
multidimensionnel et
multidimensionnel Java multidimensionnel . multidimensionnel Java, non ? Et pour celui-ci, vous devez juste
garder à l'esprit que pour créer un tableau
bidimensionnel, vous devez ajouter
chaque tableau dans son propre jeu d'accolades. La syntaxe de ceci
serait quelque chose comme int. Et puis laisse-moi juste prendre
ce corset ici aussi. Laisse-moi juste faire ça. Super. Ouais. Mon bus Num par exemple. Ensuite, nous disons, nous l'
assimilons et ensuite nous le
mettons dans ses propres accolades. Donc, soyez très
prudent car cela
aura deux événements, soit 1234. Il y en a donc quatre ici. Nous nous arrêterons ici à quatre heures. Alors laisse-moi juste copier ce type
et le coller ici. Et puis nous disons coma parce que
nous continuons. Et on s'ouvre. Ensuite, vous dites
567 par exemple. Et puis on
le ferme comme ça. Et pas seulement une fois
, mais deux fois en fait. Et puis on le verrouille
comme ça, d'accord. C'est donc un exemple. Si je devais le
retirer de vos commentaires juste pour que vous puissiez voir s' il est reconnu par Java. Laisse-moi
juste essayer de le faire
et tu pourras vérifier
par toi-même. Alors c'est
ici, c'est ici. Et nous en avons fini ici. Et nos bretelles ici, A2, B2. C'est pourquoi il y a
une flèche là-bas. Ils sont donc là. Chacun, vous pourriez dire que
chacun représente sa propre chose et voir que
celui-ci représente celui-ci. Celui-ci représente celui-ci
ici même. Tu vois ça ? C'est donc essentiellement la
syntaxe. C'est essentiellement la syntaxe.
12. Tableaux multidimensionnels: Donc, il est juste intéressant de noter que maintenant que c'est
de cette façon, cela signifie que ces nombres de mines ici sont maintenant un tableau avec deux tableaux comme
éléments, non ? Pour accéder aux éléments
de mon tableau de nombres, vous devez spécifier deux index, un pour le tableau et un pour l'élément à l'intérieur du tableau. L'exemple que je pourrais vous
donner pour cela
serait quelque chose comme ça. Par exemple, supposons que nous
utilisions exactement la même chose
que celle que nous avons utilisée ici. Et puis nous devions dire que int
x est égal à deux de mes nombres. Et je devais en dire un, par
exemple. Permettez-moi d'essayer de copier ceci afin que je puisse être
beaucoup, beaucoup plus rapide. Est-ce que je veux le mettre
dans cette question ? Je vais plutôt copier
ce que je veux. C'est ce que je suis parce que
j'ai besoin de préciser. Le premier que je
spécifie est le tableau. Et puis le second que je spécifie est la
position dans le tableau. Vous voyez que le
tableau, puis la position dans le
tableau, c'est self. Supposons que je
précise quelque chose comme 12. Ouais. Donc, en spécifiant 12, qu'est-ce qui se passe réellement ici ? Qu'est-ce que je suis ? Qu'est-ce que je suis
en train de dire ici, non ? Donc, en spécifiant un ici, c'est celui que
cette première accolade ici, ou plutôt carré ici, contient des informations nous
indiquant dans quelle zone nous sommes,
sommes-nous dans le tableau 0 ? N'oubliez pas qu'il s'agit d'un
tableau un tableau 0. Souvenez-vous que c'est notre a 0, ou nous sommes dans le tableau un. Tu vois ça ? Donc c'est notre 0,
c'est déjà un. C'est en
ce sens qu'il s'agit. Le deuxième carré ci-dessus
contient des informations sur le moment où nous sommes
dans ce tableau. quelle position parlons-nous exactement pour extraire notre
élément de la mer ?
13. Loop For: Donc nous
continuons comme ça et disons système point, point
, print n. Et nous imprimons la valeur de x parce que c'est juste évaluer, c'est juste une valeur de
cela, juste une valeur de cela, juste pour vérifier que nous ne le faisons pas
J'ai autre chose là-haut. Et nous l'avons imprimé ici. Par conséquent, nous prédisons
que si je vends 12, cela signifie 01. Nous prévoyons
d'être ici. position deux par
centroïde est 012. Nous prévoyons qu'il
nous donnera une valeur de sept. Alors lançons-le et voyons
sept jours que c'est beau. C'est-à-dire qu'il y en a
sept là-bas. Et nous pouvons également utiliser une boucle for dans une autre boucle for pour obtenir les éléments d'un tableau
bidimensionnel. Et bien sûr, nous devons
encore attirer l'attention
sur les indices de 2x. J'ai encore
besoin de le faire. Un exemple de cela serait,
disons, utiliser for-loop,
utiliser le suivi, n'est-ce pas ? Un exemple de ceci
serait probablement spécifier et de créer
une méthode ici et de
dire, appelez-la publique. Je veux juste vérifier dans
quelle méthode nous sommes. Nous sommes déjà dans un vide
statique public. C'est déjà bien. Sauf que ce que nous
allons faire c'est redescendre
jusqu'ici. Et simplement, nous n'avons pas
besoin de spécifier la méthode parce que nous l'avons
déjà là-haut. Ce ne sera donc que la fin. Et nous copions à nouveau notre fin ici. Et au lieu même d'
écrire tout ça, je pourrais simplement le copier vraiment. Permettez-moi de copier et coller juste là et de dire mes chiffres. Et au lieu de me contenter de mes chiffres
ou de les mettre en un ici, juste pour le différencier du scénario précédent
que nous avions. Et ce que je vais faire
aussi, c'est que je vais juste dire que pour int je suis égal à 0, je suis inférieur à mon
numéro un, non ? Parce que c'est
précisément à cela que je fais référence. Leur longueur.
Tu te souviens de cette longueur ? C'est exactement ce que cela signifie. C'est avec la longueur. Et puis nous faisons
un incrément de I. Donc voilà. Nous avons un incrément de l'Iowa. Et nous ouvrons notre boucle
for ici. Ensuite, nous ajoutons une autre
boucle for ici. Et nous disons que pour int j est égal à partir de 0 également. Et dire 0 plutôt différent de zéro. Je préfère utiliser j non nul. Encore mes chiffres, la
longueur du point. C'est pas vraiment fini. Longueur du point. Laisse-moi juste le placer
comme ça à la place. Revenons en arrière. Et je vais juste prendre ça ici moins deux carrés ici
et les placer ici. J'ai donc mes deux, mon carré, juste un d'entre eux et s'il vous plaît mon œil juste là-dedans. Et c'est la longueur
que je recherche. C'est la longueur
que je recherche. Et continuez
à monter avec J vraiment, continuez à monter avec J vraiment. Et pour chacun de ces scénarios, je dois
imprimer des valeurs ici. Et en particulier,
imprimer ici mes numéros et
les avoir en termes de I et j, normalement ça devrait
fonctionner comme ça. Alors lançons-le et
voyons ce que nous en
retirons et
comprenons mieux ce qui
se passe ici, non ? Il s'agit donc simplement d'une situation dans laquelle nous essayons déduire ou de trouver toutes
ces valeurs à partir d'ici. Nous avons donc un int et nous
sauvegardons pour la fin, c'
est parce que,
essentiellement, qu'est-ce que je dis ? Je dis, tant que je, qui représente la moyenne de la zone, Remember array 0, array one. Tant que c'est
inférieur à sa propre longueur, est-à-dire qu'il a une longueur de
un de 0 à un, n'est-ce pas ? Cela signifie donc qu'il faudra
le premier 0 et qu'il viendra ici. Puisque 0 est autorisé ici, c'est certainement moins d'un. Ensuite, il viendra ici et imprimera ce qui
se passe ici. Imprimez ce qui se passe ici. En fait, la longueur ici, esprit
urbain C'est en fait deux parce que c'est la
longueur de ceci, c'est 12. Donc, il faudra 0, le vérifier, et voir que 0 est
définitivement inférieur à deux. Et passez à autre chose pour dire
qu'en est-il de J ? J est égal à 0. Et puis dites que j est inférieur à, j est inférieur à trois,
comme vous pouvez le voir ici. Combien d'éléments pour j ? Ils en journée en premier lieu. Donc pour j, en fait, ce n'est pas trois éléments. Ce sera 1234567. Il y aura donc
sept éléments. Il va donc simplement prendre
et stocker cette valeur de 0. Permettez-moi donc de mettre un
commentaire ici juste pour que
vous puissiez mieux le voir. Donc, comme je l'ai dit, il suffit de prendre la valeur de 0. Tout d'abord, nous
aurons un 0, non ? Alors contre ce 0, il va l'exécuter et
prendre un autre 0, non ? Et puis ça viendra. Et laisse-moi juste copier ça. Afficher la valeur qui correspond à
cela et 0 virgule 0. Évidemment, ça
va nous en donner un. Ensuite, cela viendra et cela
provoquera une augmentation de la manière. Cela provoquera une augmentation dans
la mesure où J est le consentement, non ? Donc, cela
provoquera simplement une augmentation salaire consenti, donc ce sera 01. Et donc 01, comme
vous pouvez le voir, c'est 0, c'est dans ce tableau, un, ça veut dire vrai ici,
donc ça va être deux. Et puis nous arrivons ici, nous disons, qu'en est-il de trois ? Ici ? Il y en aura maintenant deux, ce qui fera trois, comme nous pouvons le voir ici, et ainsi de suite. Je peux probablement supposer que
vous avez déjà vu
un petit schéma qui émerge
définitivement. Permettez-moi donc de modifier
ces valeurs pour nous. Il va y en avoir trois ici, il va y en avoir quatre ici. Il y en aura quatre ici, il y en aura cinq ici. Alors ici, il y en
aura cinq ici, ce qui mènera à six ici. Et puis ici, il y en
aura six ici, ce qui mène à sept ici. Maintenant pourquoi cela finira-t-il,
et au fait, quand il se lèvera pour me
laisser voir 0123 ici, normalement ça
va changer ici. Ça va être plutôt un. Et puis, parce qu'
il est maintenant dans cet ensemble, puis il va chercher
la position ici et recommencer à partir de 0, non ? Donc ça va se passer comme ça. Et là, il y en
aura un. Et là, il y en
aura encore une. Alors ici ça va
être maintenant un, et là ça
va être deux, non ? C'est donc essentiellement ce qui
nous donnera ensuite toutes ces valeurs. Si vous essayez de les
localiser vous-même,
nous aurons besoin d'un stylo ou d'
un crayon et de papier. Et essayez de localiser 00. Vous verrez que c'est un
01, c'est 2023034105116127. Tu vois ça ? C'est donc
essentiellement ainsi que cela donne un sens
à ce qui se passe. Bon, juste ici,
bon , juste ici, non ? Donc, ce que nous allons faire ensuite , c'
est simplement
passer à la zone suivante, passer à la
prochaine étape vraiment.
14. Méthodes: Très bien, donc la prochaine chose
que je vais certainement
examiner
est liée aux méthodes Java. Probablement la chose la plus
importante que vous
rencontrerez lorsque vous utiliserez Java. Et pour bien comprendre celle-ci, nous allons
définir la méthode de l'eau douce est une méthode simplement une méthode
est juste un bloc de chaîne. Ce bloc de chaîne, ou un bloc de code qui ne s'exécute que lorsqu'il est froid, non ? Donc vous l'appelez, alors vous pouvez
certainement l'utiliser. Vous pouvez donc transmettre des données
appelées paramètres à une méthode. Et les méthodes sont utilisées pour effectuer certaines actions et elles sont également
appelées fonctions, n'est-ce pas ? Bon. Ouais. Et pourquoi
voudrions-nous utiliser des méthodes ? Vous vous demandez probablement pourquoi. Eh bien, en vérité, c'est juste
pour réutiliser du code, en fait. Réutilisez le code. Définissez
le code une fois. Et tu l'utiliseras
autant de fois que tu voudras. Autant de fois que tu veux. Ça va ? Alors c'est ça, non ? Et la chose clé que vous vous demandez probablement
maintenant est donc, comment créer une méthode ? Pour qu'un métal
soit créé, il doit d'abord être
déclaré dans une classe. Et il est défini par
le nom de la méthode, suivi de la
parenthèse, bien sûr. Et bien sûr, Java fournira
des méthodes prédéfinies telles que system.out.print,
line comme vous le savez. Et, mais vous pouvez également créer votre propre méthode pour
effectuer certaines actions. Par exemple,
supposons que vous vouliez
créer une méthode dans main. Donc, ce que vous faites, c'est
simplement dire,
voyons, allons jusqu'en haut
et mettons tout
ici dans les commentaires
parce que nous n'en avons pas besoin. Bon, bon, juste ici. Dans notre classe publique, au lieu
même de la rendre publique,
nous
allons simplement en faire
une classe statique de la manière suivante,
puis l'appeler, l'appeler. Appelons-la MyMethod. Il est plus facile de l'appeler comme cette méthode principale MyMathLab. Et
c'est ma méthode. C'est juste notre propre méthode, non ? Et avec ça, notre propre méthode, ce que je vais faire c'est que j'ai besoin ça parce que laisse-moi mettre
ce type ici. Assurez-vous que tout
est sous commentaires et qu'il n'y a pas d'erreurs que nous collectons ici,
en particulier ici. Et voilà. On n'a pas besoin
de ça, non ? Bon. Excellent. Maintenant que nous
l'avons sous cette forme, nous allons simplement l'appeler notre méthode. Et puis, littéralement, nous
aurions pu tirer pour être
exécutés, non ? C'est ce que nous devons exécuter. Un exemple de ceci serait, disons que vous
vouliez écrire quelque chose qui déborde de nature. Par exemple, supposons que
vous vouliez dire « hey, system dot out, dot print LN ». Et puis tu devais dire : «
Hé, c'est amusant.
C'en est un, non ? Il a donc poursuivi en disant cela. Alors laisse-moi juste réduire
cette distance ici. Je les préfère généralement
comme ça pour pouvoir savoir exactement ce que
je fais, n'est-ce pas ? Ensuite, je pourrais
simplement pub, public, static, void, main, et définir
ma chaîne ici. Ma ficelle juste là. Laisse-moi juste, j'ai besoin de quelques
carrés ou prends-les d'ici. Et amène mes carrés ici
et mets ma ficelle comme ça. Et je suis comme ça, je vais juste appeler ça un RGS. Vous pouvez toujours le mettre
devant ou derrière. Ce n'est vraiment pas grave. Définissez ce que
j'essaie d'exécuter. C'est ce que je vais dire. Fin de ma méthode. Ici. Comme vous pouvez le voir,
Java reconnaît que je peux l'exécuter, et quand je l'exécute, il devrait
simplement dire que c'en est un. C'en est une. Pourquoi est-ce que les Suédois utilisaient cela et c'est essentiellement juste, ont compris que
c'est une méthode. Quand j'appelle ça, je demande que ce
soit fait, n'est-ce pas ? Imagine que je fasse ça et que je place
ça plus ça, plus ça, plus ça, plus ça ici. Et c'est comme utiliser littéralement la même chose encore
et encore et encore. Donc à chaque fois, il va
simplement appeler à nouveau. C'en est un,
celui-là, pas celui-là. Je peux donc l'utiliser
autant de fois que je veux. Et évidemment, c'est
un exemple très Lee, mais cela aide simplement
à vous prouver qu'une méthode peut être appelée plusieurs fois sans aucun problème
, n'est-ce pas ? Ce qui est très pratique. Plus loin, nous allons dans l'ensemble de l'aspect des
méthodes et de tout ce que vous voyez. Ainsi, seules les informations
peuvent être transmises. Deux méthodes en tant que paramètres, et les paramètres agissent comme des variables
à l'intérieur de la méthode. Et les paramètres sont
spécifiés après le nom de la méthode et
entre parenthèses. Et vous pouvez ajouter autant de
paramètres que vous le souhaitez. Séparez-les simplement par une virgule. C'est vraiment l'essentiel. Et puis cet exemple que
je suis sur le point de vous montrer a une méthode qui prend une chaîne appelée I'm F9 en tant que paramètre. Par exemple, lorsque la
méthode est appelée, nous transmettons
un prénom qui est utilisé dans une méthode pour
afficher le nom complet. Alors allons-y directement
et voyons le nous-mêmes, non ? Supposons que nous
ayons public static void, puis que nous ayons une chaîne ici. On l'appelle fname,
comme je viens de le dire, nom
F
signifie littéralement prénom, non ? Alors ici, nous allons simplement dire fname. On l'appelle encore une fois. Et plus les exécutions
de référence. Quand je fais ça, je
pourrai atteindre mon vide public statique ici. Et maintenant, précisez-le encore parce que je devrais préciser ce qui se
passe, ce qui s'est passé ici. Je dois donner des
noms, par exemple, Tom, Tom là-dedans. Mais souviens-toi que Tom est une ficelle. Alors je devrais l'avoir.
Tom comme une ficelle. Et voilà, ça l'
identifie déjà comme une ficelle. Et puis ici aussi, Lindy. Lindy, oui. Ensuite, j'ai Sam. Ensuite, j'ai Rob. Et là, j'ai Lincoln. Et oui. Donc si je lance ceci et
disons que c'est un moyen, mentionner
littéralement tout
cela pour une famille. Permettez-moi de dire que c'est
une famille envoyée par
Thompson. J'ai donc Tom Thompson, Linda Thompson's,
Sam's, Thompson's, Rob Thompson's et
lécher Thomson's. Maintenant, vous êtes probablement en train de dire, hé, ce que je voulais ajouter de l'espace
entre eux, pas de problème. Vous pouvez toujours
le faire en mettant, en
mettant ceci ici. Et quand vous faites cela, il devrait y avoir un
peu d'espace entre eux. Permettez-moi de le dire comme ça. Et le tour est joué. Tom Thompson était Linda Thompson. Et parfois, il n'y a
qu'une seule famille si vous voulez une grande famille. Ça va ? Il suffit donc de garder à l'esprit que lorsqu' un paramètre est transmis
à la méthode, il est appelé argument. Donc, d'après l'exemple que
je viens de vous donner ici, fname est un paramètre, alors que ce nom est Tom Lindy, Sam Rob Lincoln, ou arguments, vous voyez que ce
ne sont que des arguments. J'ai vraiment la
même chose en mathématiques, peu importe ce qui est entre parenthèses,
nous appelons cela un argument. Et gardez à l'esprit
que vous pouvez avoir autant de paramètres que vous le souhaitez. Et disons simplement que
pour chacun d'eux, j'avais voulu préciser
aussi que hé, je voulais connaître leur âge pour pouvoir
même mettre l'âge ici. Et pour une fois que je fais ça, je dois mettre une virgule
et dire que Tom a 12 ans. Par exemple. Lind est la plus vieille. Elle a 28 ans. Sam a 20 ans. Rob est entre 25 ans. Et Lincoln c'est juste pour « oui ». Donc si je lance
ça, ça va
aussi montrer leur âge. Très bien. Cela va maintenant
aussi montrer les âges. Comme vous pouvez le voir, cela ne
montre pas encore que c'
est pourquoi ? Pourquoi est-ce que c'est ? C'est parce que je ne l'ai pas
précisé ici, Hey. Je veux aussi les agents, non ? Alors laissez-moi juste dire cet âge plus, plus et H jours. Je pourrais même dire peut-être ajouter une chaîne qui dit
quelque chose comme les données. Alors je dis que h, alors lançons-le. Ça y est. Tom
Thompson est installé. Alors c'est grand, 828 phrases font 20. Rob Thompson a 25 et Lincoln Thompson
a quatre ans. C'est ce qui fait la beauté de tout cela. Et vous devez juste garder à l'esprit que lorsque vous travaillez
avec plusieurs paramètres, la méthode coal doit avoir le même nombre d'arguments
que de paramètres. Les arguments doivent être
passés dans le même ordre. Nous pouvons donc également avoir
des valeurs de retour. Gardez donc à l'esprit que lorsque nous parlons de valeurs de
retour ici, nous utilisons le clavier void, nous l'utilisons dans, nous
l'avons utilisé dans les exemples ci-dessus. Cela indique que la méthode ne
doit pas renvoyer de valeur. Si vous souhaitez que la méthode
renvoie une valeur, vous pouvez utiliser un type de
données primitif tel qu' une fin ou une douche
au lieu de void, et utiliser le mot-clé return
dans le MathLab, Right ? Par exemple, disons que nous avons
quelque chose comme ça. Laisse-moi voir. Mettons-le dans les commentaires ici. Nous n'avons pas besoin de celui-ci. Donc au lieu de static void, je vais
simplement dire static int. Tu vois ça ? Donc quand je dis static int, cela signifie
que je suis très sûr de vouloir travailler avec int si vous
voyez ce que je veux dire. Donc je peux juste le faire
et juste dire int age. Et ce faisant, ce que je veux dire en fait, c'est
que
je veux aussi que tu me
rendes mon âge. Ça va ? Je veux que tu reviennes à l'âge adulte. On pourrait même dire que l'âge plus un certain nombre d'exemples
est plus sept. Et ça peut, ça peut
certainement fonctionner. Et je n'en aurai certainement
pas besoin pour l'instant. Laisse-moi l'enlever. Et
puis quand il s'agit de statique, supprimez cette erreur. Oui, quand il s'agit de
ce vide ici, ce que je vais faire
c'est dire « système point out », « dot print ». Et je vais
imprimer ma méthode d'âge. Et je donne ma valeur d'âge, je la donne comme cinq par exemple. Et en lui donnant cinq, cela signifie que lorsqu'il
détectera que tous les enfants de cinq ans et qu'il
dira cinq plus sept et qu'il obtiendra, tout artiste devrait
obtenir la 12e normalement, il devrait obtenir 12,
normalement. C'est beau. est donc le cas. Il en a eu 12, non ? Cet exemple renvoie définitivement la somme des méthodes, soit
deux paramètres. Vous pouvez être aussi créatif
que vous le souhaitez
en travaillant définitivement autour de cela. Et un exemple plus
élaboré de cela serait que se passerait-il si j'avais dit et pourquoi y a-t-il aussi ? Plutôt pas seulement en âge, laissez-moi l'appeler H1 et H2. Soyez plus pratique. L'âge de deux ans devrait avoir du sens. Maintenant. H1 et H2, H1 est alors trop plutôt, laissez-moi le mettre comme H12. Mais ce qui
fait vraiment deux, c'est vraiment
tout ce dont j'ai besoin. Et en faisant cela,
ce que je fais c'est que je dis que
return est un plus j2, par
exemple, ce qui
devrait être cinq plus deux, ce qui devrait être un sept. Voyons ce que nous
obtenons. On a un sept. Je pourrais même ajouter une valeur, sept plus trois, qui
devrait être dix maintenant. Alors on y va, il est dix maintenant, non ? C'est ainsi que nous sommes réellement capables d'
utiliser les deux paramètres. Oui, vous pouvez également simplement stocker
le résultat dans une variable, ce qui est bien sûr recommandé, car il est plus facile à
lire et à gérer, plus facile à lire et à maintenir. Donc juste un exemple plus élaboré de ceci
dont je parle serait, disons que vous avez
, par exemple, x ici et y ici et le plus
court et le plus, ceux que nous aimons le
plus quand on parle mathématiques ici, et il y a un x ici. Et ce que nous voulons faire,
c'est simplement spécifier quand a z ici si nous voulons et z ici nous l'
appellerons notre méthode. Et appelez le 54. Ensuite, nous imprimons simplement z. Bien, ce n'est pas seulement pour imprimer toutes ces choses qui vont
imprimer en premier lieu où tout ce que nous voulons faire est
maintenant que nous pouvons simplement imprimer z. Et laissez-moi juste fermer ceci
correctement ici aussi. Et mon père. Ouais. Cela devrait donc fonctionner
tout de suite ici. Alors voyons voir. Cela devrait être sans que ma
méthode dise simplement x0,
vraiment, c'est tout ce dont nous avons besoin. Donc nous allons simplement l'exécuter
et nous obtenons neuf, c'est-à-dire quatre plus cinq, ce qui devrait
être simplement neuf. C'est donc ça l'autre
valeur. L'autre endroit
est définitivement là. Bon ? Bon. La prochaine chose à laquelle nous avons
certainement affaire est ce que nous appelons la surcharge de
méthode Java. Ça va ? La
surcharge de la méthode Java fonctionne donc comme ceci. Avec la surcharge, vous pouvez
avoir plusieurs méthodes qui peuvent avoir le même nom avec des
paramètres différents, n'est-ce pas ? exemple de ceci serait peut-être si je disais quelque chose comme «
hé, et si j'avais une fin ? Ma méthode ? Laissez-moi plutôt l'appeler med, on est égal à, pas égal ou
plutôt juste rencontré un. Et puis je dis int x. Et oui, au lieu d'utiliser x, peut-être que je l'ai utilisé trop de
fois dans T c'est mieux. Je pense aux entités, mais je pourrais
certainement aussi avoir un flotteur et le
qualifier de fou aussi. Et je suis de couleur flottante et j'ai aussi double. Trois fous avec un double
intérieur d'appels. Un a et un double de B. Oui, certainement, cela
devrait certainement être le cas, là où nous pouvons également le faire maintenant. Ce que nous pouvons faire, c'est
avoir un exemple de cela. Par exemple,
laissez-moi m'en débarrasser
parce qu'il y a certaines choses que je veux clarifier et
améliorer avec un exemple. Alors allons-y. Disons ça. Revenons à notre méthode
statique ici. Et nous disons que c'est la fin plus. Appelons cela une méthode plus. Ensuite, avec cette méthode plus, ce que nous avons c'est que nous avons définitivement
int x
et y, et nous retournons x plus y. Et puis nous disons static, static, double, static double. Nous avons donc un
double PFAD mathématique statique avec un double ici. Et c'est avec un int ici. C'est très important. Ici, c'est doublé
ici, entre parenthèses. Je vais mettre mes deux
doubles et appeler ça un double x, double y. Et j'ai juste ce
retour x plus y. Encore une fois, non ? Et il suffit d'avoir cette statique
publique. Permettez-moi de supprimer tout
cela. Je n'en ai pas besoin. Revenez simplement en
disant Permettez-moi assurer que c'
est là que cela doit être. Ouais. Ouais. Nous pourrions donc avoir ici méthode statique
publique que nous utilisons toujours public
static, void main. Et prends ce train. Et en plus de cette
ficelle, nous aurons également
nos carrés. Alors laisse-moi juste les récupérer. Comme tu le sais, avec mon clavier. Il faut que je
les descende complètement. Comme ici. Absolument ici. leur avons donc une chaîne et un RGS. Donc là, on ouvre
ça et on l'ouvre. Qu'est-ce qu'on en dit ? Nous disons int num. Par exemple. Mon numéro un est égal
à une méthode plus. Et nous plaisons à des lieux comme
sept virgule neuf par exemple. Pourquoi pas ? Ensuite, nous passons à dire « double ». Et nous disons mon numéro deux, ce qui équivaut à la méthode
plus double. Et ici, nous allons
juste mettre quelque chose qui
est un peu une fraction, peut-être cinq points, voyons, peut-être 5,4 avec 6,9 par exemple. Ça. Ensuite, nous allons simplement dire un
système point out dot print LN. Et ce que nous voulons, c'est que nous voulons
imprimer notre lieu entier comme ça avec une chaîne qui est, et juste jouer toute notre valeur r que nous voulons imprimer ici, qui
sera plus num un. Bon ? Ensuite, nous allons faire une
chose similaire ici : système point out, point print LN. Et juste ici, nous allons avoir un double dans un format chaîne avec alarme, alarme numéro deux là-bas, non ? Alors lançons-le et
voyons ce que nous obtenons. Normalement, il devrait nous donner la
somme de ces deux valeurs. Ici. Ce sera sept
plus neuf, soit 16. Et un double ici
va nous donner, laissez-moi simplement mettre ceci
aussi pour que ce soit pertinent. Un double ici nous
donnera 5,4 plus six par neuf, ce qui ne serait que 12,3. Ça va ? C'est donc certainement
ainsi que nous pouvons utiliser la surcharge si vous le souhaitez. Très bien.
15. Portée: Très bien les gars, donc
la prochaine chose que nous voulons absolument examiner est ce que nous appelons la portée
Java, n'est-ce pas ? Voilà donc, la portée Java. Et chaque fois que nous
parlons de la portée Java, nous
parlons
essentiellement de la région accessible,
n'est-ce pas ? C'est là que se
trouvent les variables, non ? Alors laisse-moi le noter. Nous parlons de quelque chose
de la nature suivante. En Java, nous savons que les variables elles-mêmes sont
uniquement accessibles, uniquement accessibles à l'intérieur,
plutôt à l'intérieur d'une région. Ils sont créés. Permettez-moi de mettre ce côté
droit de la région. Créé est un double S sur
Matt dit avoir été créé à l'origine. Et c'est ce que
nous appelons la portée. C'est notre objectif.
Donc cette région qui les rend disponibles, c'est
essentiellement le champ d'application, non ? Les variables peuvent donc être déclarées
directement dans une méthode, et peuvent donc être disponibles
n'importe où dans la méthode suivant la ligne de code
dans laquelle elles ont été déclarées. Un exemple de cela serait littéralement ce que j'ai
écrit ici. Je vais juste jeter un coup d'œil à ce que nous faisions ici avec
notre méthode précédente. Nous avons donc une classe principale publique, puis nous avons une méthode ici. Nous l'appelons peut-être,
laissez-moi parler de celui-ci, en particulier la méthode statique double
plus double et puis nous avons cela
et puis ici nous
avons l'intérêt pour un. Concentrons-nous ici. Concentrez-vous ici. Nous avons public static,
void main, non ? Alors là-dedans, qu'est-ce qu'on a ? Nous avons mis tout ce que
vous voulez y mettre. Bon. Il est donc accessible. Tout ce que nous avons
déclaré là-bas, s'il est possible de le
demander ici, n'est-ce pas ? Et si cela n'a pas de sens, je peux toujours le faire
pour vous juste clarifier
davantage de quoi
nous parlons. Je peux voir ça comme ça. Permettez-moi d'
éclaircir tout ça. Nous n'avons
plus vraiment besoin de ça. Tout le chemin jusqu'
ici et supprimez. Allons-y
directement et disons « public ». Pas une casquette supérieure, une casquette, un vide statique public. En fait, je devrais simplement
supprimer le tout, plutôt supprimer cette
partie supérieure ici. Tout ça. Oui, c'est ce dont je n'ai pas
besoin et je n'en ai pas besoin. Mais cela, j'ai
absolument besoin de
prouver ce que je veux dire ici. Et donc,
que disons-nous ici ? Nous disons que nous pourrions avoir quelque chose comme ça ici. Le code qui peut être ici
ne peut pas utiliser x, n'est-ce pas ? C'est la zone. C'est ainsi que nous l'avons défini. Ensuite, nous pourrions
spécifier que le nombre entier de x équivaut à 100, n'est-ce pas ? Et avec cela, nous pouvons dire que nous pouvons créer quelque chose
qui peut utiliser X. code ici peut utiliser x. Et nous appelons ce
code qui peut utiliser x ou nous disons un système
point out point print LN, puis nous rappelons,
et nous imprimons x. Dans ce cas,
nous n'avions rien, nous n'avons pas été déclarés. Ce que signifie exit solve, vous voyez, nous devions
donc d'abord l'
appeler et déclarer cette variable de x et donc pouvoir ensuite l'appeler
et l'imprimer. Donc, si nous devions l'exécuter maintenant, il devrait simplement nous donner ce qu'est essentiellement x, non ? Et ce que je vais faire,
c'est juste pour m'assurer que tout va bien, laissez-moi simplement le poser ici et le mettre juste
ici. C'est beau. Alors laisse-moi juste t'expliquer ça et voir par toi-même
ce que nous en retirons. Nous sommes donc en train de l'exécuter. Et 100. C'est parce que x, nous avons
déclaré x comme étant 100. Et c'est juste une portée de méthode que nous sommes toujours en train de
faire ici, juste là dans quelque chose appelé
Block Scope. Et une portée de bloc, vous pouvez l'imaginer plus
comme ça, non ? Donc un bloc de code fait référence à tout le code entre
accolades, cette autre accolade de couleur dont
nous parlons. Donc, tout ce qui
se trouve entre ces deux accolades colorées, ceci et ça ici
n'est qu'un bloc de code, non ? Maintenant, les variables déclarées
à l'intérieur d'un bloc de code
accessible uniquement par le code
entre accolades, qui suit la ligne dans laquelle la variable a été déclarée. Pour plus de détails, prenons un exemple. Disons juste ici avec le même exemple
que nous avons ici. Imaginons que nous fassions
quelque chose comme ça. Disons que nous devions, au lieu d'avoir x juste ici, disons que nous devions faire
quelque chose comme ça ici, nous savons qu'un code ici
ne peut pas utiliser x définitivement. Mais que se passerait-il si je devais faire quelque chose du genre
suivant pour dire et mettre des
accolades, puis ouvrir le site. Donc, vous remarquez
que ce qui se trouve entre ces deux accolades
ici serait un bloc. Il s'agit d'un bloc de code. Quoi que j'y mette, ce
ne serait qu'un bloc de code. Et ce bloc de
code juste là. Il ne peut pas non plus utiliser x. Light ne peut pas non plus utiliser
x. Impossible d'utiliser x. Néanmoins, si nous
devions, par exemple, simplement spécifier et dire que
x est égal à 100. Encore une fois, peut-être rien de
spécial à propos d'un 100, juste comme l'utiliser. Nous pouvons voir que le prochain code que nous implémenterons
peut certainement prendre compte quel code d'
accès ici peut utiliser x. Et comme ça, nous pouvons simplement appeler et c'est
un point système, dot print LN X. Il n'y a pas d'erreur comme on peut le voir. Nous voyons donc
que ce bloc de code se termine ici. Laisse-moi juste faire ça. rouleau. Donc le n est égal ici. Mettez un blog et ici. Ensuite, le code ici
aussi sera en dehors
des accolades. code ici, ne peut pas utiliser x. Donc vous voyez que, Vous voyez
que l'effet qu'il est ces accolades vous
permet d'accéder à x. Mais au moment où il sort, vous ne pouvez plus accéder à aucun
x et aux données, nous avons nos 100 là-bas que nous venons de
spécifier, n'est-ce pas ? Donc, essentiellement, il s'
agit vraiment de la portée du bloc et gardez à l'esprit que le bloc de code peut exister seul ou il peut appartenir à un FYI
de fausse déclaration. Dans l'étui pour tout cas non. Pour les instructions, il suffit de garder à l'esprit que les variables déclarées dans l'instruction elle-même
sont également disponibles dans
la portée du bloc. C'est juste quelque
chose que vous devez
garder à l'esprit chaque fois que vous
programmez, n'est-ce pas ? Très bien, donc la prochaine
chose sur laquelle je veux que nous nous concentrions est ce qu'
on appelle et tout cela. Permettez-moi simplement de le supprimer. Nous n'en avons pas besoin. La prochaine chose dont nous
voulons parler est ce que nous appelons les récursions Java. Écrire une récursivité Java. Alors laisse-moi juste
le poser ici. Laisse-moi juste les faire. Oui, Java. Parfois, lorsque vous maintenez la touche Maj enfoncée pendant un moment,
c'est ce qui arrive. Récursions Java. Génial ! Qu'est-ce qu'une récursivité ? La récursivité est intrinsèquement, c'est juste la technique
permettant de faire appel à la fonction IF elle-même. Donc, si vous avez une fonction
qui continue de s'appeler elle-même, alors ce que vous venez de
faire là-bas est ce que nous appelons une récursivité, n'est-ce pas ? Alors voilà, appelle-toi. Cette technique
fournit certainement un moyen de décomposer des problèmes
complexes en problèmes
simples et plus
faciles à résoudre. Et bien sûr, cela peut être un peu difficile à comprendre, mais la meilleure façon de le
comprendre, comme toujours, juste l'encodage,
c'est de le faire. Tu dois te
salir les mains et le faire toi-même. Tu vois ça ? Voyons donc
cet exemple ici. Supposons que nous voulons utiliser, utiliser la récursivité pour ajouter tous les nombres. Jusqu'à dix. Vous voulez ajouter tous les chiffres ? Eh bien, une chose est un bon mot
anglais ici. Tous les chiffres. Jusqu'à dix, c'est ça ? Alors, comment ferais-tu ça ? Eh bien, vous
voudrez probablement commencer par simplement déclarer la méthode que
vous allez utiliser. Nous allons donc
utiliser static, void, main et call string. Ici, ARG est là. Et juste avec notre
ficelle là-bas. Ce que nous voulons faire, c'est utiliser les carrés juste ici. Alors laisse-moi juste les appeler comme ça. Et revenez ici et remettez mon clavier en
mode normal par défaut. Et puis int result définitivement dans notre
bloc de code c'est-à-dire, et nous disons somme de dix. C'est ce que nous
examinons souvent. Et bientôt, nous
allons définir ce que signifie la somme de
dix. Qu'est-ce que cela signifie ? Que devrait comprendre Java en tenant
compte de ce qu' on
appelle la somme de dix, n'est-ce pas ? Nous imprimons donc le résultat ici. Ensuite, ce que nous voulons faire, c'est, juste après l'avoir
retiré comme ça, nous voulons créer
une autre méthode ici, celle qui définira
ce que signifie quelque chose lui-même. Nous allons donc dire int sum. Ensuite, nous allons simplement appeler
la valeur entière de k.
Oui, c'est le cas. Maintenant, nous le reconnaissons. Java est donc capable d'interpréter
et de dire, oh, ok, donc la valeur de certains,
il existe une méthode qui est capable d'
appeler le soleil. Il n'a donc pas encore compris
ce que cette méthode enregistre
réellement et comment
elle devrait se comporter, n'est-ce pas ? Ça va ? Et puis nous disons simplement si k, si k est supérieur à 0, ce qui devrait se passer
est le suivant. Nous devons renvoyer k et ajouter la somme parce que nous voulons qu'elle soit
récursive k moins un. Oui, c'est là que la capacité
récursive entre en jeu. Et je vais interpréter
cela en fonction de ce que vous venez de trier, vous pouvez maintenant parfaitement comprendre ce qui
se passe exactement ici. Sinon, devrait le faire. signification de la condition
est comme n'étant pas remplie, il
suffit de renvoyer
la valeur de 0. Et c'est à peu près tout. C'est vraiment à peu près
ça. C'est à peu près ça. Laisse-moi juste faire
ça pour que je puisse toujours nous perdre ici. Ce type, je vais les
emmener, les
traîner et les mettre jusqu'ici. Juste pour que tu te souviennes de ce
type en bas, en bas. Sims, il y a une petite
erreur quelque part ici dans ce bloc
de code dont nous avons
eu affaire. Oui, il suffit de faire ça. Toutes les erreurs ont disparu. Très bien, qu'
est-ce qu'on dit ici ? Ce que nous disons
essentiellement ici, et je vais
juste ajouter quelques commentaires ici afin
que vous puissiez mieux
comprendre ce qui se passe. Nous additionnons des valeurs et au fait,
exécutons-le plus rapidement. Nous pouvons voir si cela fonctionne ou non, puis nous pouvons maintenant passer
à la prochaine étape. Nous l'avons
donc. Ça fait 55 ans. Tu peux toujours le faire toi-même. Essayez simplement de dire 0 plus un plus deux plus trois
plus quatre plus cinq plus six plus sept
plus huit plus neuf plus dix, vous obtenez 55. Maintenant, comment cela
se produit-il réellement ? Eh bien, voici ce
qui va se passer. Je vais prendre notre valeur, notre valeur de résultat ici. Et normalement à ce sujet, c'est un cours évidemment. Et ensuite, Java
va vérifier la
valeur du résultat,
la somme et dire : « Oh, la somme
est que va vérifier la
valeur du résultat,
la somme et dire : « Oh, la somme l'expulsion vaut
en fait dix. Et puis dites, que fait
cette méthode chez certains ?
16. Conditions d'arrêt: Comment fonctionne-t-elle réellement ? Donc il va juste venir ici et essayer de comprendre
ce qu'est Sam. Et il enregistrera une
valeur de dix ici, n'est-ce pas ? Parce que nous
l'avons choisi à dix
, puis disons que dix est supérieur à 0. Est-ce que c'est vrai ? Et puis tu
dis : « Oui, c'est vrai. Si c'est le cas,
retournez k, qui dans notre cas est dix. Il renverra donc
la valeur de dix. Et puis plus la
somme de k moins un. Dans notre cas, k vaut dix. Donc dix, en gros,
c'est 1010 moins un. C'est essentiellement ce qui
va se passer, non ? Et qu'est-ce que dix moins un ? C'est en fait neuf. Donc, essentiellement, nous
parlons de la somme de la
mienne, d' une partie de la mienne. Et il va prendre la
même valeur de neuf. Reprends-le jusqu'au bout. Et nous sommes toujours dans cette boucle. On ne sort pas encore. Donc ça va
monter ici et dire, neuf est supérieur à, neuf
est supérieur à x4 et
dire, oui, c'est vrai. Donc on a tendance à avoir une valeur
de neuf, tu vois ça ? Essentiellement, cela va
simplement vous donner, maintenant ce n'est plus
une somme là-bas. Ce sera juste la
valeur de neuf. Plus la somme de, ce sera neuf moins un, soit la somme de huit. Tu vois ça ? Avec la somme de huit, la même chose
va se produire. Il va passer au dessus
du huit qui est supérieur à 0, puis renvoyer
la valeur de huit. Nous avons donc maintenant la
valeur de huit elle-même. Pas une, pas une méthode de huit, mais c'est une valeur de huit elle-même. Ensuite, il y aura
une somme de sept. Ensuite, le même processus
continue de se produire. Et c'est ce qui
rend récursif. N'oubliez pas que la répression
par nature est la répétition d'une fonction qui
ne cesse de s'appeler elle-même. C'est ce que nous faisons ici. Nous faisons en sorte qu'un coupon s'
appelle encore et
encore et encore et encore. Il continuera donc de le faire. Cela signifie que nous aurons
plus sept plus six, plus cinq, plus quatre, plus trois plus deux. Je vais les espacer
plus un, non ? Et quand on en arrive à un,
qu'est-ce que ça va dire ? Il s'agit essentiellement de
dire que l'un est supérieur à
0. Est-ce que c'est vrai ? Retourne un plus la somme d'un
moins un, c'est 0, non ? Donc ça va dire plus la
somme de 0 juste ici. La somme des zéros. Ensuite, il
va prendre la somme de 0, disons la valeur de k
qui est maintenant définie comme 0. Vous allez donc dire que 0
est supérieur à 0 et nous avons réalisé
que ce n'est pas vrai. C'est faux. Et le sel, parce que c'est le cas, cette condition n'est
plus remplie, elle va maintenant sauter. Sautez cette
instruction conditionnelle et venez ici et dites que nous avons tendance à
0, ce qui est vrai. Il finira donc simplement ajouter un
0 supplémentaire. Tu vois ça ? Comme vous pouvez le voir, ils
continuent à s'additionner. Donc, ici, il suffit de dire
dix plus 919 plus huit. Trente-sept, cinquante-quatre. Et comme en
fait, ce sera 19, 27 pour 40, quarante-cinq, quarante-neuf, cinquante à 5455. Tu vois ça ?
C'est ainsi qu'il continue résumer ces
valeurs elles-mêmes. Vous allez les ajouter. Il ne les enregistrera pas. Je les enregistre
comme ça pour toi. Mais ce qu'il fera en fait, c'est qu'à chaque fois, il
continuera à faire quelque chose comme
dix plus neuf retraits continuera à faire quelque chose comme dans 19,
puis à envoyer 19 plus huit. Et puis je te donne, comme
je l'ai dit, 2 727 plus 7. Et ensuite, il vous en donnera 34. Ensuite, il
ajoutera 34 plus six, et nous lui donnerons 4040 plus cinq. Donnez-lui 45, puis il
dira 45 plus quatre, puis il lui donnera 49
puis 4949 plus trois. Et
cela lui donnera 5252 plus deux. Et on lui en donne 54.
Et il dira que cinq à quatre plus
un lui donnera 55. Tu vois ça ? C'est comme ça que ça
monte et qu'il
grandit une valeur finale de 55, n'est-ce pas ? Il suffit donc de garder à l'esprit que lorsque la fonction SUM est appelée, elle ajoute le paramètre
k à la somme de tous les nombres inférieurs à
k et renvoie le résultat. Donc, quand K devient 0, la fonction renvoie simplement 0
lorsqu'elle s'exécute dans le programme suivant les étapes que
je viens de vous montrer
juste ci-dessus, ici, non ? Donc, bien sûr, il
pourrait simplement y avoir un peu plus de créativité et peut-être même donner comme
une condition
d'arrêt, une condition d'arrêt indiquant quand
il devrait savoir quand s'arrêter, dans
quelles
circonstances le scénario ne devrait pas s'arrêter. En parlant de ça, en
parlant de la condition d'arrêt. État d'arrêt. Quand vous parlez de cela,
nous savons que tout comme boucles peuvent rencontrer un problème
de boucle infinie, fonctions
récursives peuvent
exécuter un problème de récursions
infinies si
la condition d'arrêt n'est pas taux correctement indiqué. Donc, pourquoi nous avons
besoin d'en savoir plus sur le cœur et de conditionner la condition d'arrêt
comme
j'aime le dire, je vais simplement mettre cette
force ici de cette façon et la mettre comme ça. Bon ? Génial ! Super. Ok, ça va maintenant,
donc nous l'avons parlé condition Halting et de
la récursivité
infinie ou des soucis, ou plutôt c'est quand
la fonction n'
arrête jamais de s'appeler elle-même.
Il suffit de mettre les morts. récursivité infinie se produit lorsqu' une fonction n'arrête jamais de s'appeler elle-même. Bon ? Chaque fonction récursive doit avoir la condition Halting, qui est la condition dans laquelle la fonction cesse de s'
appeler elle-même. Dans l'exemple précédent. Par exemple, la
condition de Holton est quand le paramètre k, comme nous l'avons vu, quand k est devenu 0, c'est ainsi que
Java a dû savoir que, oh, nous nous sommes arrêtés
ici, non ? Il est donc utile de
voir différents exemples pour mieux
comprendre le concept. Dans cet exemple, la fonction ajoute une plage de nombres entre
un début et une fin. Donc, la condition finale pour cette fonction de Lucas est quand n n'est pas
supérieur à stat, n'est-ce pas ? Nous allons donc prendre
un exemple ici et essayer
de voir si nous
pouvons utiliser la régression. Nous allons donc utiliser la récursivité et nous allons l'
inscrire pour nous. Nous commotion cérébrale pour ajouter tous les nombres entre 510. Donc tous les nombres compris entre 510. Nous allons donc le faire et simplement voir comment
tout cela évolue. Nous allons donc revenir
ici, ici, et simplement modifier la même
chose que celle que nous avons utilisée. Donc juste le résultat final. Et puis pour certains ici, nous
allons le rendre un peu intéressant au lieu
de simplement dire dix. Puisque nous voulons qu'il commence
à cinq heures, je vais dire 510. Ouais. Donc ça devient rouge parce que dans la mesure où la méthode de certains
avait déjà été définie, il n'y avait qu'un seul
paramètre dedans, donc on ne sait pas ce
qui se passe réellement ici. Nous allons donc le changer
quand ce permanent lui-même. Nous allons avoir un permanent de
départ de int puis de fin
de Paramount of India juste ici. Maintenant, c'est bon parce que
nous l'avons défini comme deux paramètres qui
ont été reconnus comme cinq comme début et
tendons pour la fin. Et gardez à l'esprit que je
décide juste des noms de variables pour que je sache que celle-ci commence
les autres fins. Parce qu'étudier et avoir des fonctions
particulières qui sont Java est capable de reconnaître que commencer signifie
un endosome soudain,
je les ai juste appelés ainsi. J'aurais pu les appeler X, Y, Z, comme je voulais, non ? Mais ce que je vais faire, c'est
que je vais dire si, si la fin est
plus grande que mon début, comme nous l'avions fait
dans une affaire précédente. La fin est plus grande
que mon début. Ensuite, ce que je veux faire,
c'est que je veux retourner la fin et que mes statistiques suivent. Ça va être début
et fin moins un. Il va donc
continuer à le faire encore et
encore et encore. Et puis il devrait
revenir à la fin. Maintenant, presque comme l'autre question que
nous venions de poser. Si vous y prêtez attention, vous pouvez
voir que c' est
vraiment comme ce que nous venons de faire il y a
quelques minutes. Nous allons donc continuer et
l'exécuter et
voir ce qui va en découler. Et voilà, nous l'avons. Nous avons une vallée
là-bas , je crois
que cela devrait être quoi ? Quarante-cinq. Est-ce que c'est ça ? Ouais. Je pense que c'est 45. Donc ça
te dit juste qu'un plus deux plus trois plus quatre
font simplement quoi ? Ils s'élèvent à dix parce que c'est la différence
entre les deux. Mais cinq plus six plus
sept plus huit plus neuf. Jusqu'à dix, ça te
donne vraiment quoi ? Ça te donne 45 en soi, non ? Nous avons donc des
gens incroyables que nous ne l'avons.
17. Programmation axée sur l'objet: Très bien, donc la prochaine
chose que nous voulons examiner est ce qu'on appelle. Et c'est probablement l'une des choses fondamentales que nous voulons
absolument savoir en Java. C'est du Java, de la POO, de la
programmation orientée objet, non ? Et c'est ce que représente
tout P. O P
signifie essentiellement objet. En bas pour toi. La programmation
orientée objet . C'est quelque chose avec lequel
vous allez entrer en contact de nombreuses fois. Il suffit donc de garder à l'esprit que la procédure ou la
programmation consiste à écrire des procédures ou des méthodes qui effectuent des opérations
sur les données. Alors que la
programmation orientée objet consiste à
créer des objets contenant à
la fois des données et des méthodes. Mais ouvrez le type sur cela, à la fois les données et les méthodes, non ? Donc orienté objet, il y a
un tiret nominé dessus. La programmation orientée objet présente plusieurs avantages par rapport à la programmation
procédurale, non ? Ces avantages
sont donc des avantages de 00 p par rapport à la procédure. Toute la programmation. Programmation de rôles. La première est que o p est
vraiment plus rapide dans le trou. Il est également capable d'être
fait et exécuté rapidement. Et c'est donc le
moment
précis et le vent que vous voulez faire si vous
travaillez sur des délais et tout. Et une autre chose est que
tout P dans fournit simplement une structure
claire pour les problèmes des programmes. Il existe donc une
structure claire pour les programmes. Et aussi la POO, aide à
garder le code Java sec. Et par « sec », nous voulons dire que vous n'avez pas
à vous répéter. Ne répétez pas. C'est ce qui vous motive à résoudre ce problème. Permettez-moi de le noter correctement pour que nous l'ayons. Tu n'as pas à te
répéter. Cela facilite
la maintenance et
la modification du code si vous le souhaitez. Et bien sûr, déboguez
parce qu'il y a du code. Surtout selon
beaucoup de choses, vous trouvez que les bogues finissent par
entrer dans
le code et que vous voulez avoir et que vous voulez avoir la valeur de tous les p qu'
il vous permet de déboguer facilement, sans trop de
tracas, supprimé les bogues de votre code et de
tous les p également. Il permet également de
créer des
applications réutilisables et réutilisables réutilisables avec moins de code et un temps de développement plus court. C'est ce qui fait
la beauté de tout ça. C'est ça la beauté, non ? Il suffit donc de garder à l'esprit
que le principe DRY ou le principe «
ne pas
se répéter » vise à réduire la
répétition du code. Vous devez extraire les appels courants
pour l'application, puis les placer en
un seul endroit et les
réutiliser au lieu
de les placer. Tu vois ça ?
C'est là toute la beauté de la programmation
orientée objet. Lorsque nous parlons de
OP,
nous ne pouvons pas parler de POO , nous ne pouvons pas parler de POO sans
parler d'une certaine compréhension ou d'une compréhension approfondie
des classes et des objets. Mais c'est la différence
entre ces deux et quels adultes exactement. Comprenez simplement que les
clusters eux-mêmes, essentiellement
des objets plutôt que les deux principaux aspects de la programmation orientée
objet. classes et les objets sont
deux aspects principaux de o p. Et vous pouvez considérer
une classe comme un groupe d'aliments, par
exemple des fruits. seront les objets de ce
cours ? Les objets le seront. Les différents fruits qu'il contient. Tu vois qu'on
pourrait avoir une pomme. Tu pourrais avoir une mangue, tu pourrais en avoir une paire. Tu pourrais prendre une banane. Ça peut être toutes ces choses. Vous pouvez penser qu'une classe ressemble plus à
quelque chose qui
contient d' autres
choses à l'intérieur. Ce que vous avez
entendu
ici est plutôt un amas, puis à l'intérieur de la classe, nous avons différents objets dont
nous pouvons parler. Vous voyez que tous
les membres de la même
classe, vous le voyez. Un autre exemple serait
probablement une classe de voitures. Classe de voitures. Et à l'intérieur des voitures, on peut parler de Volvo, on peut parler de virages. On pourrait parler de la façon dont Honda, oui, au bout du compte, Audi, non ? Ils sont donc tous des coûts
à la fin de la journée, mais la classe est la chose
qui les contient en ligne. Vous pouvez donc considérer la
classe comme un modèle pour les objets et un objet comme
une instance d'une classe. Ça va ? C'est le terme que vous entendrez souvent parler
d'un poids de classe. C'est donc important. Ensuite, lorsque les
objets individuels sont créés, ils héritent de toutes les variables et méthodes de la classe. Et nous y
reviendrons certainement un peu plus
tard. Mais pour l'instant, c'est à
peu près tout pour le moment. Très bien, donc la
prochaine chose que je veux que nous examinions est ce que nous appelons les
classes et objets Java. Je veux dire, nous
les avons déjà un peu commencés ici, mais nous allons juste les
approfondir un peu plus maintenant. Sachant que Java lui-même est un langage de
programmation orienté objet, tout en Java
est associé à classes et des objets ainsi qu' ses attributs et méthodes. Par exemple, dans
la vraie vie, objet Kaizen, le chi a des attributs
tels que le poids, la couleur, et des méthodes telles que Dr et
break, presque une méthode de surf ou C. Donc une classe est un constructeur d'objet ou un plan pour créer des
objets, n'est-ce pas ? Donc, pour créer une classe, nous utilisons généralement, nous utilisons quoi ? Nous utilisons le mot-clé class. Donc, un exemple de ceci serait
probablement quelque chose
comme ça. Par exemple, je pourrais dire public. C'est juste un peu terminé. Juste pour que tu
comprennes comment tu fais. Classe publique, comme vous nous avez
vus le faire à de nombreuses reprises. mai. Alors, évidemment, nous allons
avoir ces accolades ici. Personne ne peut dire que x est
égal à Phi, non ? C'est donc quelque chose que nous avons
vu tant de fois. D'habitude, il l'a déjà
fait pour vous la plupart du temps. Mais ensuite, au fur et à mesure que vous avancerez leurs scénarios, vous
voudrez peut-être le faire vous-même. Mais pour l'instant, c' est tout
ce dont vous pourriez avoir besoin. C'est bon pour l'
instant, c'est logique. Et évidemment, nous allons
avoir un jeu d'enfant ici pour le fermer. Mais juste parce que
c'est un exemple, je n'irai pas aussi loin
pour le montrer, n'est-ce pas ? Mais ensuite, pour
créer ceci comme pour créer une classe,
c'est vraiment ça. Qu'en est-il de la création d'un objet ? Et un objet ? Comment créer un objet ? Ce que nous voulons faire. En Java, nous devons
commencer par
un objet non ordonné et en Java, un objet est créé
à partir d'une classe. Nous avons déjà créé
la classe nommée main ici. C'est le nom de la
classe, ça s'appelle principal. Nous pouvons maintenant l'utiliser
pour créer des objets. Pour créer un objet de main, spécifiez le nom de la classe
suivi du nom de l'objet et utilisez le mot-clé. Nouveau. exemple serait exactement ici dans la
même classe ici, disons que nous devions
créer un objet dans disons,
public static, void, main, nous déclarons qu'il recrutera
dans cette chaîne d'objet. Et je vais juste prendre
cette partie ici même. Littéralement la même
chose que nous voulons. String. Et puis nous allons
juste dire dans principal et deux-points mon objet. Donc, en appelant une méthode
ici, nous prenons tout notre objet et nous disons nouveau, peut voir un nouveau principal et
juste là, nous
disons aussi system dot
out, dot print LN. Et puis on a tout vu
et on a fermé ça. Alors nous aurions
pu être soustraits de x si nous n'avions pas
vraiment consommé. Tu avais déjà une
valeur de x là-bas. Et nous pouvons gérer ça. Tu vois. Permettez-moi
donc copier et coller
exactement ce que nous avons fait ici. Et mettons-le juste ici. dans les commentaires, mais dans la réalité qui fonctionnera encore pour le
moment. Disons qu'il faut le fermer ici. Nous
avons déjà un cours ici, donc nous n'avons pas besoin
de le refaire. Alors voyons voir, ici
nous avons déjà créé un
vide statique public pour nous, donc nous n'avons pas besoin de le refaire. Nous pouvons littéralement
prendre la même chose ici et la
placer juste là. Et console mal cette console. Très bien. Et nous pouvons prendre ceci, mettre en haut, parce que c'est un
cours en ligne, le cours général. Et
tout est déjà en place. D'accord, alors voici
les défis que Bain pense que nous
avons notre nom de classe
Hello World, n'est-ce pas ? Depuis notre cours, à savoir, nous l'avons déjà indiqué comme Bonjour. Hello World, ce que nous
allons faire, c'est simplement l'
appeler le monde. Et quand lui
aussi, Hello World, c'est le nom par défaut
que nous avons ici. De ce dont nous parlons. C'est un petit m, mon gène obstétrique. Et ça va lire X. Ce n'est pas moins.
18. Cours et objets: Très bien, donc la prochaine chose
que nous voulons
examiner est de nous concentrer davantage sur la classe
et les objets Java, non ? Nous allons donc nous concentrer
davantage là-dessus, en particulier. Et gardez simplement à l'esprit que Java, étant un langage de
programmation orienté objet, tout ce que nous faisons en
Java est associé
à ces deux choses ici
dans la classe ou à un objet, avec son
attributs et méthodes. Par exemple, dans la vraie vie, une voiture est un objet
et le chi c'est quoi ? Il possède des attributs
tels que le poids et la couleur. Et des méthodes
telles que Dr et Break. Vous pouvez considérer les méthodes
comme des actes. Ce qu'il faut faire. Tu vois ça ? Attributs comme à quoi
vous ressemblez. Tu vois que je peux
décrire le droit ? Donc I plus est comme un constructeur d'objets ou un plan pour
créer des objets. Donc pour créer une classe, tout ce dont nous avons besoin est
simplement d'énoncer quelque chose comme ça et de dire
classe publique HelloWorld, n'est-ce pas ? Nous avons donc déjà nommé par le nom de toutes les
années de classe bonjour le monde. Habituellement, Java
le fait pour vous, mais il peut y avoir des scénarios
où
vous pourriez ne pas le faire vous-même. Mais pour l'instant c'est bon. Et puis on pourrait même dire que x est égal à cinq par exemple. Et, euh, oui, ça
pourrait certainement fonctionner. Et puis, si nous voulons peut-être créer un objet qui était le premier, c'était
comme créer une classe. Mais celui-ci, nous voulons
créer un objet. Pour créer un objet, vous devez garder à
l'esprit qu'en Java, un objet est créé
à partir d'une classe, et nous avons déjà créé la classe
HelloWorld force, comme vous pouvez clairement
Tu vois par ici, c'est ça ? Nous pouvons maintenant l'utiliser
pour créer des objets. Donc, pour créer un objet
de Hello World, nous
allons devoir spécifier le nom de la classe
suivi du nom, puis utiliser le mot-clé new. Donc, un exemple de bois, ce serait le suivant. Disons public, statique, nul. Vide statique public. Essayons et disons
simplement chaîne principale. Permets-moi de changer aussi vite que possible. Insérez ça, revenez et ERG. Et juste ici, bonjour
tout le monde. Mon objet OBJ, en fait l'
abréviation de objects, new, hello-world et voila. Ensuite, nous pourrions également
simplement dire, Hey, nous voulons les doutes de sprint
ou le système de notre LN d'impression. Ensuite, nous imprimons
mon OBJ point x point x. Donc, quel que soit l'objet
multiplié par x, n'est-ce pas ? Alors, qu'est-ce que nous trouvons ? Essentiellement, nous n'
en trouvons que cinq, non ? Nous obtenons donc la valeur
de cinq là-bas. Il peut donc y avoir un
scénario dans lequel nous voulons peut-être
créer plusieurs
objets d'une même classe. Et pour ce faire,
ce sera toujours
très, très simple. Rien de compliqué du tout. Ce que nous voulons faire
, c'
est que vous vouliez simplement
utiliser say hello world, puis nous spécifions
et disons mon OBJ. Disons que le premier
était religieux comme un ou juste le début une fois ou spécifié en deux
et disons simplement nouveau. Ensuite, nous disons bonjour à tout le monde. Et gardez à l'esprit
que nous avons ici numéro
d'objet pour,
objectez à cela. Nous avons ici l'objet 1. Objet un, c'est ça ? Alors ce que nous voulons faire et peut-être
que nous pourrions vraiment les imprimer
tous les deux, pourquoi pas ? Vous pouvez choisir
le même système. Dot out, dot, print. Et puis mon OBJ, le premier. Le second
parce que nous
avons déjà le premier ou avec un. Et puis nous disons simplement par x, et normalement nous devrions les faire sortir tous les
deux. Cela fait 55 ans. C'est donc ça la beauté
de tout ça. C'est ce qui est beau
ici. Essentiellement, nous
lui demandons d'
imprimer tout ce qu'il
trouve dans cette classe, en particulier le périmètre de X, comme nous
l'avons indiqué juste là. Il peut y avoir des scénarios
où vous en auriez besoin. Donc oui, j'espère que cela
vous aidera
certainement à vous en sortir. La prochaine chose que nous
voulons examiner est ce que l'
on appelle les attributs de classe de Java. Bon ? Les voici. Dans les attributs de classe Java, attributs, ce qu'ils font. Et puis en anglais,
c'est juste quelque chose qui définit les caractéristiques
de quelque chose, non ? Dans le scénario précédent ou
moins que nous
parlions de classes et d'objets. Et même plus tôt, nous avons défini ce que signifie invariable. Une variable est donc
en fait un attribut d' une classe qui
vaut vraiment la peine d'être noté. La variable est un
attribut de la classe. Et donc pour donner un exemple, disons que nous avons une classe
appelée remove all of this. Nous avons un cours
ici, qui s'appelle Hello World par exemple. Par conséquent, dans cet esprit,
créons des attributs. Ce sera donc x. Et x est proche de cinq,
comme nous l'avions fait auparavant. Nous pourrions même en créer un
autre dans y est égal à
sept, par exemple. Donc ces deux choses, x et y, nos deux attributs, c'est ce
que
nous avons vu jusqu'à présent qu'
il existe des variables. Vous comprenez maintenant
qu'il ne s'agit pas simplement de variables, mais également d'attributs. C'est ce qu'ils sont,
c'est ce que, et. champs sont donc un autre terme pour désigner
les attributs de classe. Ainsi, au lieu de
les appeler attributs, vous pouvez toujours simplement
les appeler champs également. Pour accéder à
ces attributs, vous pouvez y accéder en
créant un objet de la classe et en
utilisant la syntaxe des points. Cet exemple que je vais
vous montrer
maintenant va vous aider à
créer un objet de notre classe avec le nom my OBJ tel que je
les utilise, all my object. Et nous utilisons l'hommage
et l'objet exacts pour imprimer sa valeur. Donc juste pour
vous aider à mieux comprendre de quoi je parle
exactement, Appelons simplement public
static, void, main, string. Il suffit d'avoir ce RGS et
de desserrer ce mémo. Et oui, prenons cours HelloWorld
et Colon, notre OBJ. N'oubliez pas que ce n'est pas
nécessairement tout. Tu peux toujours
l'appeler autrement. Nous appelons donc une nouvelle classe maintenant. Ensuite, il suffit de
l'imprimer. Vous l'imprimez. Et voyons ce que nous
retirons de ce beau, ce beau, de ce beau. C'est ainsi que nous
accédons définitivement à ces attributs. Ensuite, nous pouvons également modifier
les attributs que nous avons déjà définis. Un exemple serait, parlons de
celui que j'ai fait ici. Disons que j'appelle x,
juste x dans les
minutes qui suivent au lieu de cinq, je dis simplement x et x. Je pourrais le modifier ici
et simplement dire mon objet ici, et juste comme ça. Mais mon objet de x
équivaut à cinq. Laisse-moi juste le poser. Cela équivaut donc
à cinq jours. Ensuite, je lance mon objet de x. Et j'en ai cinq. Si je change cela en 124, je devrais avoir 124
parce que je l'ai modifié. Vous voyez, au départ
c'était juste x. Et je l'ai modifié
juste là. Très bien, si c'était, par
exemple, l'automne, nous sommes là. Laissons-le
simplement et essayons de comprendre. Ça doit toujours être un 124. C'est parce que la valeur
initiale qu'il obtient est vraiment celle que nous recherchons. Mais ensuite, il arrive à ce
stade et dit que toute la nouvelle valeur de x
que je devrais entrer devrait être un 124. Parce qu'il
prend toujours en charge Java, prend
toujours les dernières
informations qui lui sont données. C'est celui qui écrase les informations
existantes. C'est, c'est, c'est vraiment
ce que vous pouvez dire à ce sujet. Je peux donc simplement mettre
le commentaire CN et dire que x est maintenant 124. C'est ce que c'est, non ? Donc, si vous ne voulez pas avoir la possibilité de remplacer des valeurs
existantes, déclarez, vous pouvez toujours
déclarer l'attribut comme dernier exemple ici. Vous pourriez dire que si vous ne
voulez pas qu'il change à un moment donné, vous pouvez dire un x final. Comme vous pouvez le voir maintenant, c'est une
erreur pour moi de changer cela. Je n'ai pas le droit de
le changer en quoi que ce soit. C'est alors pour lui-même, c'est parce que ça ne me permet
pas de prendre de valeur. Pas du tout, ni de
nouveaux intrants du tout. Je vois. Je dois m'en débarrasser
et c' est là que
tout ira bien. Et si je devais imprimer ça, je devrais avoir la valeur
de rien que pour moi. Donc des bêtas que nous n'avons pas. Un autre scénario avec lequel vous
pourriez vous
retrouver est de
travailler avec plusieurs objets. Et ce qui est difficile si vous voulez créer plusieurs
objets dans une classe, vous pouvez modifier les
valeurs d'attribut d'un objet sans affecter les valeurs d'
attribut de l'autre. Par exemple, si vous voulez modifier
la valeur de 25 supplémentaires et l'objet numéro deux et laisser x dans l'objet numéro
un et le modifier. Vous pourriez faire quelque chose
de la nature suivante. Disons qu'ils ont ça. Nous n'avons pas besoin du
dernier ici pour le moment. Nous avons deux objets, alors laissez-moi créer
mon deuxième objet. Le deuxième objet étant le nouveau
monde bonjour et les données. Et puis mon, mon second objet peut être spécifié de
la manière suivante. Mon point OBJ x, il est 24, ce qui signifie qu'en ce qui concerne la valeur
nominale, il
s'imprimera simplement pour le deuxième objet,
il imprimera 24. Je vais donc les
imprimer tous les deux juste pour
que nous puissions mieux voir. Copiez et collez et imprimez
les deux afin de voir la différence
entre les deux. Le premier devrait donc être pour le deuxième intervalle.
C'est donc le cas. Seule la première a été modifiée. Le second, depuis
qu'il a été modifié. Cela a changé. Vous voyez que le
premier reste le même, le second change. C'est ce qui se passe
si vous voulez simplement avoir plusieurs objets en fonctionnement. Vous pouvez également avoir plusieurs
attributs en fonctionnement. Vous pouvez donc spécifier autant d'
attributs que vous le souhaitez. Et pour cela, cela
impliquerait que vous fassiez quelque chose qui
déborde de la nature. Disons que je dois
supprimer tout ça. Et nous ne
parlons pas de me laisser déplacer ça
aussi parce que je n'en ai pas besoin. Alors disons que je dirais string FirstName
F9, donné par Tom. Ensuite, j'ai besoin de syntaxer
aussi, de souche. C'est mon nom de famille ici. Sheppard du
jeu Mass Effect. est donc le cas. Ensuite, nous parlons de l'âge, et disons qu'il a 26 ans. Ce que nous allons faire,
c'est que nous n'en avons plus besoin. Oui, vraiment, ce n'est
pas important. Donc j'ai pu créer
mon propre objet, non ? Comme vous l'avez probablement
vu trop de fois. Maintenant, ce que je vais faire
c'est ça. Ce que je vais faire, c'est juste ici, je vais juste vouloir qu'on imprime quelque chose d'intéressant. Nous allons
juste dire un nom, un nom. Et puis avec le nom. Nous allons aussi entrer juste un deux-points ou un nom de
point d'objet F, n'est-ce pas ? Et puis nous allons aussi
appeler, d'
accord, je laisse un peu d'espace entre eux, pas
vraiment de clavicule. Ensuite, prenez notre deuxième objet, qui est notre nom de famille. L pour L name et puis
j'ai lu delete that. Et ici aussi. Ce que je vais faire, c'est
simplement demander
l' âge ici pour que
nous ayons l'âge. Et nous appelons cet objet et ce
téléphone à l'âge ici même. Et lançons-le et
voyons ce que nous obtenons. Quand on l'exécutera. Ça y est. Nous avons nommé Tom
Shepherd, 260 ans. C'est donc certainement très
précieux, très précieux, surtout lorsque vous traitez des piles de code et
tellement d'informations que vous devez traiter et juste besoin de tout
avoir . dans l'ensemble,
tout à fait. Voici quelques
informations précieuses que vous devez absolument garder
à l'esprit. Je veux vraiment garder à l'esprit. Très bien, donc la prochaine chose dont nous allons certainement
parler est simplement appelée méthodes de
classe Java, n'est-ce pas ? Ainsi, vous avez appris du
chapitre sur les méthodes Java ou autre, la leçon dont
nous parlons, que les méthodes sont
déclarées dans une classe, qu'elles sont utilisées pour
effectuer certaines actions. Donc, pour
créer une méthode, afin de
créer une méthode, vous savez que vous voulez absolument
avoir ce qui suit. Vous voulez effectuer les actions
suivantes, n'est-ce pas ? Supposons que
je veuille créer une méthode, appelez ma méthode. Oui, je vais juste
dire que c'est ma méthode. Donc, ce que je peux faire, c'est que je peux
juste dire statique, vide, avancer
mes calculs, ouvrir ça et l'ouvrir comme ça. C'est une méthode. Ouais. Alors écris comme ça. Eh bien, je n'ai plus besoin de
ce type. Vraiment. Tu vois, laisse-moi juste traîner
ce type jusqu'en haut juste pour qu'on se souvienne
toujours que tout est juste là. Nous avons donc créé une ancienne méthode, vraiment vu qu'un système
qui sort LN d'impression par points. Ensuite, on pourrait dire : « Hé, tout le monde, c'est ce que vous voulez. Et voyons voir. D'accord, bien sûr, il y a
une petite erreur ici. Méthode principale introuvable dans la classe
HelloWorld, cela arrive, veuillez définir la
méthode principale public, statique, void, main
method, droite ? Donc en gros, oui, ça te
dit qu'il y a
définitivement un problème ici. Donc ce que nous allons faire, c'est
juste dire public, statique, vide, principal. Et nous faisons appel à ce
train pour simplement changer notre façon de faire ici et
créer ces quotas et le SDRA. Et ici même, nous
invoquons notre méthode, la mienne. Maintenant, lançons-le et voyons
ce qui se passe quand nous l'exécutons. Belle, c'est
MyMethod, MyMethod, non ? L'erreur a donc été
corrigée et c'est certainement ainsi que nous
traitons le méthyle. Ainsi, chaque fois que vous appelez une
méthode de recrutement de méthodes, vous voulez les mettre dans
leur vide statique public
, puis l'exécuter dans n'importe quelle
méthode. Cela montrera qu'il
fonctionnera certainement à votre guise. Cela soulève la question de savoir
si tout cela se trouve ici même. Le public
signifie évidemment qu'il est accessible à tous, euh, peut être modifié et changé de
manière rigide nécessairement. Mais la statique elle-même
est un peu intéressante. Que signifie statique ? Eh bien, statique pour aborder le sujet de quelque chose qui est statique ou
ne l'est pas, nous devons vraiment comprendre
ce qui se passe, n'est-ce pas ? Donc statique ou non statique, c'est ce sur quoi nous nous
concentrons maintenant.
19. Statique Vs non statique: Très bien, nous passons à la
nature statique et non statique de nos programmes Java. Et vous voyez souvent que
dans les programmes Java, nous pouvons avoir notre géographie. Les programmes Java sont statiques ou publics dans leurs attributs
et méthodes, n'est-ce pas ? Donc, dans l'exemple précédent
que nous avons fait ici, nous avons créé une
méthode statique, n'est-ce pas ? Comme vous pouvez le voir, il existe
une méthode statique. Cela signifiait qu'on ne pouvait y accéder que sans créer
d'objet de la classe, contrairement au public,
qui ne peut être accessible que par des objets, n'est-ce pas ? Jetons donc un coup d'œil à l'exemple suivant juste pour
démontrer les différences
entre les méthodes statiques et les méthodes
publiques, n'est-ce pas ? Permettez-moi donc de
supprimer tout cela. Nous n'en avons plus besoin. Au moins cette partie de l'histoire va jusqu'à notre classe publique
là-bas, non ? Donc juste après le cours public, nous allons juste le
nommer et le mettre
en commentaire et rester
statique. Et notre méthode statique sera
le type suivant qui dira static void et l'
appellera ma méthode statique. Ça va être bien
mieux comme ça. a une petite faute de frappe là-bas. Ensuite, nous veillons simplement à ce
que cela soit entre parenthèses. Et on l'ouvre comme ça. Ensuite, nous dirons Juste le système
point out, point print LN. Et tout
ce que nous avons à prouver ici, c'est
juste de dire
que des méthodes statiques
peuvent être appelées, peuvent être appelées sans
créer d'objets. Sans créer d'objets. Juste comme ça, non ? Et puis, d'un autre côté, ce que nous allons faire
aussi , c'est que nous allons également montrer une différence
ici avec une méthode publique. Je vais le mettre comme un commentaire. Et avec notre
méthode publique, je dirai simplement public void, ma méthode publique. Et
ouvrez ça comme ça. Et nous disons simplement « système
éteint », « point print LN ». Et puis nous venons de mentionner que les méthodes
publiques doivent être appelées en créant des objets. Nous avons donc besoin d'objets
avec des méthodes publiques. C'est essentiellement la différence
entre les deux, non ? C'est essentiellement la
différence entre les deux. Alors ce que je vais faire c'est que je vais
juste appeler ça
ma méthode principale si
tu veux, non ? C'est ma méthode principale. Le principal, c'est ça ? Donc je vais juste dire quelque chose
comme public, statique, vide. Je veux dire, comme on dit toujours. Et puis un droit
dans notre truc ici, on va juste
appeler une chaîne. Et comme vous le savez, j'ai besoin de l'amener
là-bas parce que je n'ai pas intrinsèquement cet
ERG S là-bas. Et viens juste ici. Et on appelle ça juste ma méthode
statique, non ? Et essentiellement en faisant
cela, que faisons-nous ? Nous appelons la méthode statique. C'est ce qui se
passe réellement ici. Voici donc avec la méthode statique caudale
. Ensuite, si nous devions
peut-être appeler notre méthode publique, voyons ce qui se passerait. Méthode publique. Il y a donc une
méthode publique là-bas. Il y a une petite
erreur là-bas. Pourquoi est-ce que c'est ? Il y a une flèche là-bas ? Parce que la façon dont nous devons appeler une méthode publique
est que nous devons appeler. Nous devons d'
abord créer un objet pour pouvoir y accéder. Vous le voyez pour accéder
aux méthodes publiques. Il s'agit donc clairement
d'une erreur. Appelons-le, disons simplement, compilons une flèche. Ces compilations et erreurs, qui
signifie qu'avec cela, ce que nous rencontrons est une erreur. Mais
appelons-le en classe principale, qui s'appelle HelloWorld. Et dites simplement mon objet. Ensuite, nous disons « nouveau
bonjour au monde » et nous fermons ça. Ensuite, on l'appelle encore
mon objet. Et puis avec cette fois, nous avons juste dit « dot my public method ». C'est déjà, on pourrait
dire stupide, faux, non ? Ça. Et comme vous pouvez le constater,
il n'y a pas d'erreur. Et essentiellement, ce que nous
faisons ici, c'est que nous
créons un objet de An object of Hello World,
That's a main class, n'est-ce pas ? Et ici,
essentiellement, ce que nous
faisons est d'appeler
la méthode public sur
l'objet que la méthode public sur
l' nous venons de créer. Donc, si nous devions lancer cela, voyons ce que
nous obtenons essentiellement. Normalement, comme vous pouvez le constater,
il n'y a aucune erreur. Ensuite, nous devrions avoir le premier montrant que les méthodes
statiques peuvent être appelées sans
créer d'objets. Voila. Ensuite, nous avons également des méthodes publiques qui
doivent être appelées en
créant des objets. Comme nous pouvons le voir, nous avons dû créer un objet pour rouler le jour, non ? Donc c'est essentiellement la différence entre
les deux, n'est-ce pas ? Et juste pour plus de
détails, nous pourrions même parler de la façon dont nous
accédons aux méthodes au sein
d'un objet, n'est-ce pas ? Supposons que vous deviez créer, laissez-moi simplement mettre les méthodes
d'accès downforce avec un objet. Utilisons-le pour créer une voiture. Un objet de voiture nommé ma voiture. Vous pouvez simplement appeler sur MF beaucoup de gaz à plein
régime et sur la
vitesse directement sur ma voiture. Object, puis lancez
simplement le programme. Et si cela n'a pas de sens, choisissons-en
un exemple. Permettez-moi donc de
supprimer tout cela. Nous n'avons pas besoin de
tout ça pour l'instant. Cela
pourrait probablement dire que cela m'a toujours fait revenir dans
mon deuxième clavier. Mais pour l'instant, faisons-le. Créons simplement le plein régime. Créez une faute
de frappe à plein régime où il y a nourriture lancée avec un
grand T là-bas. Et nous sommes en train de créer une méthode
d'accélération complète ici, non ? donc essentiellement ça. Donc nous allons simplement dire public, vide, foo, accélérateur. Et nous avons ceci, fermez-le comme ça. Ensuite, dans cette méthode, tout ce que fait cette méthode
est qu'elle
imprime le point système, impression par
points LN, elle imprime
l'instruction suivante. La voiture va
aussi vite que possible. Oui, parce que tu vas
aussi vite que possible. Très bien. Ensuite, nous voulons
également
créer une méthode de vitesse. Ça va ? Et ajoutez un paramètre. Nous allons donc simplement l'appeler vitesse
du vide public. Le premier
vide le plus public, à plein régime. Celui-ci utilise la vitesse du public void. Et puis juste dans ce bit ici, qui va
mettre notre paramètre et l'appeler vitesse maximale. C'est le nom de
notre valeur entière qui devrait s'y trouver. Il doit représenter
la vitesse maximale. Donc nous allons simplement dire
système éteint, print LN. Et juste là, nous
appellerons la vitesse maximale. Et la vitesse maximale est, et juste à l'extérieur, il y
aura une vitesse maximale. C'est la valeur entière
que nous voulons, n'est-ce pas ? Ensuite, la prochaine chose que nous voulons
faire, c'est juste, euh, c'est à l'intérieur, bien sûr,
des majuscules inférieures. Dans Hello World. Ce que nous voulons faire c'est appeler les méthodes de mon objet voiture, non ? Nous avons donc dit
public, statique, nul maintenant. Et puis nous avons toutes les ficelles ici avec un RGS ici et
là nous l'avons. Et nous allons simplement appeler Hello World. Bonjour tout le monde, et
dites simplement ma voiture par exemple. Et puis nous disons nouveau
et bonjour tout le monde. Donc, comme vous le savez, nous sommes simplement en train de créer
mon objet voiture. C'est ce qui se passe.
L'objet existe donc. Maintenant, si nous voulions
rendre cela public, nous pourrions certainement
utiliser l'objet. Il suffit donc de lier cela à
notre méthode d'accélération. Donc, essentiellement, ce nous faisons, c'est
que nous appelons la méthode full throttle. Ensuite, nous disons simplement à nouveau, ma voiture, puis nous
allouons notre vitesse à peut-être 25. Donc, en faisant de l'observation, nous
appelons le PFAD des mathématiques de vitesse. C'est ce qui se passe ici. Bon ? Alors. Tu veux juste t'assurer qu'
il n'y a pas de place ici. Il devrait simplement être
public static void. Il devrait y avoir une entrée principale
que j'ai oubliée. Principal. Oui, c'est bien. Et nous lançons ceci et devrions nous dire
que la voiture va aussi vite que possible ,
puis nous indiquer la vitesse
maximale également. est donc là. La voiture va
aussi vite que possible. Et le max b est de 25, c'est ça ? Donc, juste pour expliquer ce
qui se passe ici. Tout d'abord, nous avons créé un hello de classe mondiale
personnalisé. C'est ce qui se passe
avec le mot clé class. Ensuite, nous avons créé la méthode full throttle ici. Pas seulement cette accélération complète, mais aussi la méthode de la vitesse. Sauf dans la méthode speed, nous avions un paramètre
qui est un entier,
est un entier, quel
que soit ce qui se trouve à l'intérieur de
celui-ci en tant que paramètre. Mais notre entier ici
ou au niveau de notre paramètre est un entier appelé
paramètre de vitesse maximale. Ensuite, nous avons simplement dit
pour que nous utilisions notre moyenne, notre classe Hello,
HelloWorld. Et c'est ma faute. Nous
devons créer un objet de la classe Hello World, c'est exactement ce que nous avons fait. Nous avons créé un
objet ici, non ? Ensuite, nous avons
dit
que nous avions créé un objet en utilisant
évidemment le nouveau
mot-clé là-bas. Ensuite, nous appelons
les méthodes Full Throttle et Speed sur l'
objet mica et lançons le programme. Et nommez l'objet
suivi du point, suivi du
nom de la méthode qui nous intéresse. Et il est juste intéressant de
noter que nous pouvons ajouter un paramètre int de même si 200 dans la méthode
speed, à droite.
20. Constructeurs: Alors rappelez-vous, quelque chose qui
vaut la peine d'être noté est juste cela. N'oubliez pas que le point est utilisé pour accéder aux objets, objets, aux attributs
et aux méthodes. Donc, cela vaut la peine de le
noter parce
que cela s'
avère très utile au fur et à mesure que vous progressez, en
particulier
dans tout l'aspect de ce que nous faisons
encore en ce moment, n'est-ce pas ? Génial ! La prochaine chose
que je veux que nous examinions est ce que l'on appelle les constructeurs. Constructeurs. Et c'est quelque chose qui vous
sera très utile au fur et
à mesure que vous avancerez de
plus en plus. Donc, gardez simplement à l'esprit qu'
un constructeur lui-même. Constructor est une méthode spéciale, une méthode spéciale qui est utilisée pour initialiser des objets
aussi simples que cela. Alto. Donc, simplement, nous appelons le constructeur lorsqu'
un objet d'une classe est créé et il peut
être utilisé pour définir les valeurs
initiales des attributs
d'objet. Ça va ? Donc, un exemple de ceci serait
probablement quelque chose comme, montons ici et voyons si je peux vous en donner
un exemple. ce moment, nous
parlons d'un constructeur. Supposons que nous
ayons quelque chose comme int x qui est exactement comme ça. Essentiellement, nous créons
un attribut de classe. Assurez-vous simplement qu'il s'agit d'un commentaire créé dans l'arbre de classe Butte. Nous avons créé un
attribut de classe là-bas. Ensuite, nous
créons un constructeur de classe. Maintenant, l'objectif principal de ce que
nous faisons en ce moment. Pour notre classe, qui est
la classe HelloWorld. Génial ! Nous disons simplement « public ». Et puis nous disons bonjour à tout le monde. Ensuite, nous allons simplement faire ceci
et fermer cette lumière. Et oui, assurons-nous que c'est plutôt
ouvert comme ça. Et ici, nous nommons simplement notre attribut et
lui donnons un sept, par exemple. En lui donnant un sept, ce que nous faisons ensuite est que nous avons
simplement notre méthode commune, public void, main, string ou NGS. Et nous créons un objet qui sera
essentiellement Bonjour tout le monde. Et envoyez simplement mon OBJ. Ensuite, nous disons « nouveau bonjour tout
le monde » et nous fermons ça. Cela signifie qu'avons-nous fait ? Nous avons créé un
objet de notre classe, qui sera utilisé pour appeler
un constructeur, n'est-ce pas ? Nous avons donc créé
un objet qui appellera la structure. L'objet
de notre cluster BU appelle-t-il définitivement un constructeur ? Donc ici, ce que je vais faire, c'est que je vais
juste définir mon, puis nous avons x sur le, essentiellement nous imprimons la valeur, la valeur de x. Donc voyons si nous pouvons
obtenir un sept là-bas . C'est parfait. Nous avons nos sept. Il est donc intéressant de noter que le nom du constructeur doit
correspondre au nom de la classe et qu'il ne peut pas avoir un type de retour comme
int void par exemple. Notez également que le
constructeur est appelé lorsque l'objet est créé et toutes les classes ont
été construites par défaut. Et si vous ne créez pas de constructeur de
classe vous-même, Java en crée un pour vous. Cependant, vous
ne pouvez pas définir de valeurs
initiales pour les
attributs d'objets, n'est-ce pas ? Donc, une autre chose qui
vaut la peine d' examinée est ce que l'on appelle
le constructeur. Paramètre constructeur. Donc, un paramètre constructeur. Les paramètres du constructeur,
essentiellement ils le peuvent, les constructeurs eux-mêmes peuvent prendre paramètres qui utilisaient des attributs de
mensonge. accord, voici
un exemple que nous
pouvons certainement utiliser
comme application de ce dont nous
parlons ici. Consolons simplement tout ce que nous avons fait jusqu'ici. Plutôt jusqu'à ce qu'
au moins quelques énigmes, nous disons que x est égal à y. Et puis nous
n'avons pas encore défini y. Mais ce que nous allons plutôt
faire c'est de le
définir juste là
et de l'appeler int y. Et puis ici aussi. Ce que nous allons faire, c'est
juste dire « objet ». Et puis ici, nous allons mettre un nombre
correspondant à la valeur de y, parce que c'est ainsi que
nous avons mentionné que hello world a un paramètre. C'est un entier de y. Et chaque fois que je vois Hello World, je dois m'assurer
que je l'ai sous forme d'entier y chaque fois que
je le vois en tant que classe. Donc, ce que je vais faire, c'est
juste dire ma fin. Et puis x et je l'exécute
normalement devrait être huit, parce que x est égal à y. Donc il y en a,
juste huit, non ? Il suffit de manger et vous pouvez avoir
autant de paramètres que vous le souhaitez. Par exemple, ici, il peut s'
agir d'un entier appelé year. Par exemple, juste
un exemple. Et dans lequel, par
exemple, il faudrait
définitivement modifier cela. Disons que c'était
comme un modèle, oui, en termes de coûts, peut-être. Ce serait donc comme
votre modèle ici. Et puis en dessous, vous voudrez
probablement regarder
dans la chaîne. Je n'ai pas besoin de ce
commentaire pour l'instant. Et puis ayez une chaîne
qui nous dirait quel est le nom de
ce modèle de voiture. Et puis parce que
nous les avons comme
ça , cela suggérera qu'un
entier ici
serait le flux d'air
appelant simplement le nom. Ouais. Alors essentiellement
ce que nous allons faire, c'est que nous
allons juste leur donner nom du
modèle
serait essentiellement juste équivalent à quelqu'un qui lui
a demandé le nom. Et puis le modèle serait l'équivalent de moi. Dites simplement ce qui est « oui ». Associé à la voiture dont
nous parlons. Et puis je vais juste dire ici, principal, voici le
Hello World. Ici. Nous allons certainement
lui donner le nom First. Disons que c'est un exemple Ford. Ensuite, sur ce
gué, nous allons
commencer par l'année en premier. Donc ça va être en 1967. Et nous avons mis le nom
serait combattu, par
exemple, 1967 conseil d'administration. Et il s'agit simplement de s'assurer que
nous avons bien imprimé maintenant. Alors, comment allons-nous l'imprimer ? Eh bien, ce n'est plus
juste un objet, donc je vais juste
l'appeler ma voiture ici. C'est ce que j'appelle mon point de voiture. Ensuite, il suffit de choisir ce que nous voulons
exactement. Nous l'avons donc de la manière
suivante. Ensuite, nous appelons non seulement l'année, mais aussi
le nom modal. Donc ça devrait dire 1967, Ford aussi. C'est donc le cas. 1967. Ford fait le rendement
que nous obtenons, non ? Donc, essentiellement, c'est
à peu près tout quand il s'agit de construire ceci. C'est ce qui dérange
quand il s'agit constructeurs en action, non ?
21. Modificateurs: Très bien les gars, donc
la prochaine chose que je veux absolument que
nous examinions est ce qu'on appelle
les modificateurs, non ? Permettez-moi simplement de mettre cela ici
parce qu'il y a quelques commentaires qui vont
avoir lieu ici. Donc nous les appelons Phi is, c'est ça. Et ils ont pensé aux modificateurs, quelque chose que nous utilisons
déjà. Gardez à l'esprit que, par exemple, chaque fois que nous disons
classe publique HelloWorld, public est un modificateur, n'est-ce pas ? Nous avons donc des types ou d'autres
groupes de modificateurs. Les modificateurs peuvent être nommés en termes de modificateurs d'accès ou plutôt regroupés en termes de modificateurs d'accès, ce qui est un exemple
de notre public. Nous pouvons avoir des
modificateurs d'accès ou aucun modificateur d'accès. Ça va ? Que sont donc les modificateurs d'accès ? modificateurs d'accès eux-mêmes sont intrinsèquement ceux qui contrôlent accès, comme leur nom l'indique, vraiment accès à n'importe quel
code que vous avez, n'est-ce pas ? Et puis celui-ci n'est pas le cas. Ils ne contrôlent pas l'accès. Mais ils fournissent des prestations. Autres fonctionnalités. Oui, génial. Ce sont donc les modificateurs de
non-accès. Public, par exemple, public, comme nous en avons parlé, public est un exemple
de modificateur d'accès. C'est. Et juste avec ça
que je suis sur le point
de
vous montrer parce que c'est un petit commentaire qui
va certainement faire ici, juste pour que vous puissiez bien comprendre exactement
ce que nous faisons ici. Je vais donner un exemple en
commençant par le public. Donc, ce que public est essentiellement, c'est que le public est autorisé ou plutôt ce que
cela signifie, c'est que nous
parlons d'une classe qui est accessible par d'autres classes. C'est un cours accessible par un autre verre si vous le souhaitez. Ensuite, nous pourrions également parler d'un modificateur appelé modificateur
par défaut. Tous ces
modificateurs d'accès, d'ailleurs, devraient probablement simplement
leur indiquer clairement qu'il s' agit de modificateurs d'accès. Nous avons également default
et default. Cela signifie que
la classe n'est
accessible que par
les classes du même package. Classe. cours simples au revoir
dans le même package. Maintenant, si vous vous demandez
quels sont les
mêmes paquets dont nous pourrions
parler par exemple, c'est d'un package dont
nous parlons. Nous pouvons donc avoir
plusieurs packages , mais c'est vraiment un conteneur
contenant des classes. Tu peux le voir
plus comme ça. Et nous l'utilisons lorsque nous
ne spécifions pas de modificateur. Cela signifie donc que c'est utilisé. Java l'utilise automatiquement. Ceci est utilisé lorsque vous ne spécifiez pas par modificateur, c'est le modificateur par défaut. Si tu le voulais, je pourrais
certainement le dire. Ouais. Très bien, puis
quatre attributs, méthodes et constructeurs
que vous pouvez utiliser. Tout cela pourrait vraiment être
utile, pas seulement public. Et comme nous le savons, P
doit être petit t. Et puis quatre attributs, attributs ,
méthodes et constructeurs. Nous pourrions avoir ce qui suit. Nous pouvons toujours utiliser public. Ici. Cela signifie
que notre code est accessible pour tous les clusters. Alors si c'est privé. Si c'est privé, c'
est différent. C'est seulement le code qui est
accessible. Nous avons ensuite déclaré cours,
donc c'est privé. Et puis si c'est par défaut, cela signifie que nous
en parlons. Même colis. Le soja est toujours la même chose que nous avons déjà
mentionné ici. Donc je vais juste le faire pour référer ou les autotrophes montrent
que c'est la même chose, mais plutôt ici juste
pour le
même code de package accessible sur la
même base de package. Ensuite, nous aurions également
pu nous protéger. Et lorsqu'un code ou quelque chose que vous souhaitez modifier est protégé, cela signifie que le code est accessible dans le
même package. Et des sous-classes. Cela va voir beaucoup plus loin
et nous aide beaucoup, surtout lorsque nous commençons à
parler d'héritage, superclasses et de sous-classes, il est très utile
que vous le sachiez. Ouais. Bon. La prochaine chose que je veux que
nous examinions est ce que nous appelons les modificateurs de non-accès. Ouais. Avec un modificateur
de non-accès laissez-moi simplement
les mettre en place pour nous. Nous parlons de modificateurs d'accès
Nan. Et avec les
modificateurs de non-accès, non ? En fait, vous pouvez
utiliser final ou abstrait. C'est le, c'est le k
est au moins quatre classes. Les cours. Vous ne pouvez utiliser que Final
it all up struct. Et si nous parlons de
quelque chose qui est final, ce que nous disons c'est
que la classe ne peut pas, la classe ne peut pas être héritée, peut pas être héritée
par le processus. Encore une fois, cela est
très pratique, ou plutôt vous le comprenez mieux
car nous faisons de l'héritage,
ce que nous n'avons pas encore fait. C'est juste moi.
Construire jusqu'à ça. Je suis ici avec des
moyens abstraits que la classe ne peut pas être utilisée pour créer des objets. Donc, pour que vous puissiez
accéder à une classe abstraite, elle doit être héritée
d'une autre classe. Ça va ? Donc pour, c'était le
cas pour les cours. Mais si nous
parlons d'attributs et de méthodes, alors quand nous parlons alors quand nous parlons
de quelque chose qui est
final, cela signifie quoi ? Cela signifie que cette
chose, cet attribut ou cette méthode ne peuvent pas
être remplacés. Écrasé. Montrez que vous vous souvenez encore de l'
exemple que nous avons fait ci-dessus. Cela ne peut pas être réécrit
une heure de plus ou
y a-t-il des personnes qui auraient
même été modifiées ? Ensuite, s'il est statique, nous avons également statique. Si quelque chose est statique ou que les attributs et les
méthodes sont statiques, cela signifie que nos attributs et méthodes appartiennent à la classe. Dan, plutôt qu'un objet. Appartient à. Ils font partie de la classe. Plutôt que d'objecter. Ouais. Et s'il est abstrait, cela signifie
qu'il ne peut être utilisé que dans
une classe abstraite. Et
seul N ne
peut seul N ne être utilisé que sur des méthodes, pas sur autre chose. Il suffit donc de garder à l'esprit que la méthode n'a pas incarné. Par exemple, quelque chose comme le vide
abstrait court de sorte que le corps lui-même soit fourni par la sous-classe héritée
de, right. C'est donc juste quelques informations
supplémentaires que vous devez garder
à l'esprit. Nous pourrions également parler de la façon dont
il existe également des transitoires, ce qui n'est pas très courant à utiliser, mais qui existe toujours. Cela signifie donc quels
attributs et méthodes sont ignorés lors de la sérialisation de
l'objet qui les contient ? envoyer est ignoré. En utilisant l'objet
qu'ils contiennent. Ensuite, nous avons également synchronisé. Que signifie donc
essentiellement « synchronisé » ? Quand quelque chose est synchronisé
, ce que nous disons, c'est que je crois que j'ai oublié
quelque chose ici. Le péché a été colonisé. Ouais. C'est la bonne orthographe. Synchronisé. Cela signifie que nos
méthodes ne
sont accessibles que par un seul fil
à la fois, n'est-ce pas ? Il est donc important que
je précise qu'ici, s'agit d'une méthode à laquelle je
ne fais référence que. Les méthodes ne sont accessibles que par un seul thread à la fois. Ensuite, s'il s'agit de volatilité ou
plutôt de volatilité, si vous le souhaitez. Si j'utilise la volatilité signifie que la valeur d'
un attribut
n'est pas couchée localement et qu'elle est toujours lue
dans la mémoire principale, n'est-ce pas ? Encore une fois, n'est
certainement pas quelque chose que vous verrez souvent. Mais si les coûts, la programmation
est si importante avec Java, désolé, cela
dépendra finalement de ce que
vous citez. Ces concepts géniaux
qui se
retrouveront progressivement à faire localement et qui sont toujours lus à partir de la mémoire principale. Ce n'était
pas là lundi. Oui, ce sont donc les modificateurs d'accès axis n none que vous devez absolument garder à l'esprit. Et tout à l'heure, nous allons
juste faire quelques exemples, explorant
cela beaucoup plus loin. Un exemple de cela
serait quelque chose comme ça. Permettez-moi de tout supprimer. Nous n'avons plus besoin de ça. Donc ça dit « final ». Il y a un modificateur dans x sur un attribut ici
et donnez-lui peut-être 19. Et puis nous disons double final
Pi et Pi lui-même, comme nous le savons, il est donné par 3,14. Oui, 3,14 c'est 3,1428. Alors laissez-moi juste vous aider et progressivement,
et ainsi de suite. Nous déclarons donc que nos
modificateurs sont finis. Cela signifie qu'ils ne peuvent pas
être remplacés ou modifiés. Nous ne pouvons pas définir la
nouvelle valeur de X ou la nouvelle valeur de pi, n'est-ce pas ? Et puis voici la méthode. Nous disons public, statique, vide, principal,
puis cette chaîne. Et nous nous assurons simplement
que nous avons bien, le clavier sur leur RGS et
nous l'ingérons. Et là,
nous créons un objet. Alors nous disons bonjour à tout le monde. Et puis mon J est égal au nouveau
nom bonjour-monde de ma classe. Je viens juste de descendre et puis
de commencer à explorer autre
chose. Commençons donc comme ça. Disons simplement mon OBJ,
puis je dis x. Et voyons
ce que ça va être intéressant. Les choses sont erronées. Ils, pourquoi est-ce une erreur ? Eh bien, comme nous pouvons le voir, erreur. Très bien, pourquoi ? Parce qu'il ne peut pas
affecter la valeur de x, y parce que nous
l'avons déclaré comme final. Cela signifie qu'il ne peut être ni
modifié ni modifié de quelque
manière que ce soit. Même si nous devions essayer le gâteau et simplement essayer de modifier
notre Pi également. Une chose similaire
se produirait certainement avec cinq :
Oh, la nouvelle valeur de pi est
juste 3,14, par exemple. Rien de mal à cela,
mais c'est toujours une erreur. Pourquoi est-ce que l'erreur est
une erreur parce que nous modifions la valeur qui a été
déclarée finale. Cela ne devrait pas changer. Impossible d'attribuer une
valeur de Pi sinus, accord,
oui, oui, d'accord. Alors laisse-moi juste essayer d'
imprimer et de dire, Hey, system, dot out, dot print. Ensuite, nous
imprimons x par exemple. Et nous voyons ce qui va se passer. Donc, si nous imprimons x, juste un ici, souvenez-vous que nous avons
imprimé avec object. Voilà donc mon objet. Voyons ce que nous obtenons. Maintenant. Évidemment celui-ci, nous allons le mettre
en commentaire parce que nous savons qu'
il y a une erreur. Nous n'en avons pas besoin.
Et nous le gérons. Et voyons voir. Je prends un peu de
temps ici pour charger. Toujours en cours de chargement C'est
maintenir parce que nous
définissons x comme 19, object est x. Et si je devais changer
cela par exemple, et que tout cela soit pi, alors voyons ce qui en
découle. Maintenant. Voyons si ça nous donne 3,148. C'est 3,1428, c'est ça ? Voici donc un exemple de notre
utilisation du modificateur final. Modificateur final, que nous savons
être dans le modificateur de non-accès. Utilisons maintenant un autre modificateur de
non-accès, qui est un modificateur statique. Alors ou est-ce qu'ils le comprennent
bien plus loin, non ? Donc avec celui-ci, c'est
un métal que nous
comprenons même à chaque
fois que comprenons même à chaque
fois nous avons quelque chose qu'
on appelle statique. La méthode statique signifie qu'il est
possible d'y accéder sans créer
d'objet d'une classe. Contrairement au public où nous avons
déjà parlé de celui-ci, nous parlons de
statique par opposition à non-statique. Attends. Juste pour mettre ça en perspective, laisse-moi
tout supprimer ici. Je vais probablement donner à ce type ici parce que je sais que je
n'ai pas un seul clavier. Et créez simplement une méthode statique. Je dis juste statique, vide, ma méthode
statique. Et c'est définitivement ouvert. Et appelez ça un
système, pointez, imprimez et écrivez dedans. écris probablement
quelque chose comme statique. Les méthodes peuvent être appelées
sans créer d'objets. Ouais.
22. Modificateurs d'accès et de non-accès: Ensuite, il suffit de regarder méthode
publique et de regarder
dans un vide public. Créez quelque chose comme public void et
appelez-le simplement mon public void. Maintenant, méthode publique, c'est plutôt ici, imprimons quelque chose
comme un système qui est élagué. Disons que les méthodes publiques
doivent être froides. En créant des objets. Alors nous en avons beaucoup. Certains
diront méthode principale, mais nous l'appellerons simplement
notre méthode HelloWorld. Et celui-ci
sera juste quelque chose comme ce principal public, statique et vide. Et nous allons parler de
ce train
G S , descendre et
appeler notre méthode statique. Assurez-vous simplement que j'ai ces
accolades. Oui, ma méthode statique, essentiellement j'appelle
cette méthode statique colin, la méthode statique. Ce faisant. Ensuite, si je
regarde ma méthode publique, si je devais essayer de l'appeler
, voyons voir. Cela indique déjà
que quelque chose n'
allait pas, car cela ne m'a pas été suggéré,
qu'il y a une erreur. Pourquoi ? Parce que j'ai besoin de
créer un objet pour pouvoir utiliser ce droit. Voici une erreur. Je dois donc mettre ceci en commentaire et
créer simplement mon objet Hello World. Bonjour. Très bien, je pense qu'il est
temps de changer. Maintenant. Mon O, pour l'instant. J'appelle mon OBJ depuis trop longtemps ou
trop longtemps. Et bonjour tout le monde et mon OH, et cette méthode
publique d'homme de couleur qui m'a
été suggérée. Et en gros, j'
appelle la méthode maintenant. Si je lance ceci, normalement
cela devrait fonctionner. Maintenant, je devrais être capable d'imprimer la
méthode publique ainsi que la méthode statique. Je devrais donc voir les deux
instructions fumer une seule d' entre elles devrait voir que les méthodes statiques peuvent être appelées sans
créer d'objets. Et je devrais être capable de voir que les méthodes publiques doivent également être appelées en
créant des objets. Voyons voir. Il est également en cours de chargement. Ça y est. Nous les avons tous
les deux. Les méthodes statiques peuvent être appelées sans
créer d'objets. Et nous avons
des méthodes publiques qui peuvent être appelées un must être appelées
en créant des objets. Oui, c'est beau. Nous l'avons donc. Voilà, nous l'avons. Ensuite, la dernière modification
que nous examinerons est
ce que nous appelons le modificateur
abstrait. Comme nous le savons, le modificateur
abstrait appartient également au modificateur de
non-accès. Ouais. Et cela peut fonctionner pour les classes
et quatre attributs, non ? C'est tellement abstrait. Je vais juste
supprimer tout ça encore une fois. Et nous nous
assurons simplement que tout est en place. Ok, c'est beau. Très bien. Donc au lieu d'
appeler cela public, nous allons simplement parler d'obstruction
abstraite. Il y a des cours abstraits. Et avec Officer plus,
nous allons simplement appeler, je n'ai plus besoin de cette méthode
statique. Et puis je
dirai quelque chose comme peut-être public String fname, qui est pour mon prénom, et je l'appellerai Will. Et public end. L'âge aussi, qui
est de 24 ans. Et puis il y a abstrait
public aussi un
vide abstrait
public. Étudier. Cela signifie qu'il s'
agit d'une méthode abstraite. Ouais. Il s'agit d'une méthode abstraite. Oui, définitivement. Et nous nous assurons simplement que
c'est fermé comme ça. C'est définitivement comme ça. Bien. Ensuite, juste en dessous, nous allons avoir
quelque chose comme une sous-classe, dont nous héritons vraiment
de Hello World. Et avec toutes les sous-classes,
il suffit de dire clusters, ce qui signifie que c'est
par défaut
si vous voulez, si nous devions le
laisser comme juste le coût. Donc s'ils agressent l'
étudiant Big S et que nous disons étendre l'
héritage maintenant, bonjour tout le monde. Et nous l'ouvrons. Les possibilités sont infinies. Maintenant ,
nous
avons public et Fermer cliquez sur Commande. Très bien, donc la prochaine chose que je veux que nous
examinions est ce qu' on appelle l'encapsulation Java. Donc, il suffit d'avoir
ça ici. Il s'agit de l'encapsulation Java. Donc, ce que signifie l'encapsulation Java c'est pour nous de vraiment
comprendre ce cela signifie vraiment, c'est que
nous devons comprendre ce qu'est l'
encapsulation d'encapsulation. Cela signifie s'assurer que les données
sensibles sont
cachées aux utilisateurs. Et pour y
parvenir,
nous devons déclarer des variables de
classe. Les attributs slash, bien sûr, battent en fait comme privés. Deuxièmement, fournissez,
nous voulons nous assurer que nous fournissons l'axe des méthodes Public get et set et la valeur de la variable privée. Oui, donc c'est quelque chose de
très important également. Donc vous, nous avons déjà fait en sorte
que les variables privées ne sont accessibles que dans la même classe et que la
classe externe n'y a pas accès. Cependant, nous savons qu'il
est possible d'
y accéder si nous fournissons des méthodes
get et set publiques, n'est-ce pas ? Donc, la méthode GET renvoie la valeur de la variable et la méthode
set définit la variable. La syntaxe pour
les deux est qu'ils commencent
par
get all set suivi du nom de la variable avec la première lettre en majuscule. Un exemple de cela serait,
disons, la classe publique. Comme ils le suggéraient
déjà ici. Bonjour tout le monde. Génial ! Ensuite, écrivez-y, ce que nous
voulons faire, c'est mettre quelque chose comme une chaîne privée
, puis l'appeler un nom. Et assurez-vous que
c'est fermé. Ben, sache que
quand c'est privé,
privé signifie un accès restreint. Donc, pour des raisons de sécurité, nous voulons absolument mettre
en place de tels dispositifs. Nous ne voulons pas que tout le monde ait
accès à tout ce qui se trouve dans votre code, car ils
peuvent certainement pirater vos fichiers et simplement obtenir beaucoup
d'informations de vous. Ensuite, nous avons GetName. Et nous l'ouvrons. Et nous disons « nom de retour ». Nom de retour. Alors c'est un getter. Maintenant, nous avons aussi nos soies. Et avec toute la configuration, nous allons simplement dire
public void setName. Et il suffit de faire appel à cette
formation pour un nouveau nom. Et ouvrez ceci et
dites simplement ce nom comme équivalent. Nouveau nom. Excellent. Excellent. Donc si nous lançons ça, voyons ce que nous obtenons.
23. Projet du cours: Très bien, merci de vous
être joints à moi pour ce cours et pour
votre projet de classe. Ce que je veux que tu
fasses, c'est que je veux que tu fasses, avec tous les
trivalents maintenant, je vais joindre un fichier ici. Je veux que tu ailles
directement dans ce dossier. Je veux lire ça. Et il y a quelques exercices que j'ai également joints
que j'
aimerais que vous passiez en revue
et que vous me soumettiez simplement. Très bien, bravo, et j'ai
hâte de vous voir
dans le tableau de bord des coûts.