So the first thing that I asked you,
is whether udacicolaVotes is a local variable or a global variable.
And you should have determined that it was a local variable.
Well, to figure this out, you go to where the variable is declared, which is
here, and you know it's declared, because the data type is right here.
And you see is it declared Inside of a method, meaning between between the two
curly braces here, or is it declared outside of the method?
Now, if it's declared inside of a method,
that means that it's a local variable, and
we can see very clearly that it is in fact declared inside of a method.
So it's a local variable.
Well, what does that mean?
We should also be asking ourselves,
if I declared something as a local variable, should I have?
Let's think about it in this case.
Here's our phone.
And we've been talking about udacicola, so
let's only focus on when we click the udacicola button.
When we click this button, this method starts.
It sets udacicola votes to zero, and then it adds one to udacicolaVotes,
which is zero.
So udacicolaVotes becomes one.
Now, because udacicolaVotes is a local variable, at the end of this method,
it actually sort of dies, or gets deleted.
The fact udacicolaVotes is trashed, or gone, at the end of this method because
it's a local variable, causes a couple problems.
So why is this a problem?
Well, you would think that if three different people voted for
udacicola by clicking on the button, that udacicolaVvotes should be three.
Well, what actually happens is the first time you click on the button,udacicola
becomes zero.
It gets one added to it, becoming one.
And then it gets trashed.
It doesn't exist anymore.
The second time that somebody clicks on udacicolaVotes,
well udacicolaVotes is made all over again.
It's declared again.
Because remember, the first time it had essentially gotten trashed.
So it needs to be remade.
And when it's remain, it's set to zero.
Now we add one again to it, but remember the value is zero.
So udacicolaVotes is still one, even though the button's been clicked twice.
And the same thing happens when it's clicked the third time,
it still is one and it's actually trashed again at the end of this method.
So that's the first problem.
It's not really saving the state between button clicks.
About how many people have voted for udacicola.
But another problem is down here, this code's actually going to throw an error.
And the reasoning for that is because remember I said that udacicolaVotes
sort of comes into existence or its scope begins right here.
And then at the end of this voteudacicola method.
It is trash, it's out of existence.
Which means when I come down here, udacicolaVotes doesn't really exist.
More technically, we say that this variable is out of scope.
Its scope was here It got declared here, and it ended here.
But we're trying to use it down here.
And it can't be used.
Having udacicolaVotes be a local was not a correct decision in this case.
And I can summarize why with these two points.
It's not saving the vote about between button click, and it's not in scope for
the show me votes method.
So this will actually cause errors.
So this will actually not compile.
Okay, so let's look at the other variable in this program.
حسناً أول سؤال اسأله لك
فيما إذا كان udacicolaVotes متحول محلي أو متحول عام
ويجب أن تكون قد حددت أنه متحول محلي
حسناً، لإستنتاج ذلك، ستذهب إلى المكان الذي حدد به المتغير، وهو
هنا، وأنت تعلم بأنه قد تم تحديده بسبب نمط البيانات الموجودة هنا
وكما ترى هل تم تعينه داخل الطريقة، هنا بين قوسين التنصيص، أو
تم تحديده خارج الطريقة؟
الآن، إذا تم تعينه داخل الطريقة
هذا يعني أنه متحول محلي
يمكننا أن نرى بشكل واضح جداً أنه في الحقيقة تم تعيينه داخل الطريقة
لذلك فهو متحول محلي
حسناً، ماذا يعني ذلك؟
علينا أيضاً أن نسأل أنفسنا
إذا صرحت عن شيء كمتحول محلي هل ينبغي أن أفعل ذلك؟
دعونا نفكر به ضمن هذه الحالة
ها هو هاتفنا
وكنا نتحدث عن "udacicola" لذلك
دعونا نركز فقط عندما نضغط على زر udacicola
عندما نضغط على هذا الزر ستبدأ هذه الطريقة
سيتم تحديد قيمة udacicolaVotes بالصفر وبعد ذلك يضاف واحد إلى udacicolaVotes
والتي هي صفر
لذلك ستصبح udacicolaVotes واحد
الآن، ولأن udacicolaVotes هو متحول محلي ففي نهاية هذه الطريقة
في الواقع سيتوقف أو سيحذف
في الواقع أن udacicolaVotes مهمل أو ضائع، في نهاية هذه الطريقة لأنه
متحول محلي ويسبب ذلك مشاكل الإزدواج
حسناً لماذا تعتبر هذه مشكلة؟
حسناً، ستعتقد إن صوّت ثلاثة أشخاص مختلفين لـ
عن طريق النقر على الزر udacicola فإن قيمة udacicolaVotes يجب أن تكون ثلاثة
حسناً، ما يحصل في الواقع أن المرة الأولى التي تقوم بها بالضغط على الزر
فإن udacicola ستصبح صفر
سيتم إضافة واحد لها، لذلك ستصبح واحد
ومن ثم سوف تهمل
فهي ليست موجودة بعد الآن
في المرة الثانية التي يقوم بها شخص ما بالضغط على udacicolaVotes
فستقوم udacicolaVotes بتكرار ذلك كله مجدداً
لقد تم تعيينه مرة أخرى
تذكر السبب أنه في المرة الأولى قد تم إهماله بشكل أساسي
لذلك يجب أن يعاد إنشاؤه
وعندما يبقى هكذا، فيتم تعيينه كصفر
الآن نقوم بإضافة واحد مرة أخرى ولكن تذكر بأن القيمة صفر
فلذلك فإن udacicolaVotes لا تزال واحد على الرغم من أنه تم النقر على الزر مرتين
ونفس الشيء يحدث عندما يتم النقر عليه للمرة الثالثة
هو مازال واحد، وفي الواقع قد تم إهماله مرة أخرى في نهاية هذه الطريقة
لذلك هذه هي المشكلة الأولى
فهو حقاً لا يخزّن الحالة بين ضغط الأزرار
فكم من الأشخاص قد صوتوا لـ "udacicola"
ولكن المشكلة الأخرى هي هنا هذا الكود الذي سيؤدي إلى خطأ
وتفسير ذلك هو إن كنت تتذكر عندما قلت أن udacicolaVotes
سيصبح نوعاً ما موجود أو أن نطاقه سيبدأ من هنا
ومن ثم في نهاية هذه الطريقة لـ voteudacicola
سيهمل، ولن يعد موجود
مما يعني أنه عندما أنظر للأسفل هنا فإن udacicolaVotes غير موجوة حقاً
وبشكل تقني أكثر، نقول أن هذا المتحول هو خارج النطاق
فقد كان نطاقه هنا وتم تعيينه هنا وانتهى الأمر به هنا
ولكننا نحاول أن نستخدمه هنا
ولا يمكن استخدامه
فوجود udacicolaVotes بشكل محلي لم يكن قراراً صحيحاً في هذه الحالة
ويمكنني أن ألخص السبب بنقطتين التاليتين
لا يقوم بتخزين التصويت بين الضغط على الزر، كما أنه ليس ضمن النطاق
لكي يريني طريقة التصويت
لذلك هذا سيسبب أخطاءً في الواقع
ولذلك فإن ذلك لن يكن محدداً
حسناً، دعونا ننظر إلى متحول أخر في هذا البرنامج
Lo primero que te pregunté
era si udacicolaVotes es una variable local o global.
Debes haber notado que es una variable local.
Para averiguarlo ve a donde está declarada la variable, aquí.
Sabes que se ha declarado porque está escrita aquí.
¿Se ha declarado dentro de un método, entre estas dos llaves,
o fuera de ese método?
Si se ha declarado dentro de un método, quiere decir que es una variable local.
Aquí se ve claramente que se ha declarado dentro de un método.
Así que es una variable local.
¿Qué significa esto?
La pregunta que deberíamos hacernos es
si se debería haber declarado como una variable local.
¿Debería?
Vamos a pensar este caso.
Aquí está nuestro teléfono.
Hemos estado hablando sobre Udacicola,
así que fijémonos únicamente en cuando pulsamos el botón de Udacicola.
Cuando pulsamos este botón, empieza a ejecutarse este método.
Pone en cero udacicolaVotes
y luego añade 1 a udacicolaVotes, que está en cero.
Y udacicolaVotes pasa a ser 1.
Como udacicolaVotes es una variable local,
cuando acaba este método se destruye, se borra.
El hecho de que udacicolaVotes se borre o se destruya al final de este método,
dado que es una variable local, provoca algunos problemas.
¿Por qué?
Pensarás que si tres personas diferentes votan por Udacicola apretando este botón
udacicolaVotes debería ser 3.
Lo que en verdad ocurre es que la primera vez que pulsas el botón
udacicolaVotes es cero.
Después se añade 1,
y luego se borra, ya no existe.
La segunda vez que alguien pulsa para votar Udacicola
udacicolaVotes vuelve a empezar de cero, vuelve a declararse.
Recuerda que la primera vez se había destruido,
así que vuelve a ejecutarse.
Y cuando vuelve a ejecutarse, se pone en cero.
Vuelve a añadirse un 1 pero recuerda que el valor era cero,
así que udacicolaVotes es 1 aunque el botón se haya pulsado dos veces.
Y lo mismo ocurre cuando se pulsa por tercera vez.
Todavía está en 1 y vuelve a borrarse al final de este método.
Ese es el primer problema,
que no se está guardando el estado conforme se pulsa el botón.
No se guarda el número de personas que están votando.
Pero hay otro problema aquí abajo:
este código va a generar un error.
El motivo es que, si lo recuerdas, he dicho que udacicolaVotes
aparece aquí, su visibilidad empieza aquí.
Y, al final del método voteUdacicola,
se destruye, deja de existir.
Lo que significa que cuando vengo aquí, udacicolaVotes ya no existe.
Técnicamente decimos que esta variable no es visible.
Su visibilidad está aquí.
Se declara aquí y se acaba aquí.
Pero estamos intentando usarla aquí y no se puede.
Que udacicolaVotes sea una variable local no es una decisión acertada en este caso.
Resumo los motivos en dos puntos:
no guarda los votos al pulsar varias veces el botón
y no es visible dentro del método showMeVotes,
así que esto dará error.
Esto de aquí no se compilará.
Vamos a echar un vistazo a la otra variable de este programa.
Donc, la premičre chose que je vous ai demandée,
c'est si les udacicolaVotes sont une variable locale ou globale.
Et vous devriez voir déterminé que c'est une variable locale.
Bien, pour trouver ça, vous allez lŕ oů la variable est déclarée, et c'est
ici, et vous savez que c'est déclaré car le type de donnée est juste ici.
Et vous voyez que c'est déclaré dans une méthode, c'est ŕ dire entre les deux
accolades ici, ou est-ce déclaré en dehors de la méthode?
Maintenant, si c'est déclaré ŕ l'intérieur de la méthode
ça signifie que c'est une variable locale et alors
on peut clairement voir que c'est bien déclaré ŕ l'intérieur de la méthode.
Donc c'est une variable locale.
Bien, qu'est-ce que ça veut dire ?
On devrait aussi se demander,
si j'ai déclaré quelque chose comme une variable locale, ai-je bien fait ?
Réfléchissons-y dans ce cas.
Voici notre téléphone.
Et nous avons parlé d'udacicola, donc
concentrons-nous seulement sur le moment oů on clique sur le bouton udacicola.
Lorsque l'on clique sur ce bouton, cette méthode démarre.
Cela définit les votes udacicola ŕ zéro, puis ça ajoute un aux udacicolaVotes,
qui sont ŕ zéro.
Donc les udacicolaVotes passent ŕ un.
Comme le vote udacicola est une variable locale, ŕ la fin de cette méthode,
il meurt en quelques sortes, ou il est supprimé.
Les udacicolaVotes soient détruits ou disparaissent en fin de méthode car
c'est une variable locale, ce qui cause quelques problčmes.
Alors, pourquoi est-ce un problčme ?
Bien, vous pourriez penser que si trois personnes ont votés
udacicola en cliquant sur le bouton, les udacicolaVotes devraient ętre ŕ 3.
Ce qui se passe, c'est qu'au premier clic sur le bouton, udacicola
devient zéro.
Il y en a un qui s'ajoute et ça devient un.
Puis il se détruit.
Il n'existe plus.
La deuxičme fois que quelqu'un clique sur les udacicolaVotes,
les udacicolaVotes sont ŕ nouveau faits.
C'est ŕ nouveau déclaré.
Car rappelez-vous, la premičre fois il a été détruit.
Donc il doit ętre refait.
Et lorsqu'il reste, il est définit ŕ zéro.
Maintenant on ajoute ŕ nouveau un, mais rappelez-vous la valeur est zéro.
Les udacicolaVotes sont donc ŕ un, bien qu'on ait cliqué deux fois.
Et la męme chose se produit au troisičme clic
il est toujours ŕ un et sera ŕ nouveau détruit ŕ la fin de cette méthode.
C'est donc le premier problčme.
Ce n'est pas vraiment de sauvegarder l'état entre le clics de bouton
ŕ propos de combien de personnes ont voté pour udacicola.
Mais il y a un autre problčme ici, ce code va en fait déclencher une erreur.
Et lŕ raison c'est que, rappelez vous que j'ai dit que les udacicolaVotes
voient en quelque sorte le jour, ou leur portée commence ici.
Et ŕ la fin de cette méthode de vote udacicola.
Ils sont détruits, ils n'existent plus.
Ça veut dire que quand je viens ici, les udacicolaVotes n'existent pas vraiment.
Plus techniquement, on dit que cette variable est hors de portée.
Sa portée était lŕ, elle a été déclarée lŕ, et ça s'est terminé ici.
Mais on essaie de l'utiliser ici.
Et elle ne peut pas ętre utilisée.
Les udacicolaVotes en local ça n'était pas une bonne décision dans ce cas.
Et je peux résumer pourquoi avec ces deux points.
Ça ne mémorise pas le vote entre les clics, et ce n'est pas dans la portée
pour la méthode show me votes.
Cela va donc effectivement causer des erreurs.
Donc cela ne va pas se compiler.
Ok, regardons les autres variables de ce programme.
Hal pertama yang saya tanya
yaitu apakah udacicolaVotes termasuk variabel lokal atau global.
Dan harusnya sudah Anda tentukan kalau dia termasuk variabel lokal.
Nah, untuk memahaminya Anda perlu menuju tempat dimana variabel dinyatakan
yaitu di sini, dan sudah dinyatakan karena tipe data ada di sini.
Dan dinyatakan di dalam sebuah metode, yang bearti di dalam
kurung kurawal ini atau apakah ini dinyatakan di luar metode?
Sekarang, jika ini dinyatakan dalam sebuah metode,
maka artinya ini adalah variabel lokal dan
kita bisa lihat jelas kalau ini dinyatakan di dalam sebuah metode.
Jadi ini merupakan sebuah lokal variabel.
Nah, apa artinya?
Kita juga harus tanya pada diri kita,
jika saya menyatakan sesuatu sebagai variabel lokal, haruskah saya punya?
Mari kita bahas.
Ini adalah ponsel kita.
Dan kita telah membahas tentang udacicola, jadi
marilah hanya fokus pada saat kita mengeklik tombol udacicola.
Saat kita mengeklik tombol ini, metode ini memulai.
Ini mengatur nilai udacicola ke nol, lalu menambah satu untuk udacicolaVotes,
yang bernilai nol.
jadi udacicolaVotes menjadi satu.
Karena udacicolaVotes adalah variabel lokal, pada akhir metode ini,
dia akan mati atau dihapus.
Penyebab udacicolaVotes hancur atau menghilang pada akhir metode ini adalah
karena variabel lokal menyebabkan beberapa masalah.
Jadi, kenapa ini bermasalah?
Jika Anda pikir kalau tiga orang berbeda melakukan vote untuk
udacicola dengan cara mengeklik tombol, maka nilai udacicolaVvotes menjadi tiga.
Yang sebenarnya terjadi adalah saat pertama kali Anda mengeklik tombol,
udacicola menjadi nol.
Ditambah satu, menjadi satu.
Dan kemudian terbuang.
Tidak ada lagi.
Kali kedua seseorang mengeklik udacicolaVotes,
maka udacicolaVotes mengulang dari awal lagi.
Ini dinyatakan kembali.
Ingat, kali pertama dia terbuang.
Dia harus dibuat kembali.
Dan ketika dibuat kembali, dia diatur ke nol.
Sekarang kita tambahkan satu lagi, tapi ingat nilainya adalah nol.
Jadi udacicolaVotes masih tetap satu, walaupun tombolnya di klik dua kali.
Hal sama terjadi juga saat mengeklik yang ketiga kalinya,
masih tetap satu dan akan terbuang kembali pada akhir metode ini.
Itu adalah masalah pertama.
Tidak akan benar-benar menyimpan nilai antara tombol klik.
Mengenai jumlah orang yang telah memberi vote untuk udacicola.
Masalah lain ada di bawah ini, kode ini akan membuat masalah.
Dan alasannya, ingat yang pernah saya katakan kalau udacicolaVotes
seperti hidup atau bisa dibilang kalau jangkauannya dimulai di sini.
Lalu, di akhir metode voteudacicola ini.
Menjadi sampah, tidak ada lagi.
Yang berarti saat saya turun kesini, udacicolaVotes tidak ada.
Secara teknis, variabel ini di luar jangkauan.
Jangkauannya ada di sini, dinyatakan di sini dan berakhir pula di sini.
Tapi, kita sedang mencobanya di sini. Dan tidak bisa digunakan.
Memiliki udacicolaVotes sebagai lokal bukanlah keputusan yang tepat.
Dan saya rangkum dalam dua poin.
Ini tidak menyimpan vote antara tombol klik dan tidak berada dalam
jangkauan metode show me votes.
Jadi, ini benar-benar akan membuat kesalahan.
Jadi ini tidak akan dikumpulkan.
Oke, ayo lihat variabel lainnya dalam program ini.
まず 最初に私があなたに聞いたのは
udacicolaVotesがローカル変数か グローバル変数かです
そして あなたはローカル変数だと 決定すべきでした
これを見つけ出すには変数が宣言された場所 つまり ここへ行き
そのデータタイプはここなので それが宣言されているのが分かります
メソッドの中で宣言されているかどうか
つまり波カッコの中で宣言されているか 外で宣言されているどうかです
メソッドの中で宣言されている場合
それはローカル変数であることを 意味しています
実のところ それはメソッドの中で 宣言されていることがと明らかです
だから それはローカル変数です
どういうことでしょうか？
私たちは私たち自身にも 問いかけるべきです
ローカル変数として何かを示した時 それで良いかどうか考えましょう
このケースについて考えてみましょう
ここに私たちの携帯があります
そして 私たちは udacicolaについて 話しています
udacicolaボタンをクリックした時だけに 注目してみましょう
このボタンをクリックした時 このメソッドはスタートします
udacicolaVotesを０にセットし ０であるudacicolaVotesに
１を加えます
従って udacicolaVotesは １になります
さて この方法の終わりに udacicolaVotesはローカル変数なので
このメソッドの終わりにudacicolaVotesは いわば死んだようなもので削除されます
ローカル変数なので udacicolaVotesが このメソッドの終わりに 破棄される
またはなくなるという事実は いくつかの問題を引き起こします
では なぜ問題なのでしょう？
もし それぞれ３人がボタンを押して udacicolaに投票したら
あなたはudacicolaVvotesが ３になるべきだと思うでしょう
ここで実は何が起こっているかと言うと ボタンを初めて押したら
udacicolaは０になります
１つ加えると１になります
そして破棄されます
udacicolaはもう存在していません
２度目にudacicolaVotesを 誰かがクリックします
udacicolaVotesは また最初から作成されます
再度宣言されます
なぜなら 覚えていますか？最初に udacicolaVotesは基本的に破棄されます
だから再度作り直す必要があります
そして作り直された時 ０にセットされます
さて 再度１を追加します しかし 覚えていますか？ここでの値は０です
だから たとえボタンが２度押されたとしても udacicolaVotesはまだ１です
そして３度目にボタンが押されても 同じことが起こります
まだ１のままで 実際にudacicolaVotesは この方法の最後には再度破棄されます
これが最初の問題です
ボタンクリックの間で 状態が保存されていません
何人の人がudacicolaに 投票しているかに記憶しません
しかし 他の問題はここにあります このコードは実はエラーを投げます
そしてその理由は udacicolaVotesは
ここでその存在が始まる またはそのスコープが始まります
そしてこのvoteudacicolaメソッドの最後に
破棄されます 存在していません
つまりここにくるとvoteudacicolaは 本当は存在していないことを意味します
もっと専門的には この変数はスコープ外と私たちは言います
スコープはここで宣言されています そして ここで終了しました
しかし 私たちはここで 使用しようとしています
そして使用できません
udacicolaVotesをローカル変数とすることは このケースでは正しい選択ではありません
そして私はこの２つのポイントを使って なぜなのかまとめる事ができます
それはボタンクリック間で投票数を 保存していないこと
showMeVotesメソッドの スコープ内でないことです
つまり これが実は エラーを引き起こします
つまり これは 実はコンパイルできません
それでは このプログラムの 他の変数をみてみましょう
이제 한가지를 당신에게 묻겠습니다,
udacicolaVotes는 단지 지역 변수인가요 아니면 국제 변수인가요.
그리고 당신은 이것이 지역 변수라고 생각하여야합니다.
이제 알아보기 위해서, 당신은 어디서 변수가 발견되는
것과 당신이 알고 있는 것을 알아보도록 하겠습니다.
그리고 당신은 방법의 내부를 확인하고 두가지
괄호 안의 내용을 확인하고 외부내용을 밝힐 수 있나요?
이제, 만약 밝혀졌다면 방법 내부에,
이는 지역 변수라는 의미이며 또한
우리는 매우 확실하게 방법 내부의 방법이라고 확인할 수 있습니다.
그래서 이것은 지역 변수인 것입니다.
그래서 이것은 무슨 의미일까요?
우리는 스스로에게 질문해보아야 하며,
만약 주장한 사항이 지역 변수라면, 가져야 할까요?
이 케이스에서 알아보겠습니다.
여기 휴대전화가 있습니다.
그리고 우리는udacicola에 대해 이야기하고 있습니다, 그리고
udacicola버튼을 클릭하는 것에 집중하시길 바랍니다.
이 버튼을 누를때, 이 방법은 시작됩니다.
이는udacicola를 0으로 만들며 udacicolaVotes에 1을 추가합니다,
결론적으로 0이죠
그리고 udacicolaVotes는 1이 됩니다.
이제, udacicolaVotes는 이 방법의 마지막인 지역변수이기에,
이는 실제로 소멸되거나 삭제된 사항일 것입니다.
udacicolaVotes의 사실은 삭제되었거나 사라졌을 것입니다. 왜냐하면
이는 지역 변수이며 다양한 문제를 일으키기 때문이죠.
왜 문제가 되냐구요?
아마 당신은 만약 다른 사람들이
udacicola의 버튼을 클릭함으로 udacicolaVvotes는 3이 되어야 한다고 생각할 것입니다.
실제로 첫번째 클릭했을 때 일어나는 것은,udacicola
가 영이 되는 것입니다.
이는 하나가 추가가 되도, 하나가 되는 것입니다.
그리고 삭제되죠.
이것은 더이상 존재하지 않습니다.
두번째에는 누군가 udacicolaVotes를 클릭하면,
udacicolaVotes는 지속적으로 만들어질 것입니다.
이는 계속 반복되는 것이죠
왜냐하면, 첫번째 기본사항이 삭제된 것을 기억하세요.
그리고 이것은 재 생산됩니다.
그리고 이것이 존재할 때, 이는 0입니다.
이제 우리는 한개를 추가하면, 값은 0이 되는 것을 기억해야합니다.
그리고udacicolaVotes는 여전히 하나입니다. 두번 클릭했더라도 말이죠.
그리고 세번째 클릭할때도 같은 활동을 벌이며
여전히 1이 되고 이 방법의 마무리에 실제로 삭제됩니다.
그리고 이것이 첫번째 문제입니다.
이는 단지 말을 줄이는 것이 아닌 버튼 클릭의 문제인 것입니다.
얼마나 많은 사람들이 udacicola를 투표하였는가.
하지만 다른 문제는 여기에 있습니다, 이 코드는 실제로 우류가 발생합니다.
그리고 이러한 이유로 udacicolaVotes를 기억해야합니다.
존재를 종류별로 기억하거나 관점을 여기서 시작해야합니다.
그리고 voteudacicola방법의 마지막에는
이는 삭제되고, 더이상 존재하지 않습니다.
이 의미는 여기로 내려와도 udacicolaVotes는 존재하지 않는다는 것입니다.
더 기술적으로, 우리는 이 값들이 변수 밖이라는 것을 알 수 있습니다.
이 관점은 분명히 되어 있어도 이곳에서 종료되는 것입니다.
하지만 여기서 사용할 수 있으며
여기서 사용을 할 수 없게 됩니다.
udacicolaVotes를 지역으로 가지고 있는 것은 올바른 결정이 아닌 것입니다.
그리고 저는 왜 이 두 점인지 요약할 수 있습니다.
이는 버튼을 클릭하는지 투표 방법을 보여주는지를
저장하지 않습니다.
그리고 이것은 실제로 오류를 야기합니다.
그리고 이것은 실제로 축적되지 않습니다.
좋습니다 이제 이 프로그램의 다른 변수들을 볼 차례입니다.
Então a primeira coisa que perguntei a você,
foi se udacicolaVotes é uma variável local ou uma variável global.
E você deveria ter respondido que é uma variável local.
Bem, para descobrir isto, você vai para onde a variável é declarada, que é
aqui, e você sabe que é declarado, porque o tipo de dado é aqui mesmo.
E você vê que é declarada dentro de um método, ou seja, entre as duas
chaves aqui, ou é declarada fora do método?
Agora, se ele é declarado dentro de um método,
que significa que é uma variável local, e
podemos ver muito claramente que é na verdade declarada dentro de um método.
Portanto, é uma variável local.
Bem, o que isso significa?
Devemos também nos perguntar,
se eu declarei algo como uma variável local, eu deveria tê-lo feito?
Vamos pensar sobre isto neste caso.
Aqui está o nosso celular.
E nós temos falado sobre o botão udacicola, assim
vamos apenas focar quando clicarmos no botão udacicola.
Ao clicarmos neste botão, este método inicializa.
Ele define votos udacicola a zero, e depois, adiciona um a udacicolaVotes,
que é zero.
Assim, udacicolaVotes se torna um.
Agora, por udacicolaVotes ser uma variável local, no fim deste método,
na verdade meio que morre, ou é apagado.
O fato do udacicolaVotes ser descartadom ou apagao, no fim deste método
é por ele ser uma variável local, causa alguns problemas.
Então, por que este é um problema?
Bem, você pensaria que se três pessoas diferentes votassem
udacicola clicando no botão, aquele udacicolaVvotes deveria ser três.
Bem, o que realmente acontece é que na primeira vez que você clica no
botão, udacicola se torna zero.
Ela recebe um adicionado a ele, tornando-se um.
E então ele vai para a lixeira.
Ela não existe mais.
A segunda vez que alguém clicar em udacicolaVotes,
bem udacicolaVotes é todo refeito.
É declarado novamente.
Porque,lembre-se, na primeira vez tinha essencialmente sido descartado.
Por isto, precisa ser refeito.
E quando ele permanece, ele é definido como zero.
Agora adicionamos um novo para ele, mas lembre-se que o valor é zero.
Então udacicolaVotes ainda é um, mesmo depois de se clicar duas vezes.
E a mesma coisa acontece quando for clicado pela terceira vez,
ainda é um e é, na verdade, descartado no final deste método.
Então esse é o primeiro problema.
Não é realmente salvar o estado entre cliques de botão.
Sobre quantas pessoas votou udacicola.
Mas outro problema aqui embaixo, este código na verdade errará.
E o raciocínio para isso é porque lembre-se, eu disse que udacicolaVotes
meio que começa a existir ou seu escopo começa bem aqui.
E, em seguida, no final de este método voteudacicola.
É lixo, qnã existe.
O que significa que quando eu vir para cá, udacicolaVotes realmente não existe.
Mais tecnicamente, dizemos que esta variável está fora do escopo.
O seu escopo era aqui, ficou declarado aqui, e terminou aqui.
Mas estamos tentando usá-lo aqui.
E não pode ser utilizado.
Tendo udacicolaVotes para um local não foi uma decisão certa neste caso.
E eu posso resumir as razões com estes dois pontos.
Não está salvando o voto entre cliques de botão, e não está no escopo
para o método showmevotes.
Então, isto vai realmente causará erros.
Então, isto realmente não compilará.
Bem, então vamos olhar a outra variável deste programa.
Первое, о чем я вас спросила,
это является переменная udacicolaVotes локальной или глобальной.
И вы должны были определить, что она локальная.
Чтобы понять это, смотрим туда, где объявлена переменная, это здесь
и мы знаем, что она объявлена, так как здесь прописан тип данных.
Вы видите, она объявлена внутри метода, то есть между двумя волнистыми скобками,
или же снаружи метода?
Если переменная объявлена внутри метода,
это будет значить, что она локальная,
и мы ясно видим, что она действительно объявлена внутри метода.
Значит, эта переменная - локальная.
Хорошо, а что это означает?
Нам стоит также спросить себя,
правильно ли мы поступили, объявив какую-либо переменную локальной?
Давайте поразмышляем на данном примере.
Вот наш телефон.
Мы говорили об udacicola, так что
сосредоточимся на том, когда мы нажимаем эту кнопку.
При нажатии на кнопку запускается метод.
Количество голосов за udacicola задается нулевым,
затем прибавляется один к udacicolaVotes, которое равно нулю.
Так udacicolaVotes становится равным единице.
udacicolaVotes - локальная переменная, так что по окончании этого метода
она, на самом деле, как бы умирает, или удаляется.
Факт, что udacicolaVotes выбрасывается, исчезает по окончании метода
приносит, в действительности, пару проблем.
Так почему это проблема?
Вы можете подумать, что если три различных человека голосуют за
udacicola нажатием кнопки, то udacicolaVvotes станет равно трем.
На самом деле, когда кнопку нажимают впервые,
значение udacicola становится равным нулю.
При следующем нажатии оно станет единицей.
А затем отправится в мусор.
Перестанет существовать.
Когда udacicolaVotes нажимают во второй раз,
она, на самом деле, заново создается.
Заново объявляется.
Так как, вспомните, в первый раз она, по сути, была выброшена.
Поэтому ее необходимо переделать.
И снова ей придается нулевое значение.
Теперь мы снова прибавляем один, помня, что значение переменной равно нулю.
Так что udacicolaVotes все еще единица, хотя на кнопку уже нажали дважды.
И то же самое происходит при третьем нажатии,
она все еще единица и в действительности отправляется в мусор по окончании метода.
Это первая проблема.
Это не совсем сохранение состояния между нажатиями кнопки.
О том, как много людей проголосовали за udacicola.
Вторая проблема - вот здесь, этот код в действительности выдаст ошибку.
И причина лежит в том, что, как я уже говорила, udacicolaVotes
в своем роде зарождается здесь, ее область действия начинается именно тут.
А затем, по окончании метода voteudacicola
отправляется на свалку, прекращает существовать.
Это значит, что когда я обращаюсь сюда, udacicolaVotes уже не существует.
Говоря техническим языком, мы вне области действия переменной.
Область ее действия была здесь, здесь она была объявлена и здесь она закончилась.
Мы же пытаемся использовать ее тут.
А она не может быть использована.
Назначение udacicolaVotes локальной не было верным решением в нашем случае.
Я могу суммировать все это двумя пунктами.
Она не сохраняет голоса между нажатиями кнопки и находится
вне области действия метода showMeVotes.
Так что это вызовет ошибки.
В действительности код не будет скомпилирован.
Посмотрим на другую переменную данной программы.
Size ilk sorduğum şey,
udacicolaOyları’nın, yerel bir değişken mi yoksa küresel bir değişken mi olduğuydu.
Yerel bir değişken olarak belirlemeliydiniz.
Peki, bunun nedenini kavramak için buraya yani değişkenin bildirildiği yere gidin,
veri türü tam şurada olduğu için, değişkenin bildirildiğini biliyorsunuz.
Peki, metodun, yani çengelli parantezlerin
içinde mi yoksa dışında mı bildirilmiş?
Eğer metod içinde bildirildiyse,
bu yerel değişken olduğu anlamına gelir ve
gerçekten metot içinde bildirildiğini açık biçimde görebiliriz.
Yani yerel bir değişkendir.
Pekala, bunun anlamı nedir?
Kendimize şunu sormalıyız:
bir şeyi yerel değişken olarak bildirdim, başka türlü de yapabilir miydim?
Bu örnek üzerinden, bunun üzerine düşünelim.
İşte telefonumuz.
Udacicola üzerine konuşuyorduk, bu nedenle
yalnızca udacicola tuşuna bastığımız da ne olduğuna odaklanalım.
Tuşa bastığımız zaman metot yürütülmeye başlar.
Udacicola oylarına sıfır değeri verir ve sonra sıfır olan udacicolaOylarına
bir ekler.
Böylece udacicolaOyları 1 olur.
udacicolaOyları yerel bir değişken olduğu için, bu metodun sonunda,
bir şekilde noktalanır ya da silinir.
Yerel bir değişken olması nedeniyle metodun sonunda
udacicolaOylarının silinmesi iki soruna neden olur.
Bu neden bir sorundur?
Pekala, eğer üç farklı insan tuşa basarak,
udacicola'ya oy verseydi, udacicolaOyları'nun üç olması gerekirdi.
Gerçekte olan ise, tuşa ilk tıklandığında,
udacicolanın sıfırlanmasıdır.
Bir olması için, 1 eklenmesi gerekir.
1 olduktan sonra silinir.
Artık yoktur.
ikinci kez biri udacicolaOyları'na tıklarsa
udacicolaOyları yeni baştan oluşur.
Yeniden bildirilir.
Hatırlayın, çünkü ilk seferde bütünüyle silinmişti.
Yani yeniden oluşturulmaya ihtiyacı vardır.
Ve tekrar oluşturulduğunda değer sıfırdır.
Tekrar 1 ekliyoruz ama unutmayın değer sıfır.
Bu nedenle, tuşa iki kere tıklanmış olsa bile, udacicola hala birdir.
Aynı şey üçüncü kez tıklandığı zaman da olur,
Tekrar bir olur ve metodun sonunda yine silinir.
İşte bu ilk problemdir.
İki tıklama arasında durum kaydı yapılamıyor.
Yani kaç insanın oy verdiği kaydedilemiyor.
Diğer bir problem ise, bu kodun hata verecek olmasıdır.
Bunun arkasındaki neden, dana önce söylediğim gibi,
udacicolaOyları'nın oluşması ve faaliyetinin tam burada başlamasıdır.
Daha sonra metodun sonunda
silinir ve oluşumu sonlanır.
Bunun anlamı, buraya geldiğim zaman udacicola gerçekten mevcut olmamasıdır.
Teknik olarak söylersek, bu değişken faaliyet dışıdır.
Faaliyet alanı burasıdır, burada bildirilir ve sonlanır.
Ama biz bunu burada kullanmak istiyoruz.
lakin kullanılamıyor.
udacicolaOyları'nın yerel olarak atanması bu örnekte doğru bir karar değildi.
Bunun neden böyle olduğunu şu iki nokta ile özetleyebilirim.
Tıklamalar arasında oylar kaydedilmiyor oylarıBanagöster metodu
faaliyet alanı içinde değil.
Böylece hatalar ortaya çıkıyor.
Ve derleme mümkün olmuyor.
Pekala, şimdi bu programdaki başka bir değişkene bakalım.
Điều đầu tiên mà tôi hỏi bạn,
là udacicolaVotes là biến cục bộ hay biến toàn cục.
Và bạn cần xác định rằng nó là biến cục bộ.
Vâng, để tìm hiểu, bạn đi đến nơi khai báo biến, trong trường hợp này là
ở đây, và bạn biết nó đã được khai báo, vì kiểu dữ liệu ở ngay tại đây.
Bạn xem nó có được khai báo Bên trong phương thức, có nghĩa là ở giữa hai
dấu ngoặc ôm ở đây, hay nó được khai báo bên ngoài phương thức?
Bây giờ, nếu nó được khai báo bên trong của một phương thức,
thì có nghĩa rằng nó là một biến cục bộ,
ta có thể thấy rõ ràng rằng trong thực tế nó được khai báo bên trong phương thức.
Nên nó là biến cục bộ.
Ồ, vậy điều đó có nghĩa là gì?
Chúng ta cũng nên tự hỏi,
nếu tôi khai báo một thứ là một biến cục bộ, tôi có nên?
Hãy nghĩ về nó trong trường hợp này.
Đây là điện thoại của chúng tôi.
Chúng ta đã nói về udacicola, nên
hãy chỉ tập trung vào khi chúng ta nhấn nút udacicola.
Khi ta nhấn vào nút này, phương thức này bắt đầu.
Nó đặt phiếu udacicola bằng không, sau đó nó thêm một vào udacicolaVotes,
thứ hiện đang bằng không.
Và udacicolaVotes trở thành một.
Vì udacicolaVotes là biến cục bộ, ở cuối phương thức này,
nó sẽ biến mất hoặc bị xóa,
udacicolaVotes bị đẩy vào thùng rác, hoặc biến mất, khi kết thúc phương thức này vì
nó là một biến cục bộ, gây ra một số vấn đề.
Vậy, tại sao nó là một vấn đề?
Bạn sẽ nghĩ rằng nếu ba người khác nhau bình chọn cho
udacicola bằng cách nhấn vào nút, mà udacicolaVotes phải bằng ba.
Vâng, điều xảy ra là lần đầu tiên khi bạn nhấn vào nút, udacicola
trở thành không.
Nó thêm một vào, và trở thành một.
Và rồi nó bị đẩy vào thùng rác.
Nó không còn tồn tại nữa.
Lần thứ hai người nào đó nhấp chuột vào udacicolaVotes,
udacicolaVotes được thực hiện thêm một lần nữa.
Nó lại được khai báo.
Bởi vì, hãy nhớ rằng lần đầu tiên nó đã bị gạt vào thùng rác.
Nên nó cần phải được làm lại.
Và khi nó vẫn còn, nó được đặt bằng không.
Bây giờ chúng ta thêm một vào, nhưng nhớ giá trị là không.
Vậy nên udacicolaVotes vẫn là một, dù đã nhấn vào nút đó hai lần.
Và điều tương tự sẽ xảy ra khi nhấn vào nút đó lần thứ ba,
nó vẫn là một và nó lại bị xóa một lần nữa ở cuối phương thức này.
Đó là vấn đề đầu tiên.
Nó thực ra không lưu trạng thái giữa các lần nhấn nút.
Khoảng bao nhiêu người đã bình chọn cho udacicola.
Nhưng vấn đề là ở đây, đoạn mã này gây ra một lỗi.
Và lý do của nó là vì hãy nhớ tôi đã nói rằng udacicolaVotes
tồn tại hoặc phạm vi của nó bắt đầu ngay đây.
Sau đó ở cuối phương thức voteudacicola này.
Là thùng rác, nó không còn tồn tại.
Có nghĩa là khi tôi đến đây, udacicolaVotes không tồn tại.
Nói một cách kỹ thuật hơn thì biến này nằm ngoài phạm vi.
Phạm vi của nó ở đây, Nó được khai báo ở đây và kết thúc ở đây.
Nhưng ta đang cố gắng dùng nó ở đây.
Và không thể dùng được nó.
Để udacicolaVotes là biến cục bộ không là quyết định đúng đắn trong trường hợp này.
Và tôi có thể tóm tắt lý do tại sao với hai điểm này.
Nó không lưu các phiếu giữa các lần nhấn nút, và nó không thuộc phạm vi của
phương thức cho tôi thấy các phiếu.
Vì vậy, nó thực ra sẽ gây ra lỗi.
Nên nó sẽ không biên dịch.
Giờ hãy xem đến các biến khác trong chương trình này.
所以我问你的第一个事情是
udacicolaVotes 是一个局部变量还是一个全局变量
然后你已经判断它是局部变量
好的 为了证明它 你要去声明这个变量的地方 在这
你知道它已经声明了 因为数据类型已经在这了
你看到这是一个方法内的声明 意味着在这两个花括号之间
或者它是方法外的声明？
现在 如果它是方法内的声明
这意味着它是一个局部变量
我们可以清楚看到方法内的声明
所以它是一个局部变量
好的 这意味着什么？
我们应该常常问自己
如果我声明局部变量 我应该怎么做？
让我们在这个例子里思考
这是我们的手机
我们已经讨论过 udacicola 所以
我们只关注点击 udacicola 按钮的时候
当我们点击这个按钮 这个方法开始
它将 udacicolaVotes 归零 并将1票加给 udacicolaVotes
udacicolaVotes 的初始值是0
所以 udacicolaVotes 变为1
现在 因为 udacicolaVotes 是局部变量 在这个方法的最后
它实际上注销了 或者说被删除了
事实上 udacicolaVotes 已经废除了 或者 在这个方法的最后因为
它是局部变量 导致两个问题
为什么引起这些问题？
好的 你可以想象三个不同的人投票给 udacicola
通过点击按钮 udacicolaVvotes 会变为3
好的 当你第一次点击按钮时会发生 udacicola
归零
它加了1 变为1
之后它废除了
它就再也不存在了
第二次有人点击 udacicolaVvotes
udacicolaVvotes 再把那些做一遍
它再一次声明
因为记得 第一次本质上已经废除了
所以它需要资源回收
当它资源回收 它归零
现在我们再对它加1 不过记得值是0
所以 udacicolaVvotes 依然是1 甚至当按钮被按两次
当点击三次同样的事情会发生
它还是1并且再次废除在方法的最后
所以这是第一个问题
它实际上没有存储点击两次的状态
关于多少人投票给 udacicola
不过另一个问题在这里 这段代码有一个错误
原因是 记得我说过的 udacicolaVvotes
存在或它的作用域开始于这里
在 voteudacicola 方法的最后
它被废除了 它不存在了
意味着当我回到这 udacicolaVotes 已经不存在了
更深技术层面 我们说这个变量不在作用域内
它的作用域在这 它声明在这 它在这结束
我们试着把它用在这
它不能使用
在这个例子里将 udacicolaVotes 定义为局部变量是不正确的决定
我把它总结为这两点
它在两次点击按钮之间不能保存票数 并且对于显示 Votes 方法
不是在作用域里
所以这会引起错误
这不能被编译
好的 让我们看看这个程序的另一个变量
我要問你的第一件事情是
udacicolaVotes是一個區域變數還是全域變數
你應該確定它是一個區域變數
為了弄清楚這一點 請轉至宣告這個變數的位置
就是在這里 你知道我們已經宣告這個變數 因為在這里資料類型是正確的
你可以看到它是在一個方法內宣告的 這是在兩個花括號之間
還是在方法之外宣告的呢
如果是在方法內部宣告的
那就是一個區域變量
我們可以看得很清楚 它是在方法內宣告的
因此它是一區域變數
這意味著什么呢
我們應該問我們自己
如果聲明為區域變數 將會得到什么
以這個例子 我們來思考
這是我們的電話
我們討論的是udacicola
當我們按一下udacicola按鈕時
當我們按一下這個按鈕時 這個方法開始執行
它把udacicolaVotes投票數設定為0 然后加一到udacicolaVotes
后者是0
因此udacicolaVotes變成1
因為udacicolaVotes是一個區域變量 位于這個方法的末尾
它實際上會消失 或者刪除
在這個方法的末尾 udacicolaVotes會被作為垃圾處理或消失
因為它是一個區域變數 而造成一些問題
為什么這是一個問題呢
你可以想像一下 有三個不同的人按一下按鈕
為udacicola投票 udacicolaVvotes應該是三
實際上的情況是 你第一次按下按鈕時
udacicola變成0
然后加一 變成一
然后被作為垃圾被回收
從而不再存在
一個人第二次按udacicolaVotes時
就重新產生udacicolaVotes
并再次宣告
請記住 在第一次按下按鈕時 它已經被作為垃圾回收
因此需要重新創建
在它處于保留狀態時 它被設定為零
現在我們再次將它加一 但是請記住值是零
因此udacicolaVotes仍然是一 盡管按鈕被按下兩次
第三次按下時 發會生同樣的事情
它仍然是一 在此方法結束時它實際作為垃圾回收
這是第一個問題
在兩次按擊之間 并沒有累計
有多少人為udacicola投票
這里的另一個問題是 此代碼實際上會拋出錯誤
原因是 前面我說過
udacicolaVotes在這里出現 它的范圍啟始于這里
在這個voteudacicola方法的末尾
它作為垃圾被回收 從而不再存在
這意味著在這里udacicolaVotes實際上不存在
更具體地說 這個變數已經超出范圍
它的范圍是這里 在這里宣告 在這里結束
但是我們嘗試在這里使用它
它不能被使用
在這個例子中 把udacicolaVotes設為區域變數不是一個正確的決定
原因有兩點
第一 在兩次按下按鈕之間它沒有保存投票數
第二 它不在演示性投票計數方法的范圍之內
因此它實際上會造成問題
這將不會被編譯
讓我們來看程式中的另一個變數