First we're going to modify
the calculatePrice method signature
to have the correct return data type.
We're also going to assume that
there's 0 input parameters.
This is where the calculatePrice
method is defined.
The purpose of this method is to
calculate the total price of the order
and then return that.
The price should be an integer so
we should change the return
data type from void to int.
That takes care of the first task.
The quiz also said to make sure that
there's no input parameters, and
that's what we have here.
Now the second task is to
modify the inside of the method
to make sure that we're computing
the correct price for the order.
And assuming $5.00 for a cup of coffee.
Inside this method we're taking
the quantity of cups ordered.
And we're multiplying it
by $5 per cup of coffee.
This equals the total order price.
So this line of code is cracked.
But there's two issues that I see,
the variable price is never used and
there's an error that says
missing return statement.
It's expecting us to return an integer,
but we're not returning anything.
Right now our code is the same
as if we just said this.
We need a line that says return and
then actually put a value here and
the value on return is a price.
So, I'm just going to put price,
which is a variable we defined up here.
Cool, so now all the errors go away.
We should also modify the Java DOC.
So that we specify that we're
turning the total price.
That way when someone's calling this
method, they know what to expect.
Okay, so now we finished all
the parts for defining this method.
Now, let's move on to where
the method is getting called.
Within the submitOrder method, we
should call the calculatePrice method.
Currently calculate price,
is floating in the middle of nowhere.
I'm going to copy it, and
I'm going to paste it up here.
Because before we would calculate
the price of the order in line,
in the submit order method, but
now we have a method for it.
So I'm going to paste this here.
Now get rid of the extra semicolon.
You'll notice that price is a local
variable in this method, and
also in this method.
It's okay if they have the same name,
because these are different
variable scopes.
So the price variable here is totally
unrelated with the variable here.
They're updated and
created independently from each other.
And once this method finishes executing,
this price variable is gone.
Okay back to our submitOrder method.
So we calculated a price and
stored it in a variable, and then we
can use it to create the price message.
So, actually,
all of this code can stay the same.
We're concatenating the integer,
price, to the string total
with the currency symbol.
Then we concatenate "Thank you!" and
then just display it on the screen.
So I'm going to erase these extra,
blank lines, and save it, and
then we can run it on our device.
Okay, so I changed the quantity, and
hit ORDER, then it correctly
shows $25 as the price.
Awesome, it worked.
But how can I be sure that
calculatePrice is actually
working because there's no user visible
change compared to our app from before.
Here are a couple of techniques that
you can do to verify that your code is
actually running.
I could have it return a really
crazy number, like 700.
Save my code and then run it.
Now what I expect to see is
if I change the quantity and
hit the ORDER button,
it should saw that the price is $700.
That way I'll know that this calculate
price method is actually getting called.
And it does, cool.
Now I can revert this change.
Another way to check that this
method is getting executed
is to add a break point here.
So I'm going to click on
this little bug icon and
then our apple enter debug mode.
If I change the quantity and
I hit order, then I expect that
the app will pause at this point.
And it does.
So now we're in
the calculate price method.
There is a global variable, quantity.
And if I step over to the next line then
I see that there's now a local variable,
price And it's set to be $15 because
quantity is 3, 3 times 5 is 15, cool.
So, it's going through
the calculated price method, and
if I hit Resume,
then it updates properly on this screen.
سنقوم أولاً بتعديل توقيع طريقة
calculatePrice
لكي يكون لدينا النمط الصحيح
للبيانات المعادة
سنفترض أيضاً أن هناك 0 وسيط دخل
هذا هو المكان الذي يتم فيه
تعريف طريقة calculatePrice
الهدف من هذه الطريقة هو حساب السعر
الإجمالي للطلب
ثم إعادة ذلك
يجب أن يكون السعر من
النمط int
علينا أن نغير نمط البيانات المعادة من void
إلى النمط int
وبذلك أنجزنا الوظيفة الأولى
مكتوب في السؤال أيضاً أن نتأكد
من أنه لا توجد وسائط دخل
و هذا ما لدينا هنا
الآن الوظيفة الثانية هي أن نعدل
داخل الطريقة
للتأكد من أننا حسبنا السعر
الصحيح للطلب
وعلى افتراض 5,00$ لفنجان من القهوة
داخل هذه الطريقة نقوم بأخذ كمية
الفناجين المطلوبة
وسنضربها بـ 5$ لكل فنجان قهوة
وهذا يساوي سعر الطلب الإجمالي
بالتالي سطر الكود هذا صحيح
ولكني أنتبه إلى وجود قضيتين، متحول
price لم يتم استخدامه أبداً
و هناك خطأ يقول أمر معاد مفقود
إنه يتوقع منا أن نعيد نمط int، ولكننا
لا نعيد أي شيء
الآن الكود الذي لدينا هو نفسه كما لو أننا
نحن بحاجة إلى سطر يقول معاد ثم عملياً
نضع قيمة هنا
القيمة المعادة هي السعر
لذا سأقوم بوضع price، وهو المتحول
الذي حدَدناه في الأعلى هنا
رائع، إذاً الآن تم إزالة كل الأخطاء
يجب أيضاً أن نعدَل Javadoc
بحيث نحدد أننا نغير السعر الإجمالي
بهذه الطريقة عندما يستدعي أحد ما
هذه الطريقة، سيعرف ما سيتوقعه
حسناً، لقد أنهينا الآن جميع التفاصيل
اللازمة لتحديد هذه الطريقة
الآن، دعونا ننتقل إلى استدعاء الطريقة
في الطريقة submitOrder، يتعين علينا
أن نستدعي طريقة calculatePrice
حاليا" calculatePrice تتوضع
في مكان غير ملائم
لذا سأقوم بنسخه، ومن ثم سألصقه هنا
لأنه قبلاً كنا نحسب سعر الطلب في السطر
في طريقة submitOrder
ولكن الآن لدينا طريقة لذلك
لذلك سأقوم بلصق هذا هنا
الآن سأتخلص من
الفاصلة المنقوطة الإضافية
ستلاحظ أن price هو متغير محلي
في هذه الطريقة
وفي هذه الطريقة أيضاً
لا بأس إذا كان لديهما نفس الاسم
لأن هذه نطاقات مختلفة للمتحول
لذلك المتحول price هنا ليس
له مع المتحول هنا
لقد تم تحديثهما وإنشائهما بشكل
مستقل عن بعضهما البعض
وحالما تُنهي هذه الطريقة التنفيذ
فإن المتحول price سيختفي
حسناً نعود إلى طريق submitOrder
إذاً لقد حسبنا السعر
و حفظناه في متحول، وبعد ذلك نستطيع
استخدامه لإنشاء رسالة السعر
لذلك، في الواقع، كل هذا
الكود يمكن أن يبقى نفسه
نحن نوصل النمط الصحيح
السعر، إلى مجموع السلسلة
المحرفية مع رمز العملة
ثم نوصل "!Thank you" وبعد ذلك
فقط نعرضه على الشاشة
لذلك سأقوم بمحو هذه، الأسطر الفارغة
الإضافية، و سأحفظه
وبعد ذلك يمكننا تشغيله على الجهاز لدينا
حسناً، لقد غيرت الكمية
سأضغط "Order" وبعد ذلك
يظهر بشكل صحيح السعر 25 $
رائع، لقد نجحت
ولكن كيف يمكنني التأكد
أن calculatePrice
يعمل عملياً لأنه ليس هناك تغيير ملحوظ
للمستخدم مقارنة مع التطبيق من قبل
هنا بعض التقنيات التي يمكنك
القيام بها للتحقق من أن الكود
يعمل فعلاً
يمكن أن أجعله يعيد رقم مجنون
حقا، مثل 700
سأحفظ الكود الذي لدي ثم سأشغله
الآن ما أتوقع أن أرى إذا ما
قمت بتغيير quantity
اضغط على زر "Order" ينبغي أن
رأى أن السعر هو 700$
بهذه الطريقة سأعرف أن طريقة حساب
السعر هذه يتم إستدعائها بشكل فعلي
و قد تم ذلك، رائع
الآن يمكنني التراجع عن هذا التغيير
وهناك طريقة أخرى للتحقق
من أن هذه الطريقة يتم تنفيذها
هو إضافة نقطة فاصلة هنا
لذلك سأقوم بالنقر على
هذه الأيقونة الصغيرة
ثم سيدخل تطبيقنا في وضع التصحيح
إذا قمت بتغيير الكمية
وضغطت "Order" ثم أتوقع أن التطبيق
سوف يتوقف عند هذه النقطة
وهو يقوم بذلك
إذا الآن نحن في طريقة
calculatePrice
هناك متغير عام quantity
وإذا انتقلت إلى السطر التالي سأرى أن
هناك الآن متغير محلي
price وتم ضبطه على أن يكون 15$ لأن
quantity قيمتها 3 ، 3 مضروبة 5 هو 15 رائع
لذلك من خلال
طريقة calculatePrice
لو ضغطت "Resume" فإنه يقوم بالتحديث
بشكل صحيح على هذه الشاشة
Primero vamos a modificar
la firma del método calculatePrice
para tener el tipo de dato
de retorno correcto.
También asumiremos que
hay 0 parámetros de entrada.
Aquí es donde se define
el método calculatePrice.
El propósito de este método es
calcular el precio total del pedido
y luego retornarlo.
El precio debe ser un número entero
así que debemos cambiar
el tipo de dato de retorno
de void a int.
Esto cumple la primera tarea.
El cuestionario también pedía asegurarse
de que no haya parámetros de entrada,
y eso es lo que tenemos aquí.
Ahora, la segunda tarea es
modificar el interior del método
para asegurarse de que estamos calculando
el precio correcto para la orden.
Y suponiendo $5 por una taza de café.
Dentro de este método estamos tomando
la cantidad de tazas ordenada.
Y la multiplicamos
por $5 por cada taza de café.
Esto es igual al precio total del pedido.
Así que esta línea de código es correcta.
Pero hay dos cuestiones que veo:
la variable price nunca se utiliza
y hay un error que dice
"falta la sentencia return".
Espera que retornemos un número entero,
pero no estamos retornando nada.
Ahora mismo nuestro código
es lo mismo que decir esto.
Necesitamos una línea que diga return
y poner un valor aquí
y el valor de retorno es un precio.
Así que, voy a poner price,
que es una variable
que hemos definido aquí.
Genial, ahora
todos los errores desaparecen.
También debemos modificar el Javadoc
para especificar que estamos
retornando el precio total.
Para que cuando
alguien llame este método
sepa qué esperar.
Bien, ahora terminamos todas
las partes para definir este método.
Ahora, pasemos a donde
el método es llamado.
Dentro del método submitOrder,
debemos llamar al método calculatePrice.
Actualmente calculatePrice,
está flotando en el medio de la nada.
Voy a copiarlo,
y voy a pegarlo aquí.
Porque antes calculábamos
el precio de la orden en línea,
en el método submitOrder,
pero ahora tenemos un método para ello.
Así que voy a pegar esto aquí.
Ahora eliminamos el punto y coma sobrante.
Notarás que price es una variable local
en este método,
y también en este método.
Está bien si tienen el mismo nombre,
porque son diferentes
ámbitos de variables.
Entonces esta variable price
no tiene ninguna relación
con la variable de aquí.
Se actualizan y se crean
de manera independiente.
Luego de que este método
termina de ejecutarse,
esta variable price desaparece.
Bien, volvamos al método submitOrder.
Calculamos un precio
y lo almacenamos en una variable,
y luego podemos usarlo
para crear el mensaje de precio.
Así que, en realidad, todo este código
puede permanecer igual.
Estamos concatenando
el número entero price,
con el string "Total"
con el símbolo de moneda.
Luego concatenamos "¡Thank you!"
y después se lo mostrará en la pantalla.
Entonces borraré estas
líneas de más en blanco, lo guardaré,
y luego podemos ejecutarlo
en nuestro dispositivo.
Bien, entonces cambié la cantidad
y pulsé Order, entonces correctamente
muestra $25 como el precio.
Impresionante, funcionó.
Pero, ¿cómo me aseguro
de que calculatePrice está funcionando?
porque no hay un cambio visible
para el usuario
en comparación
con nuestra aplicación anterior.
Aquí hay un par de técnicas
que puedes realizar
para comprobar la ejecución de tu código.
Podría retornar un número
disparatado, como 700.
Guardar mi código y luego lo ejecuto.
Ahora lo que espero ver es que
si cambio la cantidad
y pulso el botón Order,
debería ver que el precio es $700.
De esa manera sabré
que el método calculatePrice
realmente es llamado.
Y así es, genial.
Ahora puedo revertir este cambio.
Otra forma de comprobar
que este método se ejecuta
es añadir un punto de interrupción aquí.
Así que haré clic en
este pequeño icono bug
y la aplicación entra
en modo de depuración.
Si cambio la cantidad
y pulso Order, espero que la aplicación
se detenga en este punto.
Y lo hace.
Así que ahora estamos
en el método calculatePrice.
Hay una variable global, quantity.
Y si paso a la siguiente línea
veo que ahora hay
una variable local, price,
y tiene fijado $15, porque quantity es 3,
y 3 por 5 es 15, perfecto.
Por lo tanto, está pasando
por el método calculatePrice
y si pulso Resume,
lo actualiza correctamente
en esta pantalla.
Tout d’abord, on va modifier la
méthode de signature de calculatePrice
pour avoir le type de données de retour exact.
On va aussi assumer
qu’il y a 0 paramètre d’entrée.
C’est ici que la méthode du
calculatePrice est définie.
Le but de cette méthode est de
calculer le prix total de la commande
et ensuite de le renvoyer.
Le prix doit être un entier donc,
on doit changer le type de données
de retour void par int.
Voilà pour la première tâche.
Le quiz stipule aussi de faire attention
à ce qu’il n’ait pas de paramètre d’entrée,
c’est ce qu’on a ici.
Maintenant la deuxième tâche consiste à
modifier le contenu de la méthode
pour être sûr qu’on calcule
le prix exact de la commande.
Si la tasse de café est à 5,00$.
À l’intérieur de cette méthode, on met
la quantité de tasses commandées.
Et nous la multiplions par
5$ par tasse de café.
Ça équivaut au prix total de la commande.
Donc cette ligne de code est déchiffrée.
Mais je peux voir deux problèmes, la
variable de prix n’est jamais utilisée et
il y a une erreur qui dit qu’il y a
une instruction de retour manquante.
Il s’attend à ce qu’on lui renvoye un
entier, mais on ne renvoye rien.
Pour l’instant, notre code est tel
qu’on vient de le dire.
On a besoin d’une ligne qui dit retour et,
en faite, puis, mettre une valeur ici et
la valeur de retour est un prix.
Donc, je vais simplement mettre prix, qui
est une variable qu’on a définie plus haut.
Cool, donc, maintenant, toutes les erreurs
ont disparu.
On devrait aussi modifier le Java DOC.
Ainsi on précise qu’on
retourne le prix total.
Ainsi lorsque quelqu’un appelle cette
méthode, ils savent à quoi s’attendre.
Ok, donc, on a terminé toutes
les étapes pour définir cette méthode.
Maintenant, passons là
où la méthode se fait appeler.
Depuis la méthode submitOrder, on
devrait appeler la méthode calculatePrice.
À présent, calculatePrice,
se promène au milieu de nulle part.
Je vais le copier, et
je vais le coller ici en haut.
Parce qu’avant on aurait dû calculer
le prix de la commande dans la ligne,
dans la méthode du submitOrder, mais
maintenant, on a une méthode pour ça.
Donc je vais copier ceci ici.
Maintenant, débarrassez-vous du
point-virgule supplémentaire.
On peut remarquer que le prix est une
variable locale dans cette méthode, et
aussi dans cette méthode.
Ça n’est pas un problème si
elles ont le même nom,
car elles ont des portées de
variables différentes.
Donc, la variable de prix ici est tout à
fait indépendante de la variable ici.
Elles sont actualisées et créées
indépendamment l’une de l’autre.
Une fois que cette méthode a terminé son
exécution, cette variable de prix disparait.
Ok retournons à notre méthode de submitOrder.
Donc, on calculoe un prix et
on le stocke dans une variable, puis on
peut l’utiliser pour créer un message prix.
Donc, vraiment,
tout ce code peut rester le même.
On assemble l’entier,
le prix, à la chaîne de caractères totale
avec le symbole de la monnaie.
Ensuite on assemble « Thank you ! » et
ensuite affichez-le sur l’écran.
Donc, je vais supprimer ces lignes vides,
superflues, et les sauvegarder, et
ensuite on peut l’exécuter sur notre appareil.
Ok, donc je change la quantité, et
j’appuie sur ORDER, ensuite il montre
correctement 25$ comme prix.
Génial, ça marche.
Mais comment puis-je être sur que
calculatePrice fonctionne
vraiment, car il n’y a pas de changement
avec l’application d’avant pour l’utilisateur.
Voici quelques techniques que vous pouvez
utiliser pour vérifier que votre code
fonctionne vraiment.
Je pourrais lui demander de renvoyer
un nombre incroyable, comme 700.
Sauvegarder mon code et ensuite l’exécuter.
Maintenant, ce que je m’attends à voir
si je change la quantité et
que j’appuie que le bouton ORDER,
on devrait voir que le prix est 700$.
De cette façon je saurais que cette méthode
calculatePrice est réellement appelée.
Et ça l’est, cool.
Maintenant, je peux inverser ce changement.
Une autre façon de vérifier que cette
méthode est exécutée
est d’ajouter un point de rupture ici.
Donc, je vais cliquer sur
cette petite icône de bug et
ensuite notre apple entre dans le
mode débug.
Si je change la quantité et
que j’appuie sur order, je m’attends à
ce que l’application fasse une pause là.
Et elle la faite.
Donc, maintenant on est dans
la méthode de calculatePrice.
Il y a une variable globale, la quantité.
Et si je passe à la ligne suivante puis,
je vois qu’il y a une variable locale,
le prix. Et il est établi à 15$ car
la quantité est de 3, 3 fois 5 font 15, cool.
Donc, ça passe par la
méthode de calculatePrice, et
si j’appuie sur Resume, ensuite
il s’actualise correctement sur l’écran.
Pertama kita akan memodifikasi
metode tanda tangan calculatePrice
untuk memiliki tipe data yang benar.
Kita juga akan berasumsi
bahwa ada 0 parameter masukan.
Di sinilah metode
calculatePrice didefinisikan.
Tujuan dari metode ini adalah
untuk menghitung harga total order
dan kemudian mengembalikannya.
Harganya harus dalam bilangan bulat
jadi kita harus mengubah kembali
tipe datanya dari batal ke bilangan bulat.
Itu sudah menyelesaikan tugas pertama.
Kuis juga mengatakan untuk memastikan
bahwa tidak ada parameter masukan,
dan itulah apa yang kita miliki di sini.
Sekarang tugas kedua adalah
memodifikasi bagian dalam metode
untuk memastikan kita menghitung
harga order yang benar.
Dan berasumsi lima dolar
untuk secangkir kopi.
Di dalam metode ini,
kita mengambil order kuantitasnya.
Dan kita mengalikannya
sebesar lima dolar per cangkir kopi.
Ini sama dengan harga total order.
Jadi baris kode ini retak.
Tapi ada dua hal yang saya lihat,
harga variabel yang tak pernah digunakan,
dan ada kesalahan yang mengatakan
hilang pernyataan kembali.
Hal ini harapkan kita untuk
kembalikan bilangan bulat,
tapi kita tidak mengembalikan apa pun.
Sekarang kode kita sama dengan
seolah-olah kita hanya mengatakan ini.
Kami membutuhkan baris
yang mengatakan kembali,
dan kemudian memberikan nilai di sini.
Nilai pada saat mengembalikan
adalah harga.
Jadi, saya hanya akan menempatkan harga,
yang merupakan variabel
yang kita definisikan di sini.
Keren, sekarang semua galat
sudah tidak ada.
Kami juga harus memodifikasi DOC Java.
Sehingga kita menentukan
bahwa kita mengubah total harga.
Dan saat seseorang memanggil metode ini,
mereka tahu apa yang diharapkan.
Oke, sekarang kita sudah selesai
dalam mendefinisikan metode ini.
Sekarang, mari kita beralih
ke tempat metode ini dipanggil.
Dalam metode submitOrder, kita
harus memanggil metode calculatePrice.
Saat ini calculate price,
mengambang di tempat yang tidak jelas.
Saya akan menyalinnya,
dan saya akan menyisisipkan di sini.
Karena sebelum kita akan menghitung
harga order yang sesuai,
dalam metode submitOrder,
tapi sekarang kita punyai metodenya.
Jadi saya akan menempelkannya di sini.
Sekarang menyingkirkan titik koma ekstra.
Kau akan menyadari bawah harga
adalah variabel lokal dalam metode ini,
dan juga dalam metode ini.
Tak masalah jika mereka
punya nama yang sama,
karena ini adalah
lingkup variabel yang berbeda.
Jadi variabel harga di sini tidak
berhubungan dengan variabel sini.
Mereka diperbarui dan dibuat
secara independen satu sama lain.
Setelah metode ini selesai mengeksekusi,
maka variabel harga ini hilang.
Oke, kembali ke metode submitOrder kita.
Jadi kita menghitung harganya
dan menyimpannya dalam variabel,
dan kemudian kita dapat
menggunakannya untuk membuat priceMessage.
Jadi, sebenarnya,
semua kode ini dapat tetap sama.
Kami menyatukan harga bilangan bulat,
untuk string Total
dengan simbol mata uang.
Kemudian kita menggabungkan
Thank you!
dan kemudian menampilkannya di layar.
Jadi saya akan menghapus baris
kosong tambahan ini dan menyimpannya,
dan kita dapat menjalankannya
pada perangkat kita.
Oke, saya sudah mengubah kuantitasnya,
menekan ORDER, maka dengan benar
menunjukkan 25 dolar sebagai harga.
Luar biasa, itu bekerja.
Tapi bagaimana saya bisa yakin
bahwa calculatePrice sebenarnya bekerja,
karena tak ada perubahan yang terlihat
dibandingkan dengan aplikasi sebelumnya.
Ini beberapa teknik yang dapat kaulakukan
untuk memverifikasi bahwa kodemu bekerja.
Saya bisa memasukkan
angka yang gila, seperti 700.
Menyimpan kode saya
dan kemudian menjalankannya.
Yang saya harapkan untuk dilihat adalah
dengan mengganti kuantitasnya,
dan menekan tombol ORDER
itu seharusnya terlihat
kalau harganya 700 dolar.
Dengan begitu saya mengetahui
bahwa metode calculatePrice ini
sebenarnya sedang dipanggil.
Dan itu terjadi, keren.
Sekarang saya dapat
mengembalikan perubahan ini.
Cara lain untuk memeriksa
bahwa metode ini sedang dieksekusi
adalah dengan menambahkan
titik istirahat di sini.
Saya akan mengklik
tanda serangga kecil ini,
kemudian apel kami masuk ke modus debug.
Jika saya mengubah
kuantitasnya dan menekan order
maka saya berharap bahwa
aplikasi akan berhenti pada titik ini.
Dan ternyata memang berhenti.
Jadi sekarang kita berada
di metode calculatePrice.
Ada variabel global, kuantitas.
Dan jika saya melangkah
ke baris berikutnya
kemudian saya melihat bahwa
sekarang ada variabel harga lokal,
dan sudah diatur menjadi 15 dolar
karena kuantitasnya adalah 3,
3 kali 5 adalah 15, keren.
Jadi, itu akan melalui
metode calculatePrice,
dan jika saya menekan Lanjutkan,
maka akan diperbarui
dengan benar pada layar ini.
では初めにcalculatePrice
メソッドの署名を変更して
正しい戻り値の型になるようにします
また 0 の入力パラメーターがある
と想定します
これが calculatePrice
メソッドを定義するところです
このメソッドの目的は注文の合計金額を計算し
その値を返すことです
価格は整数でなければならないので
voidからintに
戻り値の型を変更する必要があります
これが最初のタスクになります
入力パラメーターがないことを確認します
これがここにあるものです
入力パラメーターがないことを確認します
これがここにあるものです
2番目のタスクはメソッドの内部の変更です
注文に対して正しい値を
計算しているかどうか確認します
一杯のコーヒーが$5.00であるとします
このメソッドの中に
注文された数量をいれます
それに1 杯当たり $ 5 の
コーヒーを掛けます
これが注文の合計価格に相当します
このコードラインは割れています
ここで2つの問題がみられます
可変価格が使われていないことと
戻り値がありませんというエラーです
整数を返すことを要求していますが
何も返していないわけです
今コードは先程言った通りになっています
ラインが値を返すようにし
実際にここに値を入力すると
返された値は価格になります
それでは ここで定義した変数である
値を入力してみましょう
さあ これで全てのエラーが消えました
Java ドキュメントも
変更する必要があります
それによって
合計価格を出すように指定します
これで誰かがこのメソッドを呼び出す時
何が実行されるのかが分かります
これでこのメソッドの定義は全て終了しました
ではメソッドを呼び出すところに移りましょう
SubmitOrder メソッドの中の
calculatePrice メソッドを呼び出します
現在 calculatePrice は
こんなところに表示されてしまっています
これをコピーして
ここにベーストします
以前は ラインのSubmitOrder
メソッドで注文価格を計算していましたが
今はそのためのメソッドがあります
ではここに貼り付けます
この余分なセミコロンは消去します
このメソッドでは 価格は
ローカル変数であることに気がつくでしょう
そしてこのメソッドでも
同じ名前であれば それで大丈夫です
なぜなら これらは
異なるVariableスコープだからです
この価格の変数は完全に
この変数とは無関係です
それらは更新され
お互いに独立して作成されます
いったんこのメソッドの実行が完了すると
この価格変数はなくなります
では submitOrder メソッドに
戻りましょう
価格を計算して
変数として保存すると
価格メッセージの作成に使用できます
これで実際に
このコードの全ては同じままになります
この整数
価格 文字列の合計を通貨記号と連結します
そして"Thank you!"と連結して
画面にそれが表示されるようにします
これらの余分な部分
空白行を消去してそれを保存すると
デバイスで実行できるようになります
では数量を変更して
ORDERを押してみましょう
価格が正しく $25 と表示されます
これでうまくできました
どうすればcalculatePrice が
実際作動しているか確認できるのでしょうか
以前のアプリと比較した際の変化が
ユーザーには見えません
ここでは2つの技法で
コードが実際に機能していることを
確認します
700 のようなちょっとおかしい数を
戻すのを試してみましょう
コードを保存しそれを実行します
さあこれでどうでしょう
数量を変更して
ORDERボタンを押した場合
価格が $700 と表示されるはずです
calculatePrice メソッドが
実際に呼び出されているかこれで確認できます
ちゃんとこのようになりました
ではこの変更を戻しましょう
このメソッドが実行されていることを
確認する別の方法は
ここにブレークポイントを追加することです
それでは この小さなバグのアイコンを
クリックして
アップルでデバッグ モードを入力します
数量を変更して
注文を押した場合
この時点でこのアプリは一時停止するはずです
さあ停止しました
これは calculatePrice
メソッドが使われています
グローバル変数 数量があります
次のラインをまたいだ場合
ローカル変数 価格がでてきます
価格が $15 に設定されています 数量が
3 なので3×5で 15 というわけです
calculatePrice
メソッドを使用すると
Resumeを押すと
この画面で正しく更新します
우선 calculatePrice 메소드 서명을
수정할 거예요.
리턴 데이터 유형을 수정하기 위해서죠.
그리고 입력 파라미터가 0개라고
가정할 거예요.
calculatePrice 메소드는
여기서 정의됩니다.
이 메소드의 목적은 주문 가격
합계를 계산하여
리턴값으로 내놓는 겁니다.
가격은 정수형이어야 하니까
리턴 데이터 유형을 void에서
int로 바꿔야 겠죠.
그러면 첫번째 과제는 해결됩니다.
과제에서는 입력 파라미터를
0개로 하라고 했었죠.
그 부분도 해결했습니다.
두 번째 과제는
메소드 내부를 수정하여
주문 가격을 올바로 계산하도록
만들라는 것이었는데요.
커피 한 잔은 5달러로 가정하고 말이죠.
메소드 내부에서는
주문한 커피의 잔 수를 받아들여.
한 잔 당 가격인 5달러를
거기에 곱합니다.
그렇게 하면 가격 합계가 나오겠죠.
이렇게 코드를 분석해 보았습니다.
하지만 두 가지 문제가 보이네요.
'price'라는 변수가 사용되지 않았다,
그리고 리턴 문이 보이지 않는다는
오류 메세지가 뜹니다.
여기를 보면 정수값을 리턴해야 하는데
실제로는 아무 것도 리턴하고 있지 않네요.
지금 우리가 보는 코드는
이미 말씀드린 그대로입니다.
한 줄이 더 필요하겠네요. 리턴이라고
우선 정의한 후 리턴값을 입력해야 겠죠.
리턴값은 물론 가격이 될 테고요.
그래서 여기 'price'라고 입력합니다.
위에 정의한 대로 말이죠.
좋아요. 이제 오류는 전부 수정했군요.
자바 doc도 수정해야죠.
가격 합계를 출력한다는 사실을
명시하도록 하기 위해서요.
이렇게 하면 누가 이 메소드를 호출해도
그 내용을 이해할 수 있게 됩니다.
좋아요, 이제 이 메소드 정의 부분은
다 끝마쳤습니다.
그럼 이제 메소드가 호출되는 부분으로
가보도록 하죠.
submitOrder 메소드에서
calculatePrice 메소드를 호출해야 합니다.
현재로선 calculate price가
목적지 없이 붕 떠있는 상태죠.
이걸 복사한 후,
여기에 붙여넣겠습니다.
이전에는 주문 가격 계산을
submit order 메소드 내에서 했지만
지금은 계산용 메소드가 있으니까요.
그래서 이걸 여기에 붙여녛겠습니다.
남는 세미콜론은 지우고요.
이제 보시다 시피 가격은 이 메소드
안의 로컬 변수이고
여기서도 마찬가지입니다.
이름은 같아도 상관 없어요.
변수 영역이 다르기 때문이죠.
여기 가격 변수는
여기와는 전혀 무관합니다.
업데이트 및 생성도 서로와 전혀
상관 없이 이루어지죠.
메소드가 수행을 마치면
이 가격 변수는 사라집니다.
submitOrder 메소드로 돌아왔어요.
가격을 계산하고 변수 형태로
저장했으니, 이제 이걸 사용해서
가격 메시지를 만들 수 있습니다.
여기 코드 전부는 그냥 놔둬도 됩니다.
정수값인 가격을 달러 기호를 써서
'합계'라는 문자열에 연결할 거예요.
그리고 "감사합니다!"까지 연결시켜
스크린에 출력하는 거죠.
여분의 빈 라인을 제거하고
저장한 다음,
기기에서 실행시켜 보죠.
좋아요, 수량을 바꾸고 '주문'을 누르면
정확히 25달러라고 가격이 표시되네요.
대단해요. 제대로 만들었네요.
하지만 실제로 calculatePrice이
제대로 작동하는 지 어떻게 알 수
있을 까요. 사용자 입장에선 이전에
비해 딱히 달라진 게 안 보이는데 말이죠.
여러분이 만든 코드가
제대로 작동하는지 검증할 수 있는
몇 가지 방법이 있습니다.
700 같이 말도 안되는 수치를
리턴값으로 설정해 볼 수 있어요.
코드 저장 후 실행시킵니다.
이제 확인해 보죠.
수량을 바꿔서 입력한 후
주문 버튼을 누르면, 가격이
700달러로 나오는 걸 볼 수 있네요.
메소드가 올바로 호출되고 있는지를
이렇게 확인할 수 있습니다.
제대로 호출되고 있네요. 좋아요.
이제 바꿨던 내용을 되돌릴께요.
이 메소드가 제대로 수행중인지
확인할 수 있는 또 한 가지 방법은
이 부분에서 중단점을 설정하는 거죠.
여기 작은 버그 아이콘을 클릭해서
디버그 모드로 들어가 보겠습니다.
이제 수량을 바꿔서 주문을 클릭하면
앱이 이 지점에서 멈출 거예요.
그렇게 되었네요.
이제 calculate price 메소드에
들어왔습니다.
글로벌 변수인 수량이 있고요.
다음 라인으로 넘어가면
가격이라는 로컬 변수가 보이네요.
수량이 3이므로 3 곱하기 5는 15,
따라서 15 달러로 맞춰졌네요. 좋아요.
calculated price 메소드는
이렇게 작동하여
'계속'버튼을 누르면
스크린 상에 제대로 업데이트합니다.
Primeiro, vamos modificar
a assinatura do método calculatePrice
para receber o tipo correto
de dados de return.
Também vamos presumir que
há zero parâmetros de input.
É aqui que o método
calculatePrice é definido.
O propósito deste método
é calcular o preço total do pedido
e depois retornar ele.
O preço deve ser um integral,
então precisamos mudar
o tipo de return de void pra int.
Isso cuida da primeira tarefa.
O questionário também pede para verificar
se não há parâmetros de input,
e é isso que temos aqui.
A segunda tarefa é
modificar o conteúdo do método
para certificar-nos de que estamos
computando o preço correto.
E presumindo $5.00
por uma xícara de café.
Dentro deste método estamos pegando
a quantidade de xícaras pedida.
E a estamos multiplicando
por $5 por xícara.
Isso equivale ao preço total.
Então esta linha está resolvida.
Mas há duas questões que vejo,
o preço variável nunca é usado
e há um erro que diz
que falta a instrução de return.
Ele espera que nós retornemos uma integral
mas não estamos retornando nada.
Neste momento, nosso código
é o mesmo que se nós tivéssemos dito isto.
Precisamos de uma linha que diga return
e então colocar um valor aqui
e o valor em return é um preço.
Então, vou apenas colocar o preço,
que é uma variável definida aqui.
Legal, agora todos os erros desaparecem.
Também devemos modificar
o Java DOC.
Para especificarmos
que estamos mudando o preço total.
Desta forma, quando alguém
chamar este método, saberão o que esperar.
Certo, então terminamos
todas as partes para definir este método.
Agora, vamos prosseguir para
onde o método está sendo chamado.
Dentro do método submitOrder,
precisamos chamar o método calculatePrice.
No momento, calculatePrice
está flutuando no meio do nada.
Vou copiá-lo, e vou colá-lo aqui em cima.
Porque antes podíamos calcular
o preço do pedido em linha,
no método submitOrder,
mas agora temos um método pra isso.
Então vou colar isto aqui.
Agora livre-se do ponto-e-vírgula extra.
Você notará que preço
é uma variável local neste método,
e também neste.
Tudo bem se elas têm o mesmo nome,
porque são
escopos de variáveis diferentes.
Então a variável price aqui
não é relacionada com a variável aqui.
Elas são atualizadas e criadas
independentemente uma da outra.
E uma vez que este método termine
de ser executado, a variável price some.
Voltando a nosso método submitOrder.
Então, calculamos um preço
e guardamos em uma variável, aí podemos
usá-lo para criar a mensagem de preço.
Então, na verdade,
todo o código pode continuar o mesmo.
Estamos concatenando a integral price
para a string total
com o símbolo de moeda.
Então concatenamos "Obrigado!"
e apenas o mostramos na tela.
Então vou apagar essas linhas extras,
em branco, e salvar,
e podemos rodá-lo em nosso aparelho.
Certo, então mudei a quantidade,
e pressionei PEDIR, e agora
ele mostra corretamente $25 como o preço.
Maravilha, funcionou.
Mas como posso ter certeza de que
calculatePrice está realmente
funcionando, já que não há
mudança visível comparando com antes?
Eis algumas técnicas que você
pode fazer para verificar se seu código
está realmente funcionando.
Eu poderia fazê-lo retornar
um número absurdo, como 700.
Salvar meu código e depois rodar.
Agora, o que espero ver
é se eu mudar a quantidade
e apertar PEDIR, deveria dizer
que o preço é $700.
Desta forma, saberei que este método
calculatePrice está sendo chamado.
E ele está, legal.
Agora posso reverter esta mudança.
Outra forma de checar
se este método está sendo executado
é colocar um breakpoint aqui.
Então vou clicar
neste pequeno ícone de bug
e então nosso aplicativo
entrará no modo debug.
Se eu mudar a quantidade
e apertar PEDIR, então espero que
o app pause neste ponto.
E ele pausa.
Então agora estamos
no método calculatePrice.
Há uma variável global, quantity
E se eu pular para a próxima linha,
vejo que agora há uma variável local,
price, e está definida para $15,
porque quantity é 3, 3 vezes 5 é 15, bom.
Então, está fazendo
pelo método calculatePrice,
e se eu apertar Continuar,
então atualiza direito nesta tela.
Сначала мы изменим сигнатуру
метода calculatePricе,
чтобы на выходе получить
данные верного типа.
Будем также считать, что
здесь 0 исходных параметров.
Вот где метод calculatePrice
определен.
Этот метод подсчитывает
общую стоимость заказа
и выдает ее.
Цена должна быть числом и поэтому
мы должны изменить тип данных на
выходе с void на int.
Так мы выполним первое задание.
В тесте также указано, что
исходных параметров нет и
вот что у нас есть.
Во втором задании нам надо
изменить алгоритм так
чтобы мы подсчитывали
верную стоимость заказа.
И считали, что чашка кофе
стоит $5.00.
Внутри алгоритма мы берем
количество заказанных чашек кофе.
И умножаем его на $5
за одну чашку кофе.
Это равняется общей цене заказа.
Эта строка кода верна.
Но я вижу две проблемы, переменная
price никогда не использовалась
и есть ошибка отсутствия
утверждения для возвратного значения.
Ожидается, что на выходе будет число,
но на выходе нет ничего.
Сейчас наш код выглядит так,
как если бы мы это сказали.
Нам нужна строка с return,
а потом надо указать значение и
значение на выходе это цена.
Поэтому я просто поставлю price,
переменную, что мы назначили здесь.
Отлично - все ошибки пропали.
Нам надо также изменить Java DOC.
Указать что на выходе
у нас total price.
Так те, кто будет вызывать метод
будут знать, что от него ожидать.
Итак, мы закончили со всеми
частями по определению метода.
Перейдем к части
где метод вызывается.
Внутри метода submitOrder
нам надо вызвать calculatePrice.
Сейчас calculate price
болтается посреди пустоты.
Я его скопирую и вставлю вот сюда.
Раньше мы бы подчитали
цену заказа в строке,
в методе submit order, но сейчас
у нас для этого есть метод.
Поэтому я вставлю его сюда.
Я уберу лишнюю точку с запятой.
Обратите внимание, что price в этом
методе это местная переменная,
а также и в этом методе.
Это нормально, что у них
одинаковые имена,
поскольку это различые
области переменных.
Поэтому переменная price совершенно
не относится к переменной здесь.
Они меняются и назначаются
независимо друг отдруга.
А после выполнения этого метода,
переменная price пропадает.
Вернемся к методу submitOrder.
Мы подсчитали цену и
сохранили в переменной, а после мы
используем ее и создадим сообщение.
Поэтому весь этот код менять не надо.
Мы объединяем число,
price, со строкой total
с символом валюты.
После мы объединяем "Thank you!"
и выводим на экран.
Я сотру эти лишние пустые
строки и сохраню, а
после мы запустим
все на устройстве.
Итак, я изменила количество и
нажала ORDER, и правильно
показана цена в $25.
Отлично, все работает.
Но как я могу быть уверена, что
сalculatePrice на самом деле
работает, ведь нет видимых изменений
по сравнению с прошлой версией.
Вот пара способов с помощью которых
вы можете убедиться, что ваш код
на самом деле работает.
Ведь можно получить на выходе
и странное число, 700 например.
Сохраните код и запустите его.
Вот что я ожидаю увидеть -
если я изменю количество и
нажму кнопку ORDER, то должна
показаться цена в $700.
Так я буду знать, что метод calculate
price на самом деле был вызван.
Так и есть, отлично.
Я отменю это изменение.
Другой способ проверить,
что алгоритм выполняется - это
добавить здесь прерывание.
Я кликну на вот эту иконку и
и наше приложение начнет отладку.
Если я изменю количество и
нажму Оrder, то приложение должно
остановиться на этом месте.
Так и есть.
Вот мы в методе сalculate price.
Вот глобальная переменная, quantity.
А если я перейду на следующую линию,
то увижу местную переменную,
price. Она установлена на $15 так как
quantity равно 3, 3 по 5 = 15, класс.
Итак, все проходит через метод
calculated price и
если я нажму Resume,
все верно отобразится на экране.
Doğru dönüş veri türünü görmek için
Ücreti Hesapla metod imzasını düzenleyeceğiz.
Aynı zamanda 0 girdi parametresi olduğunu öngöreceğiz.
Burada Ücreti Hesapla metodu tanımlanır.
Bu metodun amacı siparişin toplam fiyatını hesaplamak ve sonra
Onun dönüşünü yapmaktır.
Ücret bir tamsayı olmalıdır ki
Dönüş verisi türünü geçersizden tamsayıya değiştirebilelim.
Bu ilk görevimizi halleder.
Test aynı zamanda hiç girdi parametresi olmadığından emin olmamızı
Söylüyordu ve işte burada.
Şimdi ikinci görevimiz sipariş için doğru ücreti hesapladığımızdan
Emin olmak için metodun içini düzenlemektir.
Ve bir fincan kahve için 5 Dolar olarak öngörmektir.
Bu metodun içinde sipariş edilen bardak miktarını alıyoruz.
Ve onu bir bardak kahve için 5 Dolar ile çoğaltıyoruz.
Bu toplam sipariş ücretine eşit.
Bu kod çizgisi çatlamış.
Ama burada benim gördüğüm iki konu var; değişken ücret hiç kullanılmadı
Ve dönüş bildirimi diyen bir hata var.
Bizim bir tamsayı göndermemizi bekliyor, ama biz hiç bir şey göndermiyoruz.
Şu anda kodumuz tam da bunu demişiz gibi.
Dönüş yap diyen bir satıra ihtiyacımız var.
Ve sonra buraya bir değer koymamız lazım ve dönüş değeri bir ücret.
Şimdi ben sadece ücreti koyuyorum, bu bizim yukarıda tanımladığımız bir değişken.
Şimdi bütün hatalar gitti.
Aynı zamanda Java DOC'u da düzenlemeliyiz.
Böylece toplam ücretin dönüşünü yaptığımızı belirtmiş oluruz.
Böylece ne zaman birisi bu metodu çağırsa, ne bekleyecğini de bilir.
Tamam, şimdi bu metodu tanımlamak için tüm kısımları bitirdik.
Şimdi, metodun çağrıldığı noktaya hareket edelim.
Siparişi Gönder metodu içinde, Ücreti Hesapla metodunu çağırmamız gerekir.
Şu anda ücreti hesaplama bir boşlukta akıp durmakta.
Onu kopyalayacağım ve sonra buraya yapştıracağım.
Çünkü sıradaki siparişin ücretini hesaplamadan öncei
Siparişi gönder metodunda, ama şimdi bunun için bir metodumuz var.
Onu buraya yapıştıracağım.
Şimdi ekstra noktalı virgülden kurtulun.
Bu metodda ve bu metodda da ücretin yerel bir değişken
Olduğunu fark edeceksiniz.
İsimleri aynı olsa da sorun değil,
Çünkü farklı değişken kapsamları bulunmakta.
Buradaki ücret değişkeni buradaki değişkenle tamamen alakasız.
Bunlar birbirlerinden bağımsız olarak güncellenip oluşturuldular.
Ve bu metod çalışmayı bitirdiğinde, ücret değişkeni gitmiş olacak.
Siparişi Gönder metoduna geri dönelim.
Bir ücreti hesapladık ve
Onu bir değişkenin içine depoladık, ve sonra onu ücret mesajını oluşturmak için kullanabiliriz.
Yani aslında tüm bu kod aynı kalabilir.
Tamsayıyı ve ücreti dizi toplamına
Para birimi sembolüyle beraber bitiştiriyoruz.
Daha sonra "Teşekkür Ederiz"i bitiştiriyoruz ve sonra ekranda görüntülüyoruz.
Bu ekstra ve boş satırları sileceğim ve kaydedeceğim
Ve sonra cihazımızda çalıştırabiliriz.
Tamam, miktarı değiştirdim ve
SİPARİŞ'e tıkladım, ve o 25 Doları doğru bir şekilde ücret olarak gösteriyor.
Harika, çalıştı.
Ama, uygulamamız için daha önceden hiç bir kullanıcı tarafından
Görülen değişiklik olmadığından Ücreti Hesapla'nın gerçekten çalıştığından nasıl emin olabilirim?
Kodunuzun gerçekten çalıştığını doğrulamak için size bir kaç
Teknik gösteriyorum.
700 gibi gerçekten çılgınca bir rakam döndürmesini sağlarım.
Kodumu kaydeder ve sonra çalıştırırım.
Şimdi görmeyi beklediğim şey, eğer miktarı değiştirir
Ve SİPARİŞ düğmesine basarsam, bana ücretin 700 Dolar olduğunu göstermeli.
Böylece, ücreti hesapla metodunun gerçekten çağrıldığını bilebilirim.
Ve çağrılıyor, harika.
Şimdi bu değişikliği eski haline döndürebilirim.
Bu metodun çalıştığını kontrol etmenin bir diğer yolu da
Buraya kırılma noktası eklemek.
Bu küçük böcek ikonuna tıklayacağım ve
Sonra elmamız ayıklama moduna girecek.
Miktarı değiştirir ve siparişe tıklarsam
Uygulamanın bu noktada ara vermesini beklerim.
Ve ara verir.
Şimdi ücreti hesapla metodundayız.
Küresel bir değişken var, miktar.
Ve ben bir sonraki satıra geçersem, miktar 3 olduğu için, 3 kere 5 15 yaptığı için
15 Dolara ayarlı yeni bir yerel değişken olarak ücreti göreceğim, harika.
Yani, hesaplanan ücret metodundan geçiyor ve
Ben Başla'ya tıklarsam bu ekranda düzgün bir şekilde güncelliyor.
Đầu tiên chúng ta sẽ sửa đổi ký số của phương pháp calculatePrice
để có được kiểu dữ liệu trả lại thích hợp.
Chúng ta cũng sẽ giả định rằng không có tham số đầu vào.
Đây là cách mà phương pháp calculatePrice được xác định.
Mục đích của phương pháp này là để tính tổng giá của đặt hàng
và sau đó trả lại giá trị đó.
Giá phải là số nguyên do đó
chúng ta phải thay đổi kiểu dữ liệu trả lại từ vô hiệu sang int.
Điều đó được thực hiện như là nhiệm vụ đầu tiên.
Câu đố cũng yêu cầu đảm bảo chắc chắn rằng không có tham số đầu vào, và
đó là những gì chúng ta đang có ở đây.
Bây giờ nhiệm vụ thứ hai là sửa đổi bên trong phương pháp
để đảm bảo rằng chúng ta đang tính toán giá đúng của đặt hàng.
Và giả định rằng giá là 5$ cho một cốc cà phê.
Bên trong phương pháp này chúng ta lấy số lượng cốc cà phê đặt hàng.
Và chúng ta nhân nó với 5$ một cốc cà phê.
Kết quả thu được là tổng giá đặt hàng.
Vì vậy dòng mã lệnh này đã bị phá vỡ.
Nhưng tôi thấy có hai vấn đề, giá biến đổi không bao giờ được sử dụng và
có lỗi sai báo thiếu câu lệnh trả lại.
Giá trị trả lại của phương pháp này là một số nguyên, nhưng chúng ta không trả lại giá trị gì.
Tại thời điểm này mã lệnh của chúng ta giống như chúng ta nói.
Chúng ta cần một dòng yêu cầu giá trị trả lại và sau đó đặt giá trị thực tế vào đây và
giá trị trả lại sẽ là giá tiền.
Do đó, tôi sẽ thêm giá, là một biến số mà chúng ta xác định ở đây.
Tuyệt, vậy là bây giờ không còn lỗi nào nữa.
Chúng ta cũng cần sửa đổi Java DOC.
Qua đó chúng ta nêu rõ rằng chúng ta đã chuyển tổng giá.
Bằng cách đó khi ai đó áp dụng phương pháp này, họ biết họ sẽ đạt được điều gì.
Được rồi, bây giờ chúng ta đã hoàn thành tất cả các bước để xác định phương pháp này.
Bây giờ, chúng ta cùng chuyển sang phần khi nào nên áp dụng phương pháp này.
Trong phạm vi phương pháp submitOrder, chúng ta nên áp dụng phương pháp calculatePrice.
Hiện nay việc tính giá không thuộc mục nào.
Tôi sẽ sao chép, và tôi sẽ dán giá vào đây.
Bởi vì trước đây chúng ta tính giá của đặt hàng theo dòng
trong phương pháp gửi đặt hàng, nhưng bây giờ chúng ta có phương pháp để tính giá.
Vì vậy tôi sẽ dán giá ở đây.
Giờ thì bỏ dấu chấm phẩy bổ sung.
Bạn sẽ nhận thấy giá là một biến số địa phương trong phương pháp này, và
cũng trong phương pháp này.
Sẽ không có vấn đề gì nếu biến số trùng tên,
bởi vì chúng khác nhau với phạm vi biến đổi.
Do đó mức giá biến đổi ở đây hoàn toàn không liên quan với biến đổi ở đây.
Giá được cập nhật và tạo ra một cách độc lập với nhau.
Và khi phương pháp này hoàn thành thực thi, biến số giá này sẽ không còn.
Được rồi, chúng ta quay lại phương pháp submitOrder nào.
Như vậy chúng ta đã tính giá và
lưu trữ giá trong biến số, và sau đó chúng ta có thể sử dụng nó để tạo ra thông tin giá.
Như vậy, thực ra, tất cả mã lệnh này có thể đều giống nhau.
Chúng ta đã ghép nối số nguyên,
giá, vào tổng chuỗi với biểu tượng tiền tệ.
Sau đó chúng ta ghép nối “Cảm ơn!” và sau đó chỉ hiển thị nó trên màn hình.
Như vậy tôi sẽ xóa những dòng trống, thừa và lưu lại, rồi
sau đó chúng ta có thể chạy ứng dụng trên thiết bị của chúng ta.
Được rồi, như vậy là tôi đã thay đổi số lượng, và
nhấn ORDER, cuối cùng nó hiển thị đúng giá 25$.
Tuyệt vời, phương pháp hoạt động chính xác.
Nhưng làm thế nào tôi đảm bảo rằng phương pháp calculatePrice đang thực sự
hoạt động bởi vì không có người dùng nào nhìn thấy sự thay đổi của ứng dụng của chúng ta so với trước đó.
Dưới đây là một vài kỹ thuật bạn có thể làm để xác minh mã lệnh của bạn
đang hoạt động.
Tôi có thể nhận được giá trị trả lại là một con số điên rồ, 700 chẳng hạn.
Hãy lưu mã lệnh của tôi và chạy ứng dụng.
Bây giờ điều tôi mong đợi là nếu tôi thay đổi số lượng và
nhấn nút ORDER, tôi sẽ nhận được mức giá là 700$.
Bằng cách đó tôi sẽ biết rằng phương pháp tính giá này thực sự được áp dụng.
Và đúng như vậy, thật tuyệt.
Bây giờ tôi có thể xem lại thay đổi này.
Một cách khác để kiểm tra xem phương pháp này có được thực thi hay không
đó là thêm điểm dừng ở đây.
Do đó tôi sẽ nhấp vào biểu tượng gỡ lỗi nhỏ này và
sau đó hệ apple của chúng ta chạy chế độ gỡ lỗi.
Nếu tôi thay đổi số lượng và
Tôi nhấn order (đặt hang), thì tôi hi vọng rằng ứng dụng sẽ tạm dừng ở điểm này.
Và đúng như vậy.
Như vậy bây giờ chúng ta đang dùng phương pháp tính giá.
Có một biến toàn cầu, số lượng.
Và nếu tôi bỏ qua bước sang dòng tiếp theo thì tôi thấy rằng bây giờ có một biến địa phương,
Giá được thiết lập là 15$ do số lượng là 3, 3 nhân 5 bằng 15, tuyệt.
Như vậy, phương pháp tính giá thực sự được áp dụng, và
nếu tôi nhấn Resume (Tiếp tục), thì nó cập nhật chính xác trên màn hình.
首先我们要修改 calculatePrice 方法的签明
来设定正确的返回值数据类型
我们假设输入参数的个数为0
这是定义 calculatePrice 的地方
这个方法的目的是计算整个订购的价格
并且返回它
价格应该是一个整数 所以
我们需要把返回值的数据类型从 void 变成 int
第一个任务就完成了
提示还说要确保没有输入参数
我这里也没有
第二个任务就是修改方法内部的代码
保证能够正确的计算订单价格
假设一杯咖啡是 $5.00
在这个方法内 我们使用订购杯数
将它乘以每杯咖啡的价格 $5.00
这等于整个订购价格
这行代码就完成了
但有两个问题 变量 price 从未使用
而且还有一个错误提示我们缺少返回值的声明
本来应该返回一个整数 但我们什么也没返回
现在我们的代码就是这样的
我们需要一行代码来声明返回值 并且把一个值放在这里
返回值就是一个价格
因此我放入 price 就是我们上面定义的变量
现在没有错误了
我们还应该修改 Java 注释
所以我们声明 要返回总价
当有人调用这个方法时就知道会得到什么了
所以现在 我们已经完成这个方法定义的所有部分了
现在我们转到调用这个方法的位置
在 submitOrder 方法内 我们会调用 calculatePrice 方法
现在 calculatePrice 是浮动在中间某处的
我把它复制粘贴到这里
因为在计算这个订购价格之前
在 submitorder 方法中 现在我们有个专门的方法
所以把它粘贴在这儿
再删掉多余的分号
你应该注意到了 在这个方法里 price 是个局部变量
在这个方法中也是
所以名字相同也没事
因为他们在不同的变量作用域中
在这里的 price 变量和这里的这个完全没有关系
它们的建立与更新都是完全独立的
一旦这个方法执行完 price 变量就消失了
回到 submitOrder 方法中
我们计算一个价格
把它存储到变量中 我们可以用它来创建一个 priceMessage 变量
所以事实上 所有代码都没变
我们连接上整型变量 price
和字符串 Total:$
然后我们再拼接上 Thank you! 显示在屏幕上
删除这些多余的空白行 保存
在设备上运行一下
改变数量
点击 ORDER 它就显示正确的价格为 $25
太好了 运转正常
但我怎么能确定 calculatePrice 实际上发挥作用了呢?
因为与我们之前的程序相比 用户并不能看到明显变更
有一些技巧可以用来核实你更改的代码
已经生效
我可以让他返回一个很大的值 例如700
保存代码 然后运行
现在我希望 如果我变更数量
点击 ORDER 按钮 它应该显示价格是 $700
这样我就知道 calculatePrice 方法实际上被调用了
运行正常
现在我撤销这个更改
另一个检查这个方法是否执行的办法是
在这里加入断点
我点这个调试小图标
然后我们的程序进入调试模式
如果我改变数量
点击 ORDER 我希望程序在这里暂停
的确暂停了
现在我们位于 calculatePrice 方法中
quantity 是个全局变量
如果我转到下一行 可以看到这里有一个局部变量 price
它被设定为 $15 因为数量是 3*5=15
所以检查过 calculatedPrice 方法后
如果我点击 Resume 它会在屏幕上正确更新
首我們要更改calculatePrice方法簽字
來設定正確的返回資料型別
我們假設輸入參數的個數是0
我們在這里定義calculatePrice方法
這個方法的作用是計算訂單的總價格
然后返回這個總價格
價格應該是一個整數
因此我們需要把返回資料型別從void改為int
第一個任務就完成了
測驗題還說 要確保沒有輸入參數
這是確實沒有輸入參數
第二個任務是修改方法內部的代碼
保證正確地計算訂單的價格
假設一杯咖啡的價格是$5.00
在這個方法內 我們使用訂購杯數
將它乘以每杯咖啡的單價$5
就等于訂單總價
這樣 我們就理解了這行代碼的含義
但是有兩個問題 變數price從來沒有被使用
而且有一個錯誤提示我們缺少返回陳述式
它期望我們返回一個整數 但是我們沒有返回任何值
現在我們的代碼是這樣的
我們需要一行代碼來陳述返回值 然后把一個值放在這里
返回值是價格
因此我要放入price 這是我們在這里定義的一個變數
很好 現在所有錯誤都消失了
我們還應該修改 Java DOC.
因此我們聲明 我們要返回總價
當有人調用這個方法時 他們就知道會得到什么
因此現在我們已經完成這個方法的所有定義工作
現在讓我們轉到調用這個方法的位置
在submitOrder方法內 我們應該調用calculatePrice方法
現在價格計算方法的位置還不確定
我需要復制它 把它貼在這里
在我們計算訂單價格之前
在訂單提交方法 我們需要為它定義一個方法
我需要把它貼在這里
現在刪除多余的分號
我們注意到在這個方法中 價格是一個區域變數
而且在這個方法中也是一個區域變數
因此它們的名稱可以是相同的
因為它們具有不同的變數適用范圍
這里的價格變數和這里的變數完全沒有關系
它們已經過更新 而且是互相獨立的
這個方法執行完成后 price變數就消失了
我們返回到submitOrder方法
因此計算價格
把它存放在變數中 我們可以使用它來建立價格訊息
實隙上 這個代碼是通用的
我們可以連結整數
價格到總價字串 并附加貨幣符號
然后我們連結"Thank you!" 顯示在熒幕上
我要刪除這些多余的空白行 然后保存
然后 我們可以在設備上運行程式
我變更數量
然后按一下ORDER 它就正確顯示價格為$25
太好了 完全正確
但是我怎樣確定calculatePrice已經發揮作用呢
因為與我們以前的應用程式相比 使用者并不能看到明顯的變更
你可以使用一些技術核實
你的代碼實際在運行
我可以讓它返回一個很大的數字 比如700.
保存我的代碼 然后運行
現在我期望 如果我變更數量
然后按ORDER訂單 價格應該顯示為$700
這樣我應知道這個價格計算方法實際上已經被調用
運行正常 好極了
現在我可以取消這個變更
檢查這個方法是否被執行的另一種途徑
在這里添加一個斷點
我點這個調試小圖標
我們的應用程式進入調試模態
如果我變更數量
然后按一下訂購 我期望程式在這里暫停
它在這里暫停了
現在我們位于價格計算方法之中
有一個全域變數quantity
如果我轉到下一行 我看現在這里有一個區域變數price
它被設定為$15 因為數量是3 3乘以5等于15 好極了
現在 將要執行價格計算方法
如果我按一下Resume 它會正確更新熒幕