Earlier, we saw that we could pass
a number into the display method.
Let's talk more about the different
inputs and output of a method.
Let's look at the submitOrder method
in the MainActivity as an example.
Say you have a bunch of lines
of code in that method.
When the user clicks
on the Order button,
it will trigger this submitOrder
method to be called.
The Android device will execute each of
these instructions from top to bottom,
and when it hits the calculatePrice
method call it will
jump over to where the calculatePrice
method is defined.
Say that this is defined at
the bottom of the MainActivity file.
The Android device will execute each of
these instructions from top to bottom of
the method, and then it will jump
back to the submitOrder method.
Then, it will continue executing these
instructions until it hits the end
of the method.
When the calculatePrice
method is called,
we can pass a bunch of inputs over so
that when we're executing these lines
of code, we can use these input values.
As a result of this method,
we can pass a single output
value back to the caller.
That way, the output value can be
used in the subsequent lines of code.
In Java, we call the inputs to
a method input parameters, and
we can have zero or
more input parameters.
In Java,
we call the output a return value,
and we can have zero or
one return value.
An example of an input parameter
is passing the quantity
over to the calculatePrice method.
That way, this method can use the
quantity to figure out the total price
of the whole order.
Then, we can pass that total
price back as a return value.
And then in the submitOrder method,
down here,
we can use this total price to do other
things, like display it onscreen, or
create receipt, or anything like that.
So to summarize, this is where we
define the calculatePrice method, and
this is where we call it.
We want to create a method to
calculate the price of a coffee order.
Currently, we calculate the price
directly in the submitOrder method, but
the logic to calculate the price is
going to get a little more complicated.
So let's move it into its own method.
Then we can call it as many times
as we want without copying and
pasting the code everywhere.
As you gain more experience in Android
development, you'll gain better judgment
on when to create a new method for
something or when you don't need to.
This will just come with more
experience and more time.
So, this is the first time
we're going to be creating
a new method in
the MainActivity on our own.
Instead of starting by writing it from
scratch, we want to start by learning to
recognize what is a correct method
by reading some code snippets.
So in the instructor notes, we're
going to provide you three options.
Read over these three code snippets and
determine which
option correctly implements the method
to calculate the price of the order.
When you click on the link
in the instructor notes,
you'll see this just has code for
options A, B, and C.
The goal here is for
you to become comfortable with reading
code that you've never seen before.
We haven't gone over the exact rules for
what makes a valid method, but
I want you to make your best guess on
which option you think is most correct.
I also encourage you
to Google search for
more information on how
to define Java methods.
As you click through
the different search results,
you'll come across information in the
documentation that you don't understand.
But I want you to become comfortable
with not understanding everything on
those pages, because it's perfectly
normal to not understand everything.
All you need to do is just skim
the articles for what you understand and
what you think is relevant
to the problem at hand.
So, go ahead and read the code for
these three options, look up some
information online, and then make your
best guest on how to correctly
define the calculatePrice method.
سابقاً، وحدنا أنه بإمكاننا تمرير
رقم في طريقة العرض
دعونا نتحدث عن
الفرق بين دخل وخرج طريقة ما
دعونا نشاهد طريقة submitOrder في
MainActivity كمثال على ذلك
لنقل بأن لديك مجموعة من أسطر الكود
داخل هذه الطريقة
عندما ينقر المستخدم على الزر "Order"
سيؤدي ذلك إلى
استدعاء الطريقة submitOrder
سقوم جهاز أندرويد بتنفيذ كل من
هذه التعليمات من الأعلى للأسفل
وعندما يصل إلى استدعاء
الطريقة calculatePrice سوف
ينتقل إلى مكان تعريف
الطريقة calculatePrice
لنقل بأنها معرفة
أسفل ملف MainActivity
سيقوم جهاز أندرويد بتنفيذ كل
من هذه التعليمات من أعلى لأسفل
الطريقة، بعد ذلك سنتقل مجدداً
إلى الطريقة submitOrder
ثم سيكمل تنفيذ هذه التعليمات
حتى يصل إلى نهاية
هذه الطريقة
عندما يتم استدعاء
الطريقة calculatePrice
يمكننا أن نمرر مجموعة من المدخلات هنا
التي يمكننا استخدام قيمها عندما
ننفذ هذه الأسطر من الكود
كنتيجة لهذه الطريقة
يمكننا تمرير
قيمة خرج وحيدة للمستدعي هذه الطريقة
بهذه الطريقة، يمكن استخدام قيمة
الخرج في الأسطر اللاحقة من الكود
في جافا، نسمي مدخلات طريقة ما
بوسطاء الدخل و
يمكن ألا يكون
لدينا أي وسيط أو مجموعة من الوسطاء
في جافا
نسمي الخرج القيمة المعادة
ويمكن ألا يكون لدينا
أي قيمة معادة أو قيمة معادة واحدة
كمثال على تمرير وسيط دخل
نذكر تمرير الكمية
للطريقة calculatePrice
بهذا الأسلوب، يمكن لهذه الطريقة استخدام
quantity لحساب totalPrice
للطلب كاملاً
ثم يمكننا تمرير هذا totalPrice
كقيمة معادة
ثم في الطريقة submitOrder
هنا في الأسفل
يمكننا استخدام هذا totalPrice
لفعل أشياء أخرى كعرضه على الشاشة
أو إنشاء الفاتورة أو أي شيء آخر
للتلخيص، هنا قمنا بتعريف
الطريقة calculatePrice
و هنا نقوم باستدعائها
نريد أن ننشئ طريقة لحساب
سعر طلب القهوة
حالياً، نحسب price مباشرة
في الطريقة submitOrder لكن
منطق حساب السعر سيصبح
معقداً قليلاً
لذلك دعونا ننتقل لطريقته الخاصة
ثم يمكننا استدعاؤها
قدر ما نشاء من المرات دون نسخ
ولصق الكود في كل مكان
كلما اكتسبت خبرة أكبر في تطوير أندرويد
ستقوم بمحاكمة أفضل
حول متى ستقوم بإنشاء طريقة
لشيء ما أم أنك لست بحاجة لذلك
هذا يأتي مع خبرة أكبر
ووقت أكثر
إذن، هذه أول مرة
سنقوم بها بإنشاء
طريقة جديدة
في MainActivity لوحدنا
بدلا من البدء بكتابتها من الصفر
سنبدأ بتعلم
التعرف على الأسلوب الصحيح
بقراءة بعض مقتطفات الكود
إذن، في ملاحظات المرشد
سنقدم لك ثلاثة خيارات
اقرأ مقتطفات الكود الثلاثة هذه
وحدد أي
خيار يطبق الطريقة الصحيحة
لحساب سعر الطلب
عندما تنقر على رابط
ملاحظات المرشد
سترلا ثلاثة خيارات
للكود A و B و C
والهدف هنا
أن تكون مرتاحاً في قراءة
الكود الذي لم تره من قبل
لم نقم بمراعاة القواعد الصحيحة
لكتابة طريقة صالحة، لكنني
أريدك أن تقدم أفضل اقتراح
حول أي منها تظن انه الأقرب للصحة
و أشجعكك ايضاً على البحث
في جوجل من أجل
مزريد من المعلومات حول
كيفية تعريف طرق جافا
من خلال مرورك
من خلال نتائج البحث
ستمر على معلومات
لم تتعرف عليها في التوثيق
لكن أريدك أن تكون مرتاحاً
حول عدم فهمك لكل شيء
في تلك الصفحات، لأنه من الطبيعي
بشكل تام ألا تفهم كل شيء
كل ما عليك فعله هو تصفح
المقالات للوصول إلى ما تفهمه
ورأيك حول ما هو
مناسب للمشكلة المطروحة
لذا، امض قدماص و اقرأ الكود
في هذه الخيارات الثلاثة وابحث عن
بعض المعلومات على الانترنت و قم
بأفضل اختيار حول كيفية
تعريف الطريقة calculatePrice بأسلوب صحيح
Anteriormente, vimos que se podía
pasar un número al método Display
Vamos a hablar un poco más
de las entradas y salidas de un método.
Veamos el metódo SubmitOrder
en MainActivity como ejemplo.
Digamos que tienes varías líneas
de código en ese método.
Al clicar los usuarios
en el botón de pedido,
se activará la llamada a SubmitOrder.
El dispositivo de Android ejecutará
las instrucciones de arriba a abajo
y cuando llegue a la llamada
del método CalculatePrice,
saltará a donde se define
el método CalculatePrice.
Digamos que se define en la parte
inferior del archivo MainActivity.
El dispositivo de Android ejecutará
cada una de estas instrucciones
desde arriba a abajo del método
y volverá al método SubmitOrder
Y después seguirá ejecutando
estas instrucciones hasta llegar
al final del método.
Cuando se llama al método CalculatePrice
podemos pasar un montón de entradas,
así cuando ejecutemos esas líneas
de código, podemos usar
estos valores de entrada.
Como resultado de este método,
podemos pasar un único valor
de salida al método que invocamos.
Así, el valor de salida puede usarse
en las siguientes lineas del código.
En Java, llamamos a las entradas
de método, parámetros de entrada
y podemos tener varios
o ningún parámetro de entrada.
En Java, llamamos a la salidas
de método, valor de retorno,
y podemos tener varios
o ningún valor de retorno.
Un ejemplo de un parámetro
de entrada es pasar quantity
al método CalculatePrice.
De este modo, este método puede
usar quantity para calcular
el precio total de todo el pedido.
Luego podemos pasar ese precio
total como valor de retorno.
Y entonces en el método
SubmitOrder aquí abajo,
usamos este precio total
para hacer otras cosas
como mostrarlo en la pantalla,
crear un recibo o cosas parecidas.
En resumen, esto es donde definimos
el método CalculatePrice
Y este es donde lo llamamos.
Crearemos un método para calcular
el precio del café en un pedido.
Ahora, calculamos el precio
directamente en el método SubmitOrder,
pero la lógica para calcular el precio
será un poco más complicada.
Vamonos dentro de su propio método.
Luego, podemos llamarlo tantas veces
como queramos sin copiar
y pegar el códido en todas las partes.
Conforme tengas más experiencia en
el desarrollo de Android, sabrás mejor
si tienes que crear
o no un método nuevo para algo.
Es cuestión de más experiencia y tiempo.
Por tanto, esta es la primera vez
que vamos a crear solos
un método nuevo en MainActivity.
En vez de empezar a escribir desde cero,
aprenderemos a reconocer
qué es un método correcto
con la lectura de algunos
fragmentos de código.
En la notas del instructor,
te daremos tres opciones.
Lee estos fragmentos y determina
cuál opción implementará correctamente
el método para calcular
el precio del pedido.
Al clicar en el enlace
de las notas del instructor,
verás las tres opciones de código A, B y C.
El objetivo aquí es que te sientes cómodo
leyendo un código que no habías visto.
No hemos visto las normas exactas
que convierten a un método en válido,
pero quiero que adivines cuál será
la opción correcta en tu opinión,
También te animo a buscar
más información en Google Search
sobre como definir métodos en Java.
Cuando hagas clic
en los diferentes resultados,
te encontrarás con información
y documentación que no entenderás.
Pero quiero que te sientas cómodo
aunque no entiendas todo
en esas páginas, porque es
totalmente normal que sea así.
Solo necesitas hojear los artículos
de lo que creas entender
y de lo que pienses que será
relevante para resolver el problema.
Así que adelante, lee el código
de estas tres opciones,
busca alguna información online
e intenta adivinar cómo definir
correctamente el método CalculatePrice.
Nous avons vu qu'on pouvait passer sur
un nombre dans la mÈthode d'affichage.
Maintenant, parlons un peu des diffÈrentes
entrÈes et sorties d'une mÈthode.
Prenons la mÈthode submitOrder,
dans MainActivity, comme exemple.
Supposons que l'on a une sÈrie de lignes
de codes dans cette mÈthode.
Lorsque l'utilisateur clique
sur le bouton Commander,
cela enclenche et appelle
la mÈthode submitOrder.
L'appareil Android exÈcutera chacune de
ces instructions de haut en bas,
et lorsqu'il parvient ‡ l'appel de mÈthode
calculatePrice, il
ira se placer ‡ l'endroit o˘ la mÈthode
calculatePrice est dÈfinie.
Supposons qu'elle est dÈfinie en
bas du fichier MainActivity.
L'appareil Android exÈcutera chacune de
ces instructions, du haut en bas de
la mÈthode, puis il reviendra se placer
sur la mÈthode submitOrder.
Puis, il continuera ‡ exÈcuter ces
instructions jusqu'‡ atteindre la fin
de la mÈthode.
Lorsque la mÈthode calculatePrice
est appelÈe,
on peut passer sur une sÈrie d'entrÈes
pour que, lorsqu'on exÈcute ces lignes
de code, on utilise ces valeurs d'entrÈe.
Gr‚ce ‡ cette mÈthode,
on peut ramener une valeur de sortie
unique ‡ l'appelant.
Et la valeur de sortie peut Ítre utilisÈe
dans les lignes de codes suivantes.
Dans Java, on appelle les entrÈes vers
une mÈthode paramËtres de saisie, et
on peut avoir zÈro ou
plus paramËtres de saisie.
Dans Java,
on appelle la sortie une valeur de retour,
et on peut avoir zÈro ou
une valeur de retour.
Un exemple de paramËtre de saisie
consiste ‡ faire passer la quantitÈ
vers la mÈthode calculatePrice.
Ainsi, cette mÈthode peut utiliser la
quantitÈ pour dÈterminer le prix total
de la commande globale.
Puis, on peut refaire passer ce prix
total en valeur de retour.
Puis, dans la mÈthode submitOrder,
ici en bas,
on peut utiliser ce prix total pour faire
autre chose comme l'afficher sur Ècran,
crÈer un ticket, entre autres choses.
Pour rÈsumer, voici l'endroit o˘ on
dÈfinit la mÈthode calculatePrice, et
voici l'endroit o˘ on l'appelle.
Nous voulons crÈer une mÈthode pour
calculer le prix d'une commande de cafÈ.
Actuellement, nous calculons le prix
directement dans la mÈthode submitOrder,
mais la logique de calcul du prix va
devenir un peu plus compliquÈe.
Alors, faisons-le dans sa propre mÈthode.
Ensuite, nous pouvons l'appeler autant de
fois que l'on veut sans copier et
coller le code partout.
En gagnant de l'expÈrience en
dÈveloppement d'Android, vous estimerez
quand crÈer une nouvelle mÈthode pour
quelque chose ou quand c'est inutile.
Cela viendra simplement avec
l'expÈrience et le temps.
C'est donc la premiËre fois
que nous allons crÈer
une nouvelle mÈthode dans
MainActivity, par nous-mÍmes.
Au lieu de dÈbuter en l'Ècrivant depuis
le dÈbut, on veut commencer en apprenant ‡
reconnaÓtre ce qu'est une mÈthode correcte
par la lecture d'extraits de codes.
Dans les notes du formateur, nous
allons vous fournir trois options.
Lisez ces trois extraits de codes et
dÈterminez quelle
option applique correctement la mÈthode
de calcul du prix de la commande.
Lorsque vous cliquez sur le lien
dans les notes du formateur,
vous voyez qu'il y a juste un code pour
les options A, B, et C.
Le but ici, pour vous, est
de devenir ‡ l'aise avec la lecture
de codes que vous n'avez jamais vus.
Nous n'avons pas vu les rËgles exactes
rendant une mÈthode valide, mais
je veux que vous deviniez
quelle option paraÓt la plus correcte.
Je vous encourage Ègalement
‡ chercher sur Google
plus d'informations sur les moyens
de dÈfinir les mÈthodes Java.
Lorsque vous cliquerez sur
les diffÈrents rÈsultats de recherche,
vous dÈcouvrirez des informations
que vous ne comprendrez pas.
Mais je veux que vous soyez rassurÈ
si vous ne comprenez pas tout dans
ces pages, car c'est parfaitement
normal de ne pas tout comprendre.
Tout ce que vous devez faire, c'est lire
les articles, ce que vous comprenez et
ce que vous jugez pertinent
pour la question qui vous intÈresse.
Alors, allez-y et lisez le code pour
ces trois options, cherchez de
l'information en ligne, et puis fiez-vous
‡ votre intuition pour deviner comment
bien dÈfinir la mÈthode calculatePrice.
Sebelumnya, kita sudah bisa memasukkan
angka ke ke dalam metode display.
Mari bicarakan lebih lanjut tentang
perbedaan input dan output dari metode.
Perhatikan metode submitOrder dalam
MainActivity sebagai contoh.
Misal saja Anda punya banyak
baris kode dalam metode itu
Saat pengguna mengeklik
tombol Order,
ini akan memicu metode submitOrder
untuk terpanggil.
Perangkat Android akan mengeksekusi
tiap instruksi ini dari atas sampai bawah,
dan ketika menyentuh panggilan
metode calculatePrice, dia akan
melompat kemana metode calculatePrice
dinyatakan.
Misal, dia dinyatakan
di bawah berkas MainActivity.
Perangkat Android device akan mengeksekusi
tiap instruksi dari atas ke bawah
metode, lalu melompat kembali
ke metode submitOrder.
Dia akan lanjut mengeksekusi instruksi
ini sampai menyentuh metode terakhir.
Saat metode calculatePrice dipanggil
kita bisa masukkan banyak
sekali input, sehingga
saat kita mengeksekusi baris kode ini,
kita dapat menggunakan nilai input ini.
Sebagai hasil dari metode ini,
kita dapat memberikan output tunggal
kembali ke pemanggil.
Dengan cara itu, nilai output dapat
digunakan dalam baris kode selanjutnya.
Dalam Java, kita panggil input ke dalam
metode parameter input, dan
kita bisa miliki input parameter
nol atau lebih.
Dalam Java, kita panggil output
sebagai nilai kembalian,
dan kita boleh miliki nol
atau satu nilai kembalian.
Sebuah contoh paramete input
memberikan kuantitas
kepada metode calculatePrice.
Jadi, metode ini dapat menggunakan
kuantitas untuk mengetahui harga total
seluruh order.
Lalu, kita dapat mengembalikan harga
total itu sebagai nilai kembalian.
Kemudian, di metode submitOrder
bawah ini, kita bisa gunakan
harga total ini untuk melakukan hal lain,
seperti menampilkan di layar, atau
membuat tanda terima, atau semacamnya.
Kesimpulannya, disinilah kita
mendefinisikan metode calculatePrice
dan disinilah kita memanggilnya.
Kita ingin membuat metode untuk
menghitung harga order kopi.
Saat ini, kita menghitung harga secara
langsung dalam metode submitOrder
tapi logika untuk menghitung harga
akan menjadi sedikit rumit.
Jadi, mari lanjutkan ke metodenya sendiri.
Kita dapat memanggilnya sebanyak yang
kita inginkan tanpa menyalin dan
menempel kode dimana-mana.
Seiring pengalaman Anda di pengembangan
Android membaik, penilaianpun ikut membaik
ketika membuat suatu
metode baru atau tidak.
Hal ini bisa diperoleh dengan
pengalaman dan waktu.
Jadi, ini adalah pertama kalinya
kita akan membuat
sebuah metode baru
di dalam MainActivity milik kita.
Daripada mulai dengan menulis dari awal,
kita akan mulai dengan belajar untuk
mengenali arti metode yang benar dengan
membaca beberapa potongan kode.
Jadi, di dalam catatan instruktur,
kita akan sediakan tiga opsi.
Baca tiga potongan kode ini
dan tentukan mana
opsi tepat yang mengimplementasikan
metode untuk menghitung harga order.
Saat Anda klik tautan
dalam catatan instruktur,
hanya tersedia kode untuk
opsi A, B, dan C.
Tujuannya, agar Anda lebih nyaman membaca
kode yang belum pernah dilihat sebelumnya.
Kita belum memutuskan aturan mana
yang merupakan metode sah, tapi
saya ingin Anda menebak pada opsi
mana yang paling benar.
Saya juga mendorong Anda untuk
melakukan pencarian Google
untuk mendapat informasi lebih tentang
cara mendefinisikan metode Java.
Saat Anda mengeklik pada
hasil pencarian yang berbeda,
Anda akan menemukan informasi dalam
dokumentasi yang tidak Anda pahami.
Tapi, saya ingin agar Anda lebih nyaman
tanpa memahami segalanya yang ada
di halaman itu, karena sangatlah normal
untuk tidak memahami segalanya.
Yang diperlukan hanyalah membaca cepat
artikel-artikel yang Anda pahami dan
yang Anda rasa relevan
dengan masalah Anda.
Lanjutkanlah dan baca kode untuk
tiga opsi ini, cari informasi
secara online, lalu buat tebakan
terbaik tentang cara mendefinisikan
metode calculatePrice dengan tepat.
以前に数を display メソッドに
渡す方法をご紹介しました
ここではメソッドの異なった出入力の
詳細についてお話しします
例として MainActivity にある
submitOrder メソッドを
見てみましょう
そのメソッドに一連のコード行があるとします
ユーザーが Order ボタンを
クリックした時に
この submitOrder メソッドが
呼び出されます
Android デバイスがこれらの各指示を
上から下まで実行していきます
それが calculatePrice
メソッド呼び出しにくると
calculatePrice メソッドが
定義されているところにジャンプします
これが MainActivity
ファイルの下部に定義されているとすると
Android デバイスがこれらの各指示を
メソッドの上から下まで実行していきます
そして submitOrder メソッドに
ジャンプして戻ります
その後 引き続きメソッドの最後まで
指示を実行していきます
calculatePrice メソッドが
呼び出されると
一連の入力を渡すことができるので
これらのコード行を実行している時に
これらの入力値を使用できます
このメソッドの結果として
呼び出し元に 1 つの出力値を
渡すことができます
これで出力値を後続のコード行で
使用することができます
Java ではこのメソッドへの入力を
入力パラメーターと呼び
0 もしくはそれ以上を
入力パラメーターとすることができます
Java ではこの出力を戻り値と呼び
0 もしくは 1 を戻り値と
することができます
入力パラメーターの例としては 数量を
calculatePrice メソッドに
渡します
このように このメソッドは
注文全体の合計価格を把握するために
数量を使用できます
そして戻り値として
その合計金額を渡すことができます
submitOrder メソッド
ここでは
この合計金額を他の目的で
使用することができます 例えば
画面に表示したり領収書や何かを
作成したりといったことです
要約すると ここが
calculatePriceメソッドを
定義するところで
ここはそれを呼び出すところです
コーヒー注文の価格を計算する
メソッドを作成したい場合
現在は submitOrder メソッドで
直接価格を計算していますが
この価格を計算するロジックは
もう少し複雑になります
それではそれを自身のメソッドに
移動しましょう
するとコードをあちこちに
コピー&ペーストしなくても呼び出したいだけ
何回でも呼び出すことができます
Android 開発で
多くの経験を得るにつれて
ある目的のために新しいメソッドを作成するか
その必要がないかについて より良い判断を
することができるようになります
これには経験と時間がものを言います
さて ここで初めて
自分自身で新しいメソッドを
MainActivity のなかに
作成していくわけですが
ゼロからスタートして書き始めるよりも
コード スニペットを読んで
何が正しいメソッドであるかを認識することを
学習することから初めてみましょう
インストラクターノートの中に
3 つのオプションをご用意しました
これらの 3 つのコード スニペットを
じっくり読んで どのオプションが
注文の金額計算をするのに正しくメソッドを
実装するのか特定してみましょう
インストラクターノートをクリックすると
オプション A B C の
コードが見られます
ここでの目的は 以前に見たことがない
コードを読むことに慣れることです
何が有効なメソッドに必要なのかの
厳密な規則についてはまだ触れていませんが
最も正しいと思うオプションを
推測してみて下さい
Java メソッドを定義する方法について
もっと情報を得るために
Google 検索もお勧めします
異なった検索結果をクリックすると
分からない文書の情報が出てきます
これらのページはすべてを
理解できなくても大丈夫です
全部を理解できないのは
ごく普通のことです
必要なのは 記事をざっと読んで
自分が理解できる
当面の問題に関連あるものを探すことです
それでは これら 3 つのオプションの
コードを読んでみましょう
そしてオンラインで情報を探して
calculatePrice メソッドの
定義方法について最良の推測をしてみましょう
앞서 우리는 디스플레이 메소드에
수치를 전달할 수 있다고 배웠는데요.
메소드 입출력에 대해
조금 더 알아보도록 합시다.
MainActivity 내에 있는
submitOrder 메소드를 예로 들어보죠.
이 메소드 안에 코드 덩어리가 들어있다고
생각해 봅시다.
사용자가 '주문' 버튼을 클릭하면,
이 submitOrder 메소드가 호출되죠.
안드로이드 기기에선 이런 매 지시사항이
위에서부터 하나씩 끝까지 수행됩니다.
그러다 calculatePrice 메소드에 이르면
9
00:00:26,980 --> 00:00:30,400
이 메소드가 정의된 부분으로 점프하죠.
이 부분이 MainActivity의 맨아랫부분에
정의되어 있다고 가정합시다.
안드로이드 기기에서는 이 메소드 역시
위에서부터 명령을 하나하나 수행하는데
그리고 나서 submitOrder 메소드로
다시 점프해서 돌아오는 거죠.
그런 후에 메소드 종결부까지
다시 명령을 하나하나 수행하여
14
00:00:44,340 --> 00:00:45,268
나가는 것입니다.
calculatePrice 메소드가 호출되면
16
00:00:47,240 --> 00:00:49,510
입력치를 이쪽으로 보내서
이쪽의 코드 명령을 수행하는 동안
이 입력치를 사용할 수 있게 됩니다.
이 메소드의 결과로,
단일 출력치를 호출자로 다시
전달하게 되는 것이죠.
이런 식으로, 출력치는 그 다음에 나오는
코드에 사용할 수 있습니다.
자바에서는 이 입력치를
메소드 입력 파라미터라 하며
0 혹은 그 이상의 수치를
파라미터로 가질 수 있습니다.
자바에서는 출력치를 리턴값이라 하고,
리턴값으로는 0이나 1을 가질 수 있습니다.
입력 파라미터의 예로는
calculatePrice 메소드에
수량치를 전달하는 경우가 있겠는데요.
이런 식으로 이 메소드에서는
수량치를 가지고
주문한 전체 가격을 계산합니다.
그리고 나서 그 가격을
리턴값으로 전달하는 것이죠.
그런 후 submitOrder 메소드
이 아래쪽에서,
이 전체 가격을 이용하여
스크린 출력 혹은 계산서 작성 등
다른 일을 할 수 있게 되는 것입니다.
요약하자면, 이곳에서는
calculatePrice 메소드를 정의하고
여기서 호출하는 것이죠.
우리는 커피 주문 시 가격을 계산하는
메소드를 만들고자 합니다.
현재는 submitOrder 메소드에서
직접 가격을 계산하지만
가격 계산 로직이 좀 더 복잡해지겠죠.
그러니 계산용 메소드로 이동해 봅시다.
이렇게 하면 코드 복붙을 이곳저곳에
하지 않고도 원할 때마다
호출할 수 있으니까요.
안드로이드 개발 경험이 쌓이면,
새 메소드를 만들어야 할 지
안 그래도 될 지에 대한
판단력이 생기게 될 겁니다.
시간과 경험이 쌓이면
자연스레 따라오게 되죠.
그러면, 우리는 이제 처음으로
MainActivity에 스스로
새 메소드를 만드는 거네요.
맨땅에서 시작하기 보다는
우선 올바른 메소드가 무엇인지
판단하는 법을, 짧은 코드 몇 개를
읽어보면서 알아보죠.
지시사항 노트에
3가지 선택지를 준비했습니다.
이 3개의 짧은 코드를 읽어보고
과연 어느 쪽이
주문 가격 계산 메소드를 올바로
수행하고 있는지 선택해 보세요.
지시사항 노트 안에 있는
링크를 클릭하시면,
A, B, C 세가지의 코드를
보실 수 있습니다.
여러분의 목표는
처음 보는 코드를 읽는 데
익숙해 지는 겁니다.
확실한 메소드를 만드는 정확한
규칙을 아직 우리는 배우지 않았지만
가장 정확한 코드가 이 중 무엇인지
한 번 추측해 보세요.
구글 서치를 통해
자바 메소드 정의에 관한 정보를
더 찾아 보시는 것도 좋습니다.
여러 다른 검색 결과를 클릭하다 보면
여러분이 이해하지 못하는 형식의
정보를 발견하게 될 거예요.
하지만 처음부터 다 알 필요는 없어요.
그냥 익숙해 지는 것만으로 충분합니다.
지금은 모르는 게 당연한 거니까요.
이해하는 정보만을 가지고
해당 내용을 훑어본 후,
문제와 연관된다고 생각되는 부분만
갖고 있으면 됩니다.
자, 이제 3가지 코드를 읽어 보고
인터넷에서 정보를 참조한 후
calculatePrice 메소드의
올바른 작성법을 추측해 보세요.
Vimos antes, que poderíamos
passar um número
para o método de exibição.
Vamos falar mais sobre as diferentes
entradas e saídas de um método.
Vamos olhar o método submitOrder
na MainActivity como exemplo.
Você tem várias linhas
de código nesse método.
Quando o usuário clica em Pedido,
ele irá acionar esse método submitOrder.
O dispositivo Android irá executar cada
uma destas instruções de cima para baixo,
e quando atingir a chamada
do método calculatePrice
irá pular para onde o método
calculatePrice está definido.
Digamos que este está definido na parte
inferior do arquivo MainActivity.
O dispositivo Android irá executar cada
uma dessas instruções de cima para baixo no método,
em seguida, voltará para o método submitOrder.
E continuará executando estas
instruções até chegar ao final do método.
Quando o método
calculatePrice é chamado,
nós podemos passar um monte
de entradas de modo
que quando executarmos
estas linhas de código,
podemos usar esses valores de entrada.
Como resultado deste método,
podemos passar um único valor
de retorno para quem o chamar.
Assim, o valor de saída pode ser usado
nas linhas de código subsequentes.
Em Java, nós chamamos as entradas
para um método de parâmetros de entrada,
podemos ter zero, ou mais,
parâmetros de entrada.
Em Java, chamamos
a saída de valor de retorno,
e podemos ter zero ou um valor de retorno.
Um exemplo de parâmetro
de entrada é passar a quantidade
para o método calculatePrice.
Desse modo, este método pode usar a quantidade
para saber o preço total do pedido.
Depois podemos repassar esse preço
total como valor de retorno.
E, então, no método submitOrder,
aqui em baixo,
podemos usar esse valor total para fazer
outras coisas, como exibi-lo na tela,
ou criar um recibo,
ou qualquer coisa do tipo.
Resumindo, aqui definimos o método
calculatePrice e aqui o chamamos.
Queremos criar um método para calcular
o preço de um pedido de café.
Atualmente, nós calculamos o preço
diretamente no método submitOrder,
a lógica para calcular o preço vai ficar
um pouco mais complicada.
Vamos movê-lo para seu próprio método.
Podemos depois chamá-lo as vezes que quisermos, sem copiar e colar o código em todos os lugares.
Quando ganha experiência com Android,
você adquire melhor julgamento sobre...
quando deve criar um novo método
para algo, ou quando não precisa.
Isso vai vir com mais experiência e tempo.
Bom, essa é a primeira vez que vamos criar
um método novo na MainActivity,
por nossa conta.
Em vez de começar escrevendo-o a partir do zero,
vamos começar por aprender a reconhecer o que é um método correto, lendo alguns trechos de código.
Assim, nas Notas do Instrutor,
vamos fornecer três opções.
Dê uma lida nesses três trechos
de código e determine qual
opção implementa corretamente
o método de cálcular o preço do pedido.
Ao clicar no link
nas notas do instrutor,
você verá que só tem código
para opções A, B, e C.
O objetivo aqui é fazer
você ficar confortável
com leitura de código
que você nunca viu antes.
Nós não vimos as regras exatas
que faz um método ser válido,
mas quero que dê seu melhor palpite sobre
qual opção você acha ser mais correta.
Eu também sugiro
que pesquise no Google
para obter mais informações sobre
como definir métodos Java.
Ao clicar nos diferentes
resultados de pesquisa,
você vai encontrar informações
na documentação que você não entende.
Mas eu quero que você se sinta
confortável em não entender tudo
sobre essas páginas,
porque é normal não entender tudo.
Tudo que você precisa fazer é apenas
separar os artigos pelo que você entende
acha que é relevante para
o problema em questão.
Então, vá e leia
o código relativo
essas três opções, procure
algumas informações on-line
e dê seu melhor palpite sobre como definir
corretamente o método calculatePrice.
Ранее мы увидели что можем
передать число в метод display.
Поговорим больше о разных
вводных и исходных метода.
Возьмем метод submitOrder
в MainActivity как пример.
Предположим, что есть множество
строк кода в этом методе.
Когда пользователь
нажмет на кнопку Order,
это вызовет метод submitOrder.
Устройство Android выполнит
все команды от верха до низа,
а когда доберется до
вызова метода calculatePrice,
то перейдет туда где
определен метод calculatePrice.
Допустим, что он определен
внизу файла MainActivity.
Устройство Android выполнит
все эти команды от верха до низа
метода, а потом вернется
в метод submitOrder.
И продолжит выполнение этих команд
пока не доберется до конца
метода.
При вызове метода calculatePrice,
мы передаем множество
исходных так, что
при выполнении этих строк кода
мы можем ипользовать эти исходные.
В результате этого метода
мы передаем одно значение
на выходе в вызывающую функцию.
Так значение на выходе можно исполь-
зовать со следующей строки кода.
В Java, мы называем исходные для
метода исходными параметрами и
их может быть 0 или больше.
В Java, мы называем данные на
выходе значением на выходе,
и их тоже может быть 0 или больше.
Пример исходного параметра -
это quantity, которое передается
в метод calculatePrice.
Так алгоритм может использовать
quantity для определения общей цены
заказа целиком.
Потом, мы можем передать общую цену
назад в качестве значения на выходе.
И в методе submitOrder вот здесь,
мы можем использовать общую цену
для других операций - для показа
на экране, создания чека и так далее.
Подытожим - здесь мы определяем
метод calculatePrice, а
здесь мы его вызываем.
Нам надо создать метод
определения цены заказа кофе.
Сейчас мы подсчитываем цену
в методе submitOrder, но
логика подсчета цены будет
немного более сложной.
Поэтому, давайте создадим
отдельный метод.
И вызовем его столько раз,
сколько нужно без копирования
кода везде.
По мере получения опыта в разработке
на Android, вы будете лучше понимать
когда надо создавать новый
метод и когда не надо.
Это придет с опытом и временем.
А сейчас мы в первый раз создадим
новый метод в MainActivity
самостоятельно.
Вместо того чтобы писать код
с нуля, мы начнем с понимания
кусков кода, чтобы определить
какой алгоритм нам подходит.
В заметках мы предоставим
вам на выбор три варианта.
Просмотри на эти три фрагмента
и определите какой
из них верно внедряет метод
вычисления цены заказа.
Когда вы пройдете
по ссылке в заметках,
вы увидите что есть код
для варианта А, В и С.
Цель в том,
чтобы вы научились
читать незнакомый код.
Мы еще не изучили все правила
составления правильного алгоритма, но
я хочу чтобы вы догадались
какой из вариантов правильный.
Советую вам использовать
поиск Google для
информации об определении
методов Java.
Среди разных результатов
поиска вы найдете
информацию из справочника,
которую вы не поймете.
Но я хочу чтобы вы не пугались того,
что не понимаете все на этих
страницах, потому что это
нормально - понимать не все.
Все что вам нужно - взять
из статей то, что вы понимаете, и
что вы считаете относится
к вашей проблеме.
Итак - прочитайте код для этих
трех вариантов, поищите
информацию онлайн и решите
как правильно назначить
метод calculatePrice.
Daha önce, görüntüleme metoduna
Bir numara geçirebileceğimizi gördük. .
Şimdi bir metodun farklı girdileri
Ve çıktısı hakkında konuşalım.
Şimdi örnek olarak Ana Aktivite'deki
Siparişi Gönder metoduna bakalım.
Bu metodda çok fazla
Satırınızın olduğunu düşünelim.
Kullanıcı Sipariş
Düğmesine tıkladığında,
Bu Siparişi Gönder
Metodunun çağrılmasını tetikler.
Android cihaz bu talimatların her
Birini en üstten en alta işler,
Ve Ücreti Hesapla metodunu çağırmaya
Tıkladığında o
Ücreti Hesapla metodunun
Tanımlandığı yere sıçrar.
Bunun Ana Aktivite dosyasının
En altında tanımlandığını düşünelim.
Android cihaz her talimatı
Metodun en üstünden altına dek
İşleyecek ve daha sonra
Siparişi Gönder metoduna sıçrayacaktır.
Daha sonra metodun sonuna
Gelene dek bu talimatları uygulamaya
Devam edecektir.
Ücreti Hesapla metodu
Çağrıldığında,
Bir sürü girdiyi geçebiliriz
Böylece bu kod satırlarını
Uygularken bu girdi değerlerini kullanabiliriz.
Bu metodun bir sonucu olarak,
Çağırana tek bir çıktı
Değeri geçirebiliriz.
Böylece çıktı değeri birden fazla
Kod satırında kullanılabilir.
Java'da girdileri girdi
Parametresi metoduna çağırıyoruz
Ve sıfır ya da daha fazla
Girdi parametremiz olabilir.
Java'da
Çıktıya bir geri dönüş değeri
Çağırırız ve sıfır ya da bir
Gibi bir geri dönüş değerimiz olur.
Bir girdi parametresinin örneği
Ücreti Hesapla metoduna
Miktarı geçirmektir.
Böylece, bu metod tüm siparişin
Toplam miktarını hesaplamak
İçin bu miktarı kullanabilir.
Daha sonra bu toplam ücreti
Geri dönüş değeri olarak geçirebiliriz.
Ve sonra Siparişi Gönder metodunda,
Burada,
Bu toplam ücreti, ekranda görüntülemek
Ya da fatura oluşturmak, veya benzer
Bir şey yapmak için kullanabiliriz.
Özetlemek gerekirse, burada
Ücreti Hesapla metodunu tanımlıyoruz
Ve burada da çağırıyoruz.
Bir kahve siparişinin ücretini
Hesaplamak için bir metod oluşturmak istiyoruz.
Şu anda, ücreti Siparişi Gönder
Metodunda doğrudan hesaplıyoruz
Ama ücreti hesaplamanın mantığı
Biraz daha karışık olacak.
Şimdi bunu kendi metodunun içine taşıyalım.
Sonra onu kodu heryere
Kopyalayıp yapıştırmadan
İstediğimiz kadar çağırabiliriz.
Android geliştirmede daha fazla deneyim elde ettikçe,
Bir şey için yeni bir metod geliştirmeniz
Gerekip gerekmediği hususunda da
Daha iyi karar verebilirsiniz.
Bu sadece daha faza deneyim ve
Daha fazla zamanla olabilir.
Şimdi, Ana Aktivite'de
Tek başımıza yeni bir metod
Oluşturacağımız ilk sefer
Bu olacak.
Bunu en baştan yazarak başlamak yerine,
Bazı kod parçalarını okuyarak
Doğru metodun ne olduğunu anlamayı
Öğrenmeye başlamak istiyoruz.
Öğretici notlarında size üç
Seçenek sunacağız.
Bu üç kod parçasını okuyun ve
Hangi seçeneğin
Siparişin ücretini hesaplamak için
Doğru metodu uyguladığını belirleyin.
Öğretici notlarındaki
Linke tıkladığınızda,
Bunun sadece A, B ve C
Seçenekleri için kodu olduğunu göreceksiniz.
Burada amaç sizin
Daha önce hiç görmediğiniz bir
Kodu okurken rahat olmanız.
Geçerli bir metodun ne olacağıyla ilgili
Kesin kurallar üzerinden gitmedik
Ama sizin en doğru olduğunu düşündüğünüz seçenekle
İlgili doğru tahmini yapmanızı istiyorum.
Aynı zamanda Java
Metodlarının nasıl tanımlandığıyla
İlgili daha fazla bilgi için
Google araması yapmanızı tavsiye ederim.
Farklı arama sonuçlarına
Tıkladığınızda belgeler üzerinde
Anlamadığınız değişik
Bilgilere rastlayacaksınız.
Ama sizin bu sayfalardaki
Herşeyi anlamamak konusunda da
Rahat olmanızı istiyorum, çünkü
Herşeyi anlamamanız gayet normal.
Tek yapmanız gereken makaleleri
Anladıklarınız konularda süzmek
Ve özellikle problemi çözmek
İçin gerekli olanları bulmak.
Haydi şimdi bu üç seçenek için
Kodu okuyun, çevrimiçi olarak
Bilgilere bakın ve sonra
Ücreti hesapla metodunu doğru
Şekilde tanımlama tahmininizi yapın.
Mới đây, bạn đã thấy ta có thể sử dụng
biến số trong phương thức hiển thị.
Hãy nói thêm về sự khác biệt giữa đầu ra
và đầu vào của một phương thức.
Hãy nhìn vào phương thức submitOder
trong MainActivity làm ví dụ.
Giả sử bạn có rất nhiều dòng
code trong phương thức đó.
Khi người dùng bấm
vào nút Order,
nó sẽ kích hoạt và triệu gọi
phương thức submitOrder này.
Thiết bị Android sẽ thực thi từng chỉ dẫn
một từ trên xuống dưới
và khi tới phương thức
calculatePrice, nó sẽ
nhảy tới phần mà phương thức
calculatePrice được định nghĩa.
Giả sử nó được định nghĩa
ở cuối tệp MainActivity.
Thiết bị Android sẽ thực thi từng chỉ dẫn
một theo thứ tự từ trên xuống dưới
của phương thức, sau đó sẽ
nhảy ngược về phương thức submitOrder.
Sau đó, nó sẽ tiếp tục thực hiện từng
chỉ dẫn một cho đến cuối cùng
của phương thức.
Khi phương thức calculatePrice
được triệu gọi,
chúng ta có thể sử dụng
rất nhiều đầu vào để mà
khi thực thi những dòng code này,
chúng ta có thể sử dụng giá trị đầu vào.
Nhờ có phương thức này,
chúng ta có thể trả mộ giá trị
đầu ra về lệnh gọi.
Theo cách này, giá trị đầu ra có thể
được sử dụng trong dòng code tiếp theo.
Trong Java, chúng ta gọi đầu vào
theo phương thức tham số đầu vào
và chúng ta có thể có 0
hoặc nhiều tham số đầu vào.
Đối với Java, chúng ta
gọi đầu ra là giá trị trả lại.
Và chúng ta có thể có 0
hoặc nhiều giá trị trả lai.
Một ví dụ về tham số đầu vào
là việc nhập số lượng
vào phương thức calculatePrice.
Nhờ đó, phương thức này có thể sử dụng
số lượng để tìm ra tổng giá trị
của toàn bộ đơn hàng.
Sau đó ta có thể trả về
tổng giá trị đơn hàng.
Và rồi trong phương thức
submitOrder ở dưới này,
chúng ta có thể sử dụng tổng giá trị đó
vào việc khác, như hiển thị lên màn hình
hoặc lập hóa đơn
hay cái gì tương tự như thế.
Tóm lại, đây là nơi chúng ta định nghĩa
phương thức calculatePrice, và
đây là nơi chúng ta gọi nó.
Chúng ta muốn thiết lập một phương thức
để tính toán giá trị của đơn hàng cà phê.
Hiện tại, chúng ta đang tính toán giá trị
trực tiếp bằng phương thức submitOrder
nhưng logic sử dụng để tính toán
sẽ trở nên hơi phức tạp một chút.
Vì vậy, hãy dời nó tới
phương thức riêng của nó.
Như thế ta có thể gọi nó bao nhiêu lần
cũng được mà không phải copy và dán
phần code khắp nơi.
Khi bạn có nhiều kinh nghiệm hơn với
phát triển Android, bạn sẽ có khả năng
đánh giá xem khi nào cần tạo phương thức
mới và khi nào không.
Chỉ cần thêm kinh nghiệm
và thêm thời gian.
Như vậy, đây sẽ là lần đầu tiên
chúng ta xây dựng
một phương thức mới
trên MainActivity.
Thay vì bắt đầu viết nó từ đầu,
chúng ta sẽ học cách nhận biết
đâu là phương thức đúng bằng cách
nghiên cứu một vài đoạn cốt.
Như vậy trong chú thích của tác giả,
chúng tôi sẽ cho bạn ba lựa chọn.
Hãy đọc ba đoạn code này
và xem xem đoạn nào
thực hiện chính xác phương thức
tính toán giá trị đơn hàng.
Khi bạn bấm vào đường dẫn
trong ghi chú của tác giả
bạn sẽ thấy nó chỉ có code
cho lựa chọn A, B, và C.
Mục đích ở đây là
giúp bạn thoải mái hơn khi đọc
những code bạn chưa bao giờ thấy.
Chúng ta vẫn chưa xem đến những nguyên tắc
để tạo nên một phương thức hợp lệ
nhưng tôi muốn bạn thử đoán xem
lựa chọn nào là chính xác nhất.
Tôi cũng khuyến khích bạn
tìm kiếm thêm thông tin
trên Google về cách
định nghĩa phương thức Java.
Khi bạn xem qua
những kết quả nhận được,
bạn sẽ bắt gặp những thông tin
trong tài liệu mà bạn không hiểu.
Nhưng tôi muốn bạn hãy thoải mái
với việc không hiểu hết mọi thứ
trên những trang đó, bởi vì việc không thể
hiểu được tất cả là hết sức bình thường.
Tất cả những gì bạn cần là lướt qua
những bài viết, tìm những gì bạn hiểu
và những gì bạn nghĩ là
liên quan tới vấn đề.
Vì vậy, hãy đọc đoạn code
cho ba lựa chọn đó, tìm kiếm
thêm thông tin trên mạng, và
đưa ra lựa chọn đâu là cách chính xác
để định nghĩa phương thức calculatePrice.
此前 我们看到 我们可以把一个数输入到 display 方法里
我们来讨论方法输入和输出的不同
将 MainActivity 里的 submitOrder 方法作为一个例子
在这个方法里有好多行的代码
当用户点击 Order 按钮时
它将触发 submitOrde 方法被调用
Android 设备将从上到下执行每一条指令
然后它将触发calculatePrice 方法被调用
它将跳到定义 calculatePrice 方法的地方
在 MainActivity 文件底部
Android 设备将从上到下执行方法里每一条指令
然后返回 submitOrder 方法
它将一直执行下去直到它触发了
方法的结束指令
当 calculatePrice 方法被调用的时候
我们可以输入一些值
这样当我们执行代码行的时候 就可以使用这些输入值
作为方法的结果
我们可以通过一个单一的输出值返回给调用者
通过这种方式 输出值可以在后续代码行使用
在 Java 里 我们所说的方法的输入参数
可以是零个或者更多的输入参数
在 Java 里 我们所说的输出一个返回值
我们可以有零个或一个返回值
举个输入参数的例子 输入 quantity
到 calculatePrice 方法里
这个方法能够使用 quantity 来计算出
整个订单的总价
然后 我们把总价作为一个返回值返回
在下面这个 submitOrder 方法里
我们能够用这个总价做一些其他的事 比如在屏幕上显示
创建收据 或者类似的事
总结一下 这是我们定义 calculatePrice 方法的地方
这是我们调用它的地方
我们希望创建一个方法来计算咖啡订单的价格
当前 我们在 submitOrder 方法里直接计算价格
但是计算价格的逻辑有一点复杂
所以我们用自己的方法来操作
这样就可以在需要的时候多次调用
不用在任何地方复制粘贴代码
随着 Android 开发经验的增加 判断能力也会得到提升
比如判断何时需要创建新方法何时不需要
这是需要经验和时间的
这是我们第一次创建一个新的方法
在我们自己的 MainActivity 里
不像开始的时候从头编写它 我们想通过阅读一些代码片段
来学着识别正确的方法
所以在讲师注释里 我们将会提供三个选项
阅读这三个代码片段
决定哪个选项是正确地实现了计算订单价格的方法
当你点击讲师注释里的链接时
你可以看到这只有代码选项A B C
这样做的目标是
让你在没有看过代码之前也能轻松阅读
我们没有介绍过创建一个有效方法准确规则
但是 我想要你做出你认为最正确的猜测
你也可以去 Google 搜索
关于定义 Java 方法的更多的信息
当你点击不同的搜索结果时
你一定看到文档里你不明白的信息
但是我希望即使你不理解页面上的这些内容 你依然感觉轻松轻松
因为它不理解任何东西是完全正常的
你需要做的只是浏览这些你能理解的文章
以及与你手头工作相关的文章
继续 阅读这三个选项的代码
看一些网上的信息 然后做出你最好的猜测
关于怎样正确地定义 calculatePrice 方法
早前,我們看過如何傳送一個數字到顯示程式。
2
00:00:04,370 --> 00:00:08,350
現在,我們會討論更多有關不同輸入及輸出的程式。
我們用MainActivity中的submitOrder程式作一個例子。
4
00:00:12,510 --> 00:00:15,000
舉例,如果你在那程式中有很多行的編碼,
5
00:00:15,000 --> 00:00:16,670
當用者按Order選項時,
會觸發和調用submitOrder程式。
Android裝置將會由上至下,執行每一條指令。
8
00:00:23,200 --> 00:00:26,980
當觸動到calculatePrice的程式調用時,
裝置會跳到calculatePrice的程式定義。
如果這個程式是定義在MainActivity最底部的檔案,
Android裝置將會由上至下,執行程式中的每一條指令,
然後再跳回SubmitOrder程式。
然後,裝置會繼續執行這些指令,直至觸到
程式的末端為止。
15
00:00:45,268 --> 00:00:47,240
當calculatePrice程式被調用的時候,
16
00:00:47,240 --> 00:00:49,510
我們可以把一堆輸入傳送過去,
當執行這些指令的時候,我們可以運用這些輸入值。
運用這個程式,
我們可以把單一輸出值傳送給調用者。
這樣子,輸出值可以在及後編碼中繼續使用。
21
00:01:03,030 --> 00:01:07,090
在Java,我們調用輸入到程式輸入參數,
22
00:01:07,090 --> 00:01:09,520
我們可以有零或更多輸入參數。
在Java,我們稱輸出為返回值,
24
00:01:13,370 --> 00:01:16,470
我們可以有零或一個返回值。
一個輸入參數的例子是傳送數量
26
00:01:20,420 --> 00:01:22,840
到calculatePrice程式。
這程式能使用數量,來計算訂單的
28
00:01:26,957 --> 00:01:28,130
的總價格。
然後,我們可以傳送總價格回到返回值。
30
00:01:31,350 --> 00:01:34,046
在下面的submitOrder程式中,
31
00:01:34,046 --> 00:01:38,253
我們可以用這個總價格做其他東西,例如在螢幕上顯示,或者
32
00:01:38,253 --> 00:01:40,930
建立收據等類似的任務。
總結一下,這就是我們定義calculatePrice的程式,
34
00:01:43,730 --> 00:01:45,400
以及調用其的方式。
35
00:01:45,400 --> 00:01:49,490
我們想建立一個程式,去計算每個咖啡訂單的價錢。
36
00:01:49,490 --> 00:01:53,410
目前,我們正使用submitOrder程式去計算價錢,不過
37
00:01:53,410 --> 00:01:57,020
計算價錢的邏輯將會變得複雜一點。
我們現在就開始這個新程式。
39
00:01:59,030 --> 00:02:01,948
然後我們可以不停調用這個程式,並且不用複製
粘貼編碼。
當你在Android開發獲得更多經驗時,你可以更有效判斷
什麼時候要建立或不建立新程式。
隨著更多經驗和時間,你將會取得更好的判斷。
44
00:02:14,690 --> 00:02:17,640
這將會是我們第一次在MainActivity建立
45
00:02:17,640 --> 00:02:20,800
新程式。
與其重頭編寫程式,我們倒不如先透過閱讀代碼片段,
47
00:02:24,575 --> 00:02:28,460
來學習什麼才是一個正確的程式。
在導師筆記內,我們會為你提供三個選項。
49
00:02:31,700 --> 00:02:35,830
細心閱讀這三個代碼片段,然後判斷
50
00:02:35,830 --> 00:02:40,330
那個選項能正確執行程式,從而去計算訂單的價錢。
51
00:02:40,330 --> 00:02:42,330
當你在導師筆記中點擊連結時,
你會看見A,B,C選項的編碼。
53
00:02:48,380 --> 00:02:49,290
這個練習的目的是
54
00:02:49,290 --> 00:02:53,360
要你熟習閱讀從未接觸過的編碼。
55
00:02:53,360 --> 00:02:57,370
雖然我們還未討論建立程式的正確規則,不過
56
00:02:57,370 --> 00:03:01,169
我希望你能選擇一個你認為最正確的答案。
57
00:03:02,630 --> 00:03:05,091
我亦鼓勵你在Google尋找
58
00:03:05,091 --> 00:03:09,140
多些有關定義Java程式的資料。
當你在閱讀不同的搜尋結果時,
60
00:03:11,450 --> 00:03:15,100
你將會遇到很多不明白的資料。
61
00:03:15,100 --> 00:03:18,290
不過我希望你能熟習和接受無法明白一切的事實,
62
00:03:18,290 --> 00:03:21,950
因為這是正常不過的。
63
00:03:21,950 --> 00:03:25,780
你需要做的,只是瀏覽一些你明白
64
00:03:25,780 --> 00:03:28,030
及認為對問題相關的文章。
現在請你閱讀這三個選項的編碼,
66
00:03:30,610 --> 00:03:34,260
在網上翻查資料,然後挑選
67
00:03:34,260 --> 00:03:37,627
你認為最能定義calculatePrice程式的選項。