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に 戻り値の型を変更する必要があります
これが最初のタスクになります
入力パラメーターがないことを確認します
これがここにあるものです 入力パラメーターがないことを確認します
これがここにあるものです
２番目のタスクはメソッドの内部の変更です
注文に対して正しい値を 計算しているかどうか確認します
一杯のコーヒーが$5.00であるとします
このメソッドの中に 注文された数量をいれます
それに1 杯当たり $ 5 の コーヒーを掛けます
これが注文の合計価格に相当します
このコードラインは割れています
ここで２つの問題がみられます 可変価格が使われていないことと
戻り値がありませんというエラーです
整数を返すことを要求していますが 何も返していないわけです
今コードは先程言った通りになっています
ラインが値を返すようにし 実際にここに値を入力すると
返された値は価格になります
それでは ここで定義した変数である 値を入力してみましょう
さあ これで全てのエラーが消えました
Java ドキュメントも 変更する必要があります
それによって 合計価格を出すように指定します
これで誰かがこのメソッドを呼び出す時 何が実行されるのかが分かります
これでこのメソッドの定義は全て終了しました
ではメソッドを呼び出すところに移りましょう SubmitOrder メソッドの中の
calculatePrice メソッドを呼び出します
現在 calculatePrice は こんなところに表示されてしまっています
これをコピーして ここにベーストします
以前は ラインのSubmitOrder メソッドで注文価格を計算していましたが
今はそのためのメソッドがあります
ではここに貼り付けます
この余分なセミコロンは消去します
このメソッドでは 価格は ローカル変数であることに気がつくでしょう
そしてこのメソッドでも
同じ名前であれば それで大丈夫です
なぜなら これらは 異なるVariableスコープだからです
この価格の変数は完全に この変数とは無関係です
それらは更新され お互いに独立して作成されます
いったんこのメソッドの実行が完了すると この価格変数はなくなります
では submitOrder メソッドに 戻りましょう
価格を計算して
変数として保存すると 価格メッセージの作成に使用できます
これで実際に このコードの全ては同じままになります
この整数
価格 文字列の合計を通貨記号と連結します
そして"Thank you!"と連結して 画面にそれが表示されるようにします
これらの余分な部分 空白行を消去してそれを保存すると
デバイスで実行できるようになります
では数量を変更して
ORDERを押してみましょう 価格が正しく $25 と表示されます
これでうまくできました
どうすればcalculatePrice が 実際作動しているか確認できるのでしょうか
以前のアプリと比較した際の変化が ユーザーには見えません
ここでは２つの技法で コードが実際に機能していることを
確認します
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 它會正確更新熒幕