Metode
4.1 Pengantar Metode
KONSEP:
Metode dapat dipakai untuk memecah suatu program kompleks menjadi
potongan-potongan kecil. Metode void dipakai untuk mengeksekusi sekelompok
statemen tanpa menghasilkan nilai balik. Metode penghasil-nilai menghasilkan
suatu nilai balik kepada statemen yang memanggilnya.
Secara umum, metode adalah sekumpulan
statemen yang melakukan pekerjaan tertentu. Sejauh ini, Anda telah menggunakan
metode-metode dalam dua cara:
· Anda telah menciptakan event handler. Event handler adalah sebuah metode
jenis khusus yang merespon event.
· Anda telah mengeksekusi metode-metode pustaka dari .NET Framework,
seperti MessageBox.Show dan
metode-metode TryParse.
Pada bab ini, Anda akan belajar bagaimana
menciptakan metode sendiri yang dapat dieksekusi seperti Anda mengeksekusi
metode-metode pustaka dari .NET Framework.
Gambar 4.1 Menggunakan satu runtun statemen yang
panjang untuk melakukan suatu pekerjaan
Metode umumnya dipakai untuk memecah suatu
permasalahan menjadi potongan-potongan yang lebih kecil. Daripada harus
menuliskan suatu metode yang panjang yang memuat semua statemen yang diperlukan
untuk menyelesaikan permasalahan, Anda bisa menuliskan beberapa metode
berukuran kecil yang masing-masing menyelesaikan bagian tertentu dari
permasalahan. Metode-metode berukuran kecil ini dapat dieksekusi dengan uruan
yang diinginkan untuk menyelesaikan permasalahan. Pendekatan ini disebut pula
dengan divide and conquer (bagi dan taklukkan) karena suatu permasalahan yang
besar dibagi menjadi permasalahan-permasalahan yang lebih kecil yang lebih
mudah diselesaikan. Gambar 4.1 dan Gambar 4.2 mengilustrasikan ide ini dengan
membandingkan dua program: satu yang menggunakan event handler kompleks dan
panjang yang memuat semua statemen yang diperlukan untuk menyelesaikan suatu
permasalahan dan program lain yang membagi suatu permasalahan menjadi
permasalahan-permasalahan yang lebih kecil, masing-masing ditangani oleh sebuah
metode terpisah.
Dengan kata lain, suatu program dapat dipecah menjadi unit-unit kode yang lebih kecil, seperti metode-metode, yang dikenal dengan program termodularisasi. Modularisasi cenderung menyederhanakan kode. Jika pekerjaan tertentu dilakukan pada beberapa tempat di dalam suatu program, suatu metode dapat dituliskan satu kali saja untuk melakukan pekerjaan itu dan kemudian dapat dieksekusi kapanpun ia diperlukan. Keuntungan dalam penggunaan metode ini dikenal dengan pendaur-ulangan kode karena Anda sedang menuliskan kode satu kali saja untuk melakukan suatu pekerjaan dan kemudian menggunakannya kembali setiap kali Anda perlu melakukan pekerjaan itu.
Metode void dan Metode Penghasil-Nilai
Pada bab ini, Anda akan belajar menuliskan
dua jenis metode: metode void dan metode penghasil-nilai. Ketika Anda memanggil
suatu metode void, ia hanya
mengeksekusi statemen-statemen yang dimuatnya dan kemudian berhenti. Ketika
Anda memanggil suatu metode penghasil-nilai, ia akan mengeksekusi
statemen-statemen yang dimuatnya dan kemudian ia akan menghasilkan suatu nilai
balik yang diberikan kepada statemen yang memanggilnya. Metode-metode TryParse merupakan contoh dari metode
penghasil-nilai. Jenis pertama yang akan Anda pelajari adalah metode void.
4.2 Metode void
KONSEP:
Metode void melakukan suatu pekerjaan dan kemudian berhenti. Ia tidak
menghasilkan nilai balik kepada statemen yang memanggilnya.
Untuk menciptakan suatu metode, Anda perlu
menuliskan definisinya. Definisi metode memiliki dua bagian: header dan tubuh.
Header metode, yang ditampilkan di awal dari definisi metode, memuat beberapa
hal penting tentang metode, mencakup nama metode. Tubuh metode adalah
sekumpulan statemen yang akan dilakukan ketika metode dieksekusi.
Statemen-statemen ini diapit di dalam kurung kurawal. Berikut adalah salah satu
contoh dari definisi metode:
private
void TampilPesan()
{
MessageBox.Show("Ini adalah metode TampilPesan.");
}
Header Metode
Dengan menggunakan definisi metode yang
ditunjukkan sebelumnya, Gambar 4.3 menunjukkan beberapa bagian dari header
metode, yang merupakan baris pertama dari definisi metode.
Amati kode lebih dekat:
· Pemodifikasi akses: Katakunci private
merupakan pemodifikasi akses. Ketika suatu metode dideklarasikan private, ia
hanya dapat dipanggil oleh kode yang ada di dalam kelas yang sama dengan metode
itu. Cara lain, suatu metode yang dideklarasikan public dapat dipanggil oleh kode yang ada di luar kelas. Ini
penting karena sejumlah aplikasi dapat memiliki beberapa kelas, dan kecuali
jika memang Anda bermaksud agar suatu metode dapat dipanggil dari luar kelas,
Anda sebaiknya mendeklarasikannya private.
· Tipe nilai balik: Ingat diskusi sebelumnya tentang
metode void dan metode
penghasil-nilai. Ketiak katakunci void
diberikan di sini, ini berarti bahwa metode ini adalah suatu metode void, dan ia tidak menghasilkan tipe
nilai balik. Seperti yang nanti Anda lihat pada bab ini, suatu metode
penghasil-nilai mencantumkan sebuah tipe data di sini.
· Nama metode: Anda sebaiknya memberikan setiap
metode sebuah nama yang deskriptif. Secara umum, aturan-aturan yang diterapkan pada penamaan
variabel berlaku pula pada penamaan metode. Metode pada contoh ini dinamai TampilPesan, sehingga Anda dapat dengan
mudah menebak apa yang dilakukan oleh metode ini: Ia menampilkan suatu pesan.
· Tanda kurung: Pada header, nama metode selalui diikuti oleh tanda kurung.
Seperti yang akan Anda lihat nanti pada bab ini, Anda kadangkala akan menuliskan deklarasi-deklarasi
tertentu di dalam kurung, tetapi untuk sekarang, tanda kurung ini dibiarkan
kosong.
Tubuh Metode
Diawali pada baris setelah header metode,
satu atau lebih statemen ditempatkan di dalam kurung kurawal ({ }).
Statemen-statemen ini merupakan tubuh metode dan dieksekusi setiap kali metode
dipanggil.
Ketika Anda menuliskan sebuah definisi
metode, Visual Studio secara otomatis akan mengindentasi (mengatur tata-letak)
statemen-statemen di dalam tubuh metode. Indentasi ini tidak diharuskan, tetapi
ia membuat kode lebih mudah dibaca dan didebug. Dengan mengindentasi
statemen-statemen di dalam tubuh metode, Anda secara visual dapat membedakannya
dari kode lainnya.
Mendeklarasikan Metode Di Dalam Sebuah Kelas
Metode biasanya berada di dalam suatu kelas,
jadi Anda perlu menuliskan definisi metode di dalam kelas dimana ia menjadi
bagian dari kelas itu. Pada bab ini, semua metode yang akan Anda tuliskan akan
menjadi bagian dari kelas Form1.
Ketika Anda menuliskan suatu definisi metode, Anda akan menuliskannya di dalam
kelas Form1, seperti ditunjukkan
pada Gambar 4.4.
Memanggil Suatu Metode
Sebuah metode dieksekusi ketika ia dipanggil.
Event handler dipanggil ketika event tertentu terjadi, tetapi metode-metode
lain dieksekusi oleh statemen pemanggil metode. Ketika sebuah metode dipanggil,
program akan melompat ke definisi metode itu dan mengeksekusi statemen-stetemen
yang ada di dalam tubuhnya. Berikut adalah sebuah contoh statemen pemanggil
metode yang memanggil metode TampilPesan
yang sebelumnya telah didefinisikan:
TampilPesan();
Statemen ini hanyalah nam dari metode yang
diikuti dengan tanda kurung. Karena ia merupakan statemen, ia harus diakhiri
dengan titik-koma.
Lihat sebuah program utuh yang menggunakan
metode TampilMetode. Anda akan
menemui projek dengan nama Metode Sederhana di dalam CD yang menyertai
buku ini. Gambar 4.5 menunjukkan form aplikasi, dan Program 4.1 menunjukkan
kode form.
Program 4.1 Kode utuh untuk Form1 pada aplikasi Metode
Sederhana
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Metode_Sederhana
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
private
void tombolGo_Click(object sender, EventArgs e)
{
MessageBox.Show("Ini adalah metode tombolGo_Click.");
TampilPesan();
MessageBox.Show("Kembali di dalam metode tombolGo_Click");
}
private
void TampilPesan()
{
MessageBox.Show("Ini adalah metode TampilPesan.");
}
}
}
|
Amati kode lebih dekat: Ketika user mengklik
tombol Go, event handler tombolGo_Click akan dieksekusi. Di
dalam event handler ini, statemen pada baris 22 menampilkan Ini adalah metode tombolGo_Click pada
suatu kotak pesan. Kemudian, baris 23 memanggil metode TampilPesan. Seperti ditunjukkan pada Gambar 4.6, program akan
melompat ke definisi metode TampilPesan
dan mengeksekusi statemen-statemen di dalam tubuhnya. Hanya ada satu statemen
di dalam tubuh dari metode TampilPesan,
pada baris 29. Statemen ini menampilkan Ini
adalah metode TampilPesan, dan
kemudian metode berakhir. Seperti ditunjukkan pada Gambar 4.7, program akan
melompat kembali ke bagian program yang memanggil metode TampilPesan dan memulai kembali eksekusi dari titik itu. Pada kasus
ini, program akan memulai eksekusi pada baris 24, yang menampilkan Kembali di dalam metode tombolGo_Click.
Event handler tombolGo_Click
berakhir pada baris 25.
Ketika suatu metode dipanggil, sejumlah
operasi dilakuan “di balik layar” sehingga sistem akan mengetahui ke mana
program akan kembali setelah metode berakhir. Pertama, sistem menyimpan alamat
memori dari lokasi ke mana ia akan kembali. Ini umumnya merupakan statemen yang
ada setelah statemen pemanggil metode. Lokasi memori itu dikenal dengan titik
balik. Kemudian, sistem melompat ke metode dan mengeksekusi statemen-statemen
yang ada di dalam tubuhnya. Ketika metode selesai dieksekusi, sistem melompat
kembali ke titik balik dan memulai kembali eksekusi.
Pada Tutorial 4.1, Anda akan berlatih
menuliskan dan memanggil metode.
Tutorial 4.1: Menciptakan dan Memanggil Metode
Di dalam CD
yang menyertai buku ini, Anda akan mendapai sebuah projek dengan nama Lampu. Pada tutorial ini, Anda akan
menciptakan projek tersebut untuk mensimulasikan sebuah lampu yang dihidupkan
atau dimatikan. Form projek ditampilkan pada Gambar 4.8.
Berikut merupakan detil tentang pengaturan-pengaturan properti:
·
Properti Visible dari kontrol
pbLamuHidup awalnya ditetapkan true.
·
Properti Visible dari kontrol
pbLampuMati awalnya ditetapkan false.
·
labelStatus menampilkan HIDUP atau MATI ketika aplikasi dijalankan untuk mengindikasikan apakah lampu
hidup atau mati. Awalnya, properti Text
dari kontrol ini ditetapkan HIDUP.
Pada saat
aplikasi dijalankan, ketika user mengklik tombol Tukar Lampu, status
lampu akan dibalik. Dengan kata lain, jika lampu sedang hidup, ia akan
dimatikan. Jika lampu sedang mati, ia akan dihidupkan.
Ketika lampu
hidup, aksi-aksi berikut terjadi:
·
Properti Visible dari kontrol
pbLampuHidup ditetapkan true.
·
Properti Visible dari kontrol
pbLampuMati ditetapkan false.
·
Properti Text dari label labelStatus ditugaskan string “HIDUP”.
Ketika lampu
hidup, aksi-aksi berikut terjadi:
·
Properti Visible dari kontrol
pbLampuMati ditetapkan true.
·
Properti Visible dari kontrol
pbLampuHidup ditetapkan false.
·
Properti Text dari label labelStatus ditugaskan string “MATI”.
Untuk
memodularisasi kode, Anda menciptakan sebuah metode dengan nama HidupkanLampu (yang memuat kode untuk
menghidupkan lampu), dan sebuah metode lain dengan mati MatikanLampu (yang memuat kode untuk mematikan lampu). Ketika Anda
perlu menghidupkan lampu, Anda memanggil metode HidupkanLampu dan ketika Anda perlu mematikan lampu, Anda memanggil
metode MatikanLampu.
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka
projek dengan nama Lampu.
Langkah 2: Buka form Form1
pada mode Designer. Form
ditampilkan, berikut dengan nama dari tiap kontrol pada Gambar 4.8.
Langkah 3: Pindakan kontrol-kontrol agar saling menindih satu sama
lain, seperti ditunjukkan pada Gambar 4.9. (Pada gambar, kontrol pbLampuHidup berada di atas, tetapi
tidak masalah kontrol mana yang ada di atas). Selain itu, kurangi lebar form
dan posisikan kontrol-kontrol Button
seperti ditunjukkan pada gambar.
Langkah 4:
Program 4.2, di akhir dari tutorial ini, menunjukkan kode utuh dari form. Buka
editor kode dan ketikkan kode untuk metode HidupkanLampu
dan MatikanLampu, yang ditunjukkan
pada baris 20-42 pada Program 4.2.
Amati kode
lebih dekat. Baris 20 merupakan awal dari sebuah metode dengan nama HidupkanLampu. Tujuan dari metode ini
adalah untuk mensimulasikan lampu yang sedang hidup. Ketika metode ini
dieksekusi, baris 23 akan membuat kontrol pbLampuHidup
terlihat, baris 26 membuat kontrol pbLampuMati
tersembunyi, dan baris 29 menetapkan properti Text dari kontrol labelStatus
menjadi “HIDUP.
Baris 32
merupakan awal dari sebuah metode dengan nama MatikanLampu. Tujuan dari metode ini adalah untuk mensimulasikan
lampu yang sedang mati. Ketika metode ini dieksekusi, baris 35 akan membuat
kontrol pbLampuMati terlihat, baris
38 membuat kontrol pbLampuHidup
tersembunyi, dan baris 41 menetapkan properti Text dari kontrol labelStatus
menjadi “MATI.
Langkah 5: Selanjutnya, Anda menciptakan event handler Click untuk kontrol-kontrol Button. Kembali ke mode Designer dan klik ganda kontrol tombolTukar. Ini membuka editor kode,
dan Anda akan melihat sebuah event handler kosong dengan nama tombolTukar_Click. Sempurnakan event
handler tukarTombol_Click dengan
mengetikkan kode yang ditunjukkan pada baris 46-54 pada Program 4.2. Amati kode
ini. Statemen if pada baris 47
menentukan apakah kontrol pbLampuHidup
visibel. Jika ya, ini berarti lampu sedang hidup, jadi statemen pada baris 49
memanggil metode MatikanLampu untuk
mematikan lampu. Sebaliknya, klausa else
pada baris 51 mengambil alih, dan metode HidupkanLampu
dipanggil pada baris 53 untuk menghidupkan lampu.
Langkah 6: Kembali ke mode Designer
dan klik ganda pada kontrol tombolKeluar.
Pada editor kode, Anda akan melihat sebuah event handler kosong dengan nama tombolKeluar_Click. Sempurnakan event
handler tombolKeluar_Click dengan
mengetikkan kode yang ditunjukkan pada baris 59-60 pada Program 4.2.
Langkah 7: Simpan projek dan jalankan aplikasi. Ketika aplikasi
dijalankan, klik tombol Tukar Lampu beberapa kali untuk
mensimulasikan hidup matinya lampu. Ketika selesai, klik tombol Keluar untuk
mengakhiri aplikasi.
Program 4.2 Kode utuh untuk Form1
pada aplikasi Lampu
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Lampu
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
private
void HidupkanLampu()
{
//Menampilkan citra "lampu hidup"
pbLampuHidup.Visible = true;
//Menyembunyikan citra "lampu mati"
pbLampuMati.Visible = false;
//Menampilkan status lampu
labelStatus.Text = "HIDUP";
}
private
void MatikanLampu()
{
//Menampilkan citra "lampu mati"
pbLampuMati.Visible = true;
//Menyembunyikan citra "lampu hidup"
pbLampuHidup.Visible = false;
//Menampilkan status lampu
labelStatus.Text = "MATI";
}
private
void tombolTukar_Click(object sender, EventArgs e)
{
//Membalik status lampu
if
(pbLampuHidup.Visible == true)
{
MatikanLampu();
}
else
{
HidupkanLampu();
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
4.3 Melewatkan Argumen Kepada Metode
KONSEP:
Argumen adalah sepenggal data yang dilewatkan kepada suatu metode ketika metode
dipanggil. Parameter adalah sebuah variabel yang menerima suatu argumen yang
dilewatkan kepada metode.
Kadangkala adalah berguna untuk tidak hanya
memanggil metode, tetapi juga mengirim satu atau lebih potongan data kepada
metode. Potongan data yang dikirim ke suatu metode dikenal sebagai argumen.
Metode dapat menggunakan argumen-argumennya dalam perhitungan atau operasi
lain.
Anda telah sangat familiar dengan bagaimana
menggunakan argumen pada suatu pemanggilan metode. Sebagai contoh, lihat pada
statemen berikut:
MessageBox.Show("Hallo");
Statemen ini memanggil metode MessageBox.Show dan melewatkan string
“Hallo” sebagai argumen. Berikut adalah salah satu contohnya:
nilai = int.Parse(str);
Asumsikan bahwa nilai adalah sebuah variabel int
dan str adalah sebuah variabel string. Statemen ini memanggil metode int.Parse, yang melewatkan variabel str sebagai argumen.
Jika Anda menuliskan suatu metode dan Anda
menginginkannya untuk menerima argumen-argumen ketika metode itu dipanggil,
maka Anda perlu memperlengkapi metode dengan satu atau lebih variabel
parameter. Variabel parameter, atau parameter saja, merupakan sebuah variabel
spesial yang menerima suatu argumen ketika metode dipanggil. Berikut adalah
sebuah contoh metode yang memiliki sebuah variabel parameter:
private void TampilNilai(int nil)
{
MessageBox.Show(nil.ToString());
}
Perhatikan deklarasi variabel int yang ada di dalam kurung (int nil). Ini merupakan deklarasi dari
sebuah variabel parameter, yang mengaktifkan metode TampilNilai untuk menerima sebuah nilai int sebagai argumen. Berikut adalah sebuah contoh pemanggilan terhadap
metode TampilNilai, yang melewatkan
5 sebagai argumen:
TampilNilai(5);
Statemen ini mengeksekusi metode TampilNilai. Argumen yang dicantumkan
di dalam kurung ditugaskan kepada variabel parameter dari metode, nil. Ini diilustrasikan pada Gambar 4.10.
Di dalam metode TampilNilai, variabel nil
akan memuat nilai dari argumen yang dilewatkan kepadanya. Jika Anda melewatkan
5 sebagai argumen, metode akan menampilkan nilai 5 pada suatu kotak pesan.
Anda juga dapat melewatkan isi dari variabel
dan nilai dari ekspresi sebagai argumen. Sebagai contoh, statemen-statemen
berikut memanggil metode TampilNilai
dengan sejumlah argumen berbeda yang dilewatkan:
TampilNilai(x);
TampilNilai(x
* 4);
TampilNilai(int.Parse("700"));
Statemen pertama sederhana. Ia melewatkan
nilai dari variabel x sebagai argumen kepada metode TampilNilai. Statemen kedua juga sederhana, tetapi ia melakukan
pekerjaan yang lebih banyak: ia melewatkan hasil dari ekspresi x * 4 sebagai
argumen kepada metode TampilNilai.
Statemen ketiga melakukan pekerjaan lebih banyak lagi. Ia melewatkan nilai yang
dihasilkan dari int.Parse sebagai
argumen kepada metode TampilNilai.
(Metode int.Parse dipanggil lebih
dahulu, dan nilai baliknya dilewatkan kepada metode TampilNilai).
Pada CD yang menyertai buku ini, Anda akan
mendapati sebuah projek dengan nama Demo
Argumen yang mendemonstrasikan
metode ini. Gambar 4.11 menunjukkan form aplikasi dan Program 4.3 menunjukkan
kode form.
Program 4.3 Kode utuh untuk Form1
pada aplikasi Demo Argumen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Demo_Argumen
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
private
void TampilNilai(int nil)
{
MessageBox.Show(nil.ToString());
}
private
void tombolDemo1_Click(object sender, EventArgs e)
{
//Memanggil TampilNilai dengan melewatkan 5 sebagai argumen
TampilNilai(5);
}
private
void tombolDemo2_Click(object sender, EventArgs e)
{
//Memanggil TampilNilai dengan melewatkan ekspresi 3 + 5
//sebagai argumen
TampilNilai(3 + 5);
}
private
void tombolDemo3_Click(object sender, EventArgs e)
{
//Menggunakan loop untuk memanggil TampilNilai 5 kali
for
(int hitung = 0; hitung < 5; hitung++)
{
TampilNilai(hitung);
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Form ini memiliki empat kontrol tombol, dan
sebuah event handler Click telah
dituliskan untuk setiap kontrol itu. Selain event handler, kode juga memuat
metode TampilNilai, yang telah
didiskusikan sebelumnya, pada baris 20-23.
Jika Anda menjalankan aplikasi dan mengklik
tombol Demo1, maka event handler tombolDemo1_Click akan dieksekusi.
Perhatikan pada baris 28 bahwa metode TampilNilai
dipanggil, dengan melewatkan 5 sebagai argumen. Ini menyebabkan sebuah kotak
pesan ditampilkan yang menunjukkan nilai 5.
Jika Anda mengklik tombol Demo2, maka event handler tombolDemo2_Click akan dieksekusi. Pada
baris 35, metode TampilNilai
dipanggil, dengan melewatkan ekspresi 3 + 5 sebagai argumen. Ini menyebabkan
suatu kotak pesan ditampilkan yang menunjukkan nilai 8.
Jika Anda mengklik tombol Demo 3, maka event handler tombolDemo3_Click akan dieksekusi. Pada
baris 41, sebuah loop for dieksekusi
lima kali, setiap kali melewatkan variabel hitung
sebagai argumen. Ini menyebabkan suatu kotak pesan ditampilkan lima kali, yang
menunjukkan nilai 0 sampai 4.
Pada Tutorial 4.2, Anda akan menciptakan
sebuah aplikasi yang memanggil suatu metode dan melewatkan sebuah argumen
kepadanya.
Tutorial 4.2: Melewatkan Sebuah Argumen Kepada Suatu
Metode
Pada tutorial
ini, Anda menciptakan sebuah projek dengan nama Kartu. Form projek, yang
ditampilkan pada Gambar 4.12a, telah diciptakan untuk Anda. Kontrol-kontrol PictureBox menunjukkan tiga citra
kartu. Setiap properti Visible dari
kontrol PictureBox ditetapkan false, jadi ia awalnya ia tidak
ditampilkan saat aplikasi dijalankan. Saat aplikasi dijalankan, user dapat
memilih nama kartu dari ListBox,
dengan mengklik tombol Tampilkan Kartu, dan citra terseleksi akan
ditampilkan.
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka
projek dengan nama Kartu.
Langkah 2: Program 4.4, pada akhir dari tutorial ini, menunjukkan
kode utuh dari projek. Buka editor kode dan ketikkan komentar dan kode untuk
metode TampilKartu, yang ditunjukkan
pada baris 20-36 pada Program 4.4.
Tujuan dari
metode TampilKartu adalah untuk
menampilkan salah satu kontrol PictureBox.
Amati kode ini lebih dekat:
Baris 22: Ini adalah awal dari metode. Metode ini memiliki sebuah
parameter string dengan nama kartu. Ketika Anda memanggil metode, Anda
melewatkan item yang diseleksi user pada ListBox
sebagai argumen, dan metode menampilkan kartu tertentu.
Baris 24-35: Ini merupakan sebuah statemen switch yang menguji nilai
dari parameter kartu. Jika kartu sama dengan “As Waru”, maka
program akan melompat ke statemen case
pada baris 26 dan memanggil metode TampilAsWaru
pada baris 27. Jika kartu sama
dengan “10 Hati”, maka program akan melompat ke statemen case pada baris 29 dan memanggil metode TampilSepuluhHati pada baris 30. Jika kartu sama dengan “Raja
Keriting”, maka program akan melompat ke statemen case pada baris 32 dan
memanggil metode TampilRajaKeriting
pada baris 33.
Langkah 3: Ketikkan komentar dan kode untuk metode TampilAsWaru, seperti ditunjukkan pada
baris 38-45 pada Program 4.4. Metode ini membuat kontrol pbAsWaru terlihat, dan kontrol-kontrol PictureBox menjadi tidak terlihat.
Langkah 4: Ketikkan komentar dan kode untuk metode TampilSepuluhHati, seperti ditunjukkan
pada baris 47-54 pada Program 4.4. Metode ini membuat kontrol pbSepuluhHati terlihat, dan
kontrol-kontrol PictureBox menjadi
tidak terlihat.
Langkah 5: Ketikkan komentar dan kode untuk metode TampilRajaKeriting, seperti ditunjukkan
pada baris 56-63 pada Program 4.4. Metode ini membuat kontrol pbRajaKeriting terlihat, dan kontrol-kontrol
PictureBox menjadi tidak terlihat.
Langkah 6: Selanjutnya, Anda menciptakan event-event handler untuk
kontrol-kontrol Button. Kembali ke
mode Designer dan klik ganda pada
kontrol tombolTampil. Ini akan
membuka editor kode, dan Anda akan melihat sebuah event handler kosong dengan
nama tombolTampil_Click. Sempurnakan
event handler tombolTampil_Clik
dengan menuliskan kode yang ditunjukkan pada baris 67-76 pada Program 4.4.
Amati kode
ini lebih dekat. Statemen if pada
baris 68 menentukan apakah user telah memilih sebuah item pada kotakListKartu. Jika sebuah nilai telah
diseleksi, baris 70 akan memanggil metode TampilKartu.
Perhatikan bahwa item yang diseleksi pada ListBox
(dikonversi menjadi sebuah string) dilewatkan sebagai argumen. Jika user tidak
memilih item apapun pada kontrol kotakListKartu,
klausa else pada baris 72 akan
mengambil alih, dan baris 74-75 akan menampilkan suatu kotak pesan yang
memberitahu user untuk memilih sebuah kartu.
Langkah 7: Kembali ke mode Designer
dan klik ganda pada kontrol tombolKeluar.
Pada editor kode, Anda akan melihat sebuah event handler kosong dengan nama tombolKeluar_Click. Sempurnakan event
handler ini dengan menuliskan kode yang ditunjukkan pada baris 81-82 pada
Program 4.4.
Langkah 8: Simpan projek dan jalankan aplikasi. Uji aplikasi
dengan memilih nama dari tiap kartu pada ListBox
dan klik tombol Tampilkan Kartu. Ketika selesai, klik tombol Keluar untuk mengakhiri aplikasi.
Program 4.4 Kode utuh untuk Form1
pada aplikasi Kartu
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Kartu
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
TampilKartu menerima sebuah string yang memuat nama
//dari
kartu terseleksi, dan menampilkan kartu
private
void TampilKartu(string kartu)
{
switch (kartu)
{
case "As Waru" :
TampilAsWaru();
break;
case "10 Hati":
TampilSepuluhHati();
break;
case "Raja Keriting":
TampilRajaKeriting();
break;
}
}
//Metode
TampilAsWaru membuat As Waru
//visibel
dan kartu lain tidak visibel
private
void TampilAsWaru()
{
pbAsWaru.Visible = true;
pbSepuluhHati.Visible = false;
pbRajaKeriting.Visible = false;
}
//Metode
TampilSepuluhHati membuat 10 Hati
//visibel
dan kartu lain tidak visibel
private
void TampilSepuluhHati()
{
pbSepuluhHati.Visible = true;
pbAsWaru.Visible = false;
pbRajaKeriting.Visible = false;
}
//Metode
TampilRajaKeriting membuat Raja Keriting
//visibel
dan kartu lain tidak visibel
private
void TampilRajaKeriting()
{
pbRajaKeriting.Visible = true;
pbAsWaru.Visible = false;
pbSepuluhHati.Visible = false;
}
private
void tombolTampil_Click(object sender, EventArgs e)
{
//Jika sebuah kartu diseleksi pada ListBox, tampilkan kartu itu
if
(kotakListKartu.SelectedIndex != -1)
{
TampilKartu(kotakListKartu.SelectedItem.ToString());
}
else
{
MessageBox.Show("Silahkan pilih sebuah kartu dari " +
"kotak list.");
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Kompatibilitas Tipe Data Argumen dan Parameter
Ketika Anda melewatkan sebuah argumen kepada
metode, tipe data argumen harus kompatibel dengan tipe data dari parameter
penerima. Jika tidak, error akan terjadi ketika Anda mencoba mengkompilasi
kode. Anda telah mempelajari kompatibilitas kode. Berikut adalah simpulan
bagaimana menerapkan pelewatan argumen ketika menggunakan string, int, double, dan decimal:
·
Anda hanya dapat melewatkan argumen string kepada parameter string.
· Anda dapat melewatkan argumen int kepada parameter int, tetapi Anda tidak dapat melewatkan argumen double atau decimal kepada parameter int.
· Anda dapat melewatkan argumen double
atau int kepada parameter double, tetapi Anda tidak dapat
melewatkan nilai decimal kepada
parameter double.
· Anda dapat melewatkan argumen decimal
atau int kepada parameter decimal, tetapi Anda tidak dapat
melewatkan nilai double kepada
parameter decimal.
Skop Variabel Parameter
Ingat bahwa skop dari sebuah variabel adalah
bagian program dimana variabel itu dapat diakses. Sebuah variabel dapat diakses
hanya oleh statemen-statemen yang ada di dalam skop variabel. Skop dari sebuah
variabel parameter adalah metode dimana di dalamnya parameter dideklarasikan.
Statemen di luar statemen tidak bisa mengakses variabel parameter.
Melewatakan Lebih Dari Satu Argumen
Seringkali, adalah berguna untuk melewatkan
lebih dari satu argumen kepada metode. Kode berikut menunjukkan sebuah metode
yang menerima dua argumen. Nama metode adalah TampilMaks. Ia menerima dua argumen int dan menampilkan nilai dari argumen yang terbesar dari keduanya.
Jika kedua argumen bernilai sama, ia menampilkan sebuah pesan yang
mengindikasikannya.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
private void TampilMaks(int angka1,
int angka2)
{
if (angka1== angka2)
{
MessageBox.Show("Kedua nilai sama.");
}
else if (angka1> angka2)
{
MessageBox.Show(angka1+ " adalah yang terbesar.");
}
else
{
MessageBox.Show(angka2+
" adalah yang terbesar.");
}
}
|
Perhatikan bahwa dua variabel parameter, angka1 dan angka2, dideklarasikan di dalam kurung pada header metode (baris
1). Ini seringkali disebut dengan daftar parameter. Selain itu perhatikan bahwa
sebuah koma memisahkan deklarasi tersebut. Berikut adalah sebuah contoh
statemen yang memanggil metode ini:
TampilMaks(5, 10);
Statemen ini melewatakn argumen 5 dan 10
kepada metode. Argumen-argumen dilewatkan kepada varibel-variabel parameter
sesuai dengan posisinya. Dengan kata lain, argumen pertama dilewatkan kepada
variabel parameter pertama, argumen kedua dilewatkan kepada variabel parameter
kedua, dan seterusnya. Jadi, statemen ini menyebabkan 5 dilewatkan kepada
parameter angka1 dan 10 dilewatkan
kepada parameter angka2. Ini
diilustrasikan pada Gambar 4.13.
Dimisalkan bahwa Anda membalik urutan argumen
yang dicantumkan pada pemanggilan metode, seperti berikut:
TampilMaks(10, 5);
Ini menyebabkan 10 dilewatkan kepada parameter angka1 dan 5 dilewatkan kepada parameter angka2. Contoh kode berikut menunjukkan contoh lain. Kali ini, Anda melewatkan variabel-variabel sebagai argumen-argumen:
int
nilai1 = 2;
int
nilai2 = 3;
TampilMaks(nilai1,
nilai2);
Ketika metode TampilMaks dieksekusi sebagai akibat dari kode ini, parameter angka1 akan memuat 2 dan parameter angka2 akan memuat 3.
Argumen Bernama
Selain pendekatan konvensional dari pelewatan
argumen posisional (dimana argumen pertama dilewatkan kepada parameter pertama,
argumen kedua dilewatkan kepada parameter kedua, dan seterusnya), C# juga membolehkan
Anda untuk menetapkan parameter mana yang akan menerima argumen yang
dilewatkan. Untuk menetapkan variabel parameter yang menerima argumen, Anda
menggunakan format berikut dalam menuliskan argumen pada pemanggilan metode:
namaParameter : nilai
Dalam format ini, namaParameter adalah nama dari sebuah variabel parameter dan nilai adalah nilai yang sedang
dilewatkan. Sebuah argumen yang dituliskan menggunakan sintaksis ini dikenal
sebagai argumen bernama. Untuk mendemonstrasikannya, lihat pada metode berikut:
private void TampilNama(string namaDepan, string namaBelakang)
{
MessageBox.Show(namaDepan
+ " " + namaBelakang);
}
Statemen berikut menunjukkan bagaimana metode
dapat dipanggil menggunakan argumen-argumen bernama:
TampilNama(namaBelakang : "Kristof", namaDepan :
"John");
Statemen ini menetapkan bahwa “Kristof”
dilewatkan kepada parameter namaBelakang
dan “John” dilewatkan kepada parameter namaDepan.
Anda mendapatkan hasil yang sama jika Anda memanggil metode seperti ini,
menggunakan argumen-argumen posisional:
TampilNama("John",
"Kristof");
Argumen Default
Dalam C#, Anda bisa menyediakan argumen
default untuk parameter metode. Ketika argumen default disediakan, adalah
dimungkinkan untuk memanggil metode tanpa secara eksplisit melewatakan argumen
kepada parameter. Berikut adalah sebuah contoh metode yang memiliki sebuah
parameter dengan suatu argumen default:
private void TampilPajak(decimal harga,
decimal persenPajak = 0.07m)
{
//Menghitung pajak
decimal pajak = harga * persenPajak;
//Menampilkan pajak
MessageBox.Show("Pajak sebesar Rp. " + pajak.ToString());
}
Pada definisi metode ini, sebuah argumen
default disediakan untuk parameter persenPajak.
Perhatikan bahwa nama parameter diikuti dengan tanda sama-dengan dan sebuah
nilai. Nilai yang mengikuti tanda sama-dengan adalah argumen default. Pada
kasus ini, nilai 0.07m adalah argumen default untuk parameter persenPajak. Karena parameter persenPajak memiliki sebuah argumen
default, Anda memiliki opsi untuk mengabaikan argumen untuk parameter itu
ketika Anda memanggil metode. Berikut adalah contohnya:
TampilPajak(100.0m);
Statemen ini memanggil metode TampilPajak, dengan melewatkan nilai
100.0m sebagai argumen untuk parameter harga.
Karena Anda tidak melewatkan argumen kepada parameter persenPajak, nilai parameter itu menjadi 0.07m. Jika Anda ingin
parameter persenPajak untuk memiliki
nilai yang berbeda, Anda dapat menetapkan argumen untuknya ketika Anda
memanggil metode, seperti berikut:
TampilPajak(100.0m,
0.08m);
Statemen ini memanggil metode TampilPajak, dengan melewatkan 100.0m
kepada argumen untuk parameter harga
dan 0.08m sebagai argumen untuk parameter persenPajak.
Berikut adalah beberapa detil yang perlu
diingat ketika menggunakan argumen default:
· Argumen default harus berupa literal atau konstanta. Anda tidak bisa
menetapkan variabel sebagai argumen default.
· Anda dapat menyediakan argumen default untuk semua parameter pada suatu
metode. Namun, ketika hanya sebagian parameter saja yang memiliki argumen
default (seperti pada contoh sebelumnya), Anda harus mendeklarasikan parameter
dengan argumen default di akhir. Sebagai contoh, error kompilasi akan terjadi
jika Anda menuliskan header metode TampilPajak
seperti ditunjukkan di sini:
//Header metode ilegal
private void TampilPajak(decimal persenPajak =
0.07m, decimal harga)
· Ketika sebuah metode memiliki beberapa parameter dengan argumen default
dan Anda mengabaikan salah satu argumen ketika Anda memanggil metode, maka Anda
perlu mengabaikan semua argumen yang ada setelah argumen itu.
Melewatkan Argumen Dengan Nilai
Semua program contoh yang telah Anda lihat
sejauh ini melewatkan argumen dengan nilai. Variabel argumen dan variabel
parameter merupakan item-item terpisah di dalam memori. Ketika argumen
dilewatkan dengan nilai, hanya salinan dari nilai argumen dilewatkan kepada
variabel parameter. Jika isi dari variabel parameter diubah di dalam metode, ia
tidak memengaruhi argumen pada bagian pemanggil dari program.
Sebagai contoh, kode berikut didapati pada
projek di dalam CD yang menyertai buku ini dengan nama Melewatkan Dengan Nilai. Ketika Anda menjalankan aplikasi dan
mengklik tombol Go, Anda akan
melihat runtun kotak pesan yang ditampilkan pada Gambar 4.14.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
private void tombolGo_Click(object
sender, EventArgs e)
{
int angka = 99;
//Menampilkan nilai dari angka
MessageBox.Show("Nilai dari angka adalah " + angka);
//Memanggil UbahSaya, melewatkan angka sebagai argumen
UbahSaya(angka);
//Menampilkan nilai dari angka kembali
MessageBox.Show("Nilai dari angka adalah " + angka);
}
private void UbahSaya(int nilaiKu)
{
//Ubah nilai dari parameter nilaiKu
nilaiKu = 0;
//Menampilkan nilai dari nilaiKu
MessageBox.Show("Di dalam UbahSaya,
nilaiKu adalah " + nilaiKu);
}
|
Di dalam event handler tombolGo_Click, sebuah variabel lokal dengan nama angka dideklarasikan pada baris 3 dan diinisialisasi dengan nilai 99. Hasilnya, statemen pada baris 6 menampilkan Nilai dari angka adalah 99. Nilai dari variabel angka kemudian dilewatkan sebagai argumen kepada metode UbahSaya pada baris 9. Ini berarti bahwa di dalam metode UbahSaya, nilai 99 ditugaskan kepada variabel parameter nilaiKu.
Di dalam metode UbahSaya, baris 18 menugaskan nilai 0 kepada variabel parameter nilaiKu. Ini akan mengganti nilai 99
yang sebelumnya dilewatkan kepada parameter ketika metode ini dipanggil. Baris
21 menampilkan pesan Di dalam UbahSaya,
nilaiKu adalah 0.
Setelah metode UbahSaya selesai dieksekusi, kendali program kembali ke event
handler tombolGo_Click. Ketika
statemen pada baris 12 dieksekusi, pesan Nilai
dari angka adalah 99 ditampilkan. Meskipun variabel parameter nilaiKu diubah di dalam metode UbahSaya, variabel angka di dalam event handler tombolGo_Click
tidak berubah.
Pelewatan dengan nilai dapat dilakukan karena
argumen umumnya dikirim ke metode untuk tujuan informasi semata. Umumnya,
ketika Anda melewatkan sebuah variabel sebagai argumen kepada metode, Anda
menginginkan variabel itu untuk memiliki nilai yang sama sebelum dan sesudah
pemanggilan metode.
4.4 Melewatkan Argumen Dengan Referensi
KONSEP:
Ketika argumen dilewatkan dengan referensi kepada suatu metode, metode itu
dapat mengubah nilai dari argumen pada bagian pemanggil dari program.
Ketika Anda ingin suatu metode dapat mengubah
nilai dari variabel yang dilewatkan kepadanya sebagai argumen, variabel itu
harus dilewatkan dengan referensi. Dalam C#, ada dua cara untuk melewatkan
argumen dengan referensi:
· Anda dapat menggunakan parameter referensi pada metode
· Anda dapat menggunakan parameter keluaran pada metode
Menggunakan Parameter Referensi
Parameter referensi adalah sebuah jenis
spesial dari variabel parameter. Ketika Anda melewatkan argumen kepada suatu
parameter referensi, parameter referensi itu tidak menerima salinan dari nilai
argumen. Tetapi, ia menjadi suatu referensi ke argumen yang dilewatkan
kepadanya. Apapun yang dilakukan kepada parameter referensi itu akan dilakukan
pula pada argumen yang direferensinya.
Parameter referensi berguna dalam membuat
komunikasi dua-arah antar metode. Ketika sebuah metode memanggil metode lain
dan melewatkan argumen dengan referensi, komunikasi antar metode dapat terjadi
dengan cara-cara berikut:
·
Metode pemanggil dapat berkomunikasi dengan metode terpanggil melalui
pelewatan argumen.
· Metode terpanggil dapat berkomunikasi dengan metode pemanggil melalui
pemodifikasian nilai argumen lewat parameter referensi.
Dalam C#, Anda mendeklarasikan sebuah
parameter referensi dengan menuliskan katakunci ref yang ditempatkan sebelum tipe data dari parameter. Sebagai
contoh, lihat pada metode berikut:
private void TetapkanNol(ref int angka)
{
angka = 0;
}
Di dalam kurung, katakunci ref mengindikasikan bahwa angka merupakan variabel referensi.
Metode menugaskan 0 kepada parameter angka. Karena angka adalah parameter referensi, aksi ini sebenarnya dilakukan
terhadap variabel yang sebelumnya sebagai argumen dilewatkan kepada metode.
Ketika Anda memanggil sebuah metode yang
memiliki parameter referensi, Anda perlu menuliskan katakunci ref yang ditempatkan sebelum argumen.
Contoh kode berikut menunjukkan salah satu contoh:
int varKu = 99;
TetapkanNol(ref
varKu);
Statemen pertama mendeklarasikan varKu sebagai sebuah variabel int, yang diinisialisasi dengan nilai
99. Statemen kedua memanggil metode TetapkanNol,
yang melewatkan varKu dengan
referensi. Setelah pemanggilan metode, variabel varKu ditetapkan menjadi nilai 0.
Ketika Anda melewatkan argumen kepada
parameter ref, argumen itu harus
telah memiliki nilai tertentu. Sebagai contoh, jika sebuah variabel belum
diinisialisasi atau ditugasi suatu nilai, maka Anda tidak bisa melewatkannya
sebagai argumen kepada sebuah parameter ref.
Kode berikut menyebabkan error kompilasi:
int
varKu; //Mendekalrasikan varKu tanpa nilai awal
TetapkanNol(ref
varKu); // Error! varKu belum
diinisialisasi
Lihat pada sebuah program yang menggunakan
metode TetapkanNol. Pada CD yang
menyertai buku ini, Anda akan menemukan sebuah projek dengan nama Melewatkan Dengan Ref. Gambar 4.15
menunjukkan form aplikasi, dan Program 4.5 menunjukkan kode form.
Program 4.5 Kode utuh untuk Form1 pada aplikasi Melewatkan
Dengan Ref
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Melewatkan_Dengan_Ref
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
TetapkanNol menerima sebuah argumen int
//dengan
referensi dan menetapkannya menjadi nol
private
void TetapkanNol(ref int angka)
{
angka
= 0;
}
private
void tombolGo_Click(object sender, EventArgs e)
{
//Mendeklarasikan beberapa variabel int lokal
int x
= 99, y = 100, z = 101;
//Menampilkan nilai-nilai pada variabel-variabel itu
kotakListKeluaran.Items.Clear();
kotakListKeluaran.Items.Add("x ditetapkan menjadi " + x);
kotakListKeluaran.Items.Add("y ditetapkan menjadi " + y);
kotakListKeluaran.Items.Add("z ditetapkan menjadi " + z);
//Melewatkan tiap variabel kepada TetapkanNol
TetapkanNol(ref x);
TetapkanNol(ref y);
TetapkanNol(ref z);
//Menampilkan nilai-nilai pada variabel-variabel itu kembali
kotakListKeluaran.Items.Add("--------------------");
kotakListKeluaran.Items.Add("x
ditetapkan menjadi " + x);
kotakListKeluaran.Items.Add("y ditetapkan menjadi " + y);
kotakListKeluaran.Items.Add("z ditetapkan menjadi " + z);
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Perhatikan bahwa form memiliki sebuah kontrol ListBox dengan nama kotakListKeluaran. ListBox ini dipakai untuk menampilkan keluaran program. Metode TetapkanNol yang sebelumnya telah dididiskusikan ditampilkan pada baris 22-25. Metode ini menerima sebuah argumen int dengan referensi dan menugaskan nilai 0 kepada argumen.
Di dalam metode tombolGo_Click, baris 30 mendeklarasikan variabel int dengan nama
x, y, dan x dan menginisialisasinya dengan nilai 99, 100, dan 101. Baris 33
membersihkan kontrol kotakListKeluaran,
dan baris 34-36 menampilkan nilai dari variabel x, y, dan z pada ListBox.
Pada baris 39-41, variabel x, y, dan z
dilewatkan sebagai argumen dengan referensi kepada metode TetapkanNol. Setiap kali TetapkanNol
dipanggil, variabel yang dilewatkan sebagai argumen ditugasi nilai 0. Ini
ditunjukkan ketika variabel x, y, dan z ditampilkan kembali pada baris 45-47.
Gambar 4.16 menunjukkan form aplikasi setelah tombol Go diklik.
Menggunakan Parameter Keluaran
Parameter keluaran bekerja seperti parameter
referensi. Ketika Anda melewatkan sebuah argumen kepada parameter keluaran,
parameter keluaran itu menjadi referensi ke argumen yang dilewatkan kepadanya.
Apapun yang dilakukan pada parameter keluaran akan dilakukan pula pada argumen
yang direferensinya. Parameter keluaran berbeda dari parameter referensi dalam
hal-hal berikut:
· Argumen tidak perlu ditetapkan untuk memiliki suatu nilai sebelum ia
dilewatkan kepada parameter keluaran. Sebagai contoh, sebuah variabel
tak-terinisialisasi dapat dilewatkan kepada parameter keluaran.
· Metode yang memiliki parameter keluaran perlu menetapkan nilai untuk
parameter keluaran sebelum ia metode dieksekusi.
Dalam C#, Anda mendeklarasikan sebuah
parameter keluaran dengan menuliskan katakunci out yang ditempatkan sebelum tipe data dari variabel parameter.
Sebagai contoh, Anda dapat memodifikasi metode TetapkanNol dengan cara berikut untuk membuat parameter angka menjadi sebuah parameter
keluaran:
private void TetapkanNol(out int angka)
{
angka = 0;
}
Ketika Anda memanggil suatu metode yang
memiliki parameter keluaran, Anda perlu menuliskan katakunci out sebelum argumen. Kode berikut
menunjukkan salah satu contoh:
int varKu;
TetapkanNol(out varKu);
Statemen pertama mendeklarasikan varKu sebagai sebuah variabel int tak-terinisialisasi. Statemen kedua
memanggil metode TetapkanNol, yang
melewatkan varKu kepada parameter
keluaran. Setelah metode dipanggil, variabel varKu ditetapkan menjadi 0.
Tutorial 4.3 memberikan Anda latihan untuk
menulis sebuah metode yang menggunakan parameter keluaran.
Tutorial 4.3: Menggunakan Parameter Keluaran
Pada tutorial
ini, Anda akan menciptakan sebuah aplikasi dengan nama Republik Indonesia. Form
aplikasi telah disediakan bagi Anda yang ditunjukkan pada Gambar 4.17. Aplikasi
ini juga ditemani dnegan sebuah file teks dengan nama RepublikIndonesia.txt yang memuat propinsi-propinsi di Republik
Indonesia.
Ketika
aplikasi dijalankan dan user mengklik tombol Baca Propinsi, aplikasi
akan menggunakan kontrol OpenFileDialog
agar user dapat memilih sebuah file. Aplikasi membaca setiap nama propinsi dari
file dan menambahkannya pada kontrol kotakListPropinsi.
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka
projek dengan nama Republik Indonesia.
Langkah 2: Buka Form1
pada mode Designer dan tambahkan
sebuah kontrol OpenFileDialog pada
form. Ubah nama kontrol menjadi bukaFile
dan bersihkan isi dari properti Filename
dari kontrol.
Langkah 3: Buka kode form Form1
pada editor kode. Sisipkan direktif using
System.IO; yang ditunjukkan pada baris 10 pada Program 4.6 di akhir
tutorial. Statemen ini diperlukan karena Anda akan menggunakan kelas StreamReader, yang merupakan bagian
dari namespace System.IO di dalam
.NET Framework.
Langkah 4: Ketikkan komentar dan kode untuk metode BacaNamaFile, yang ditunjukkan pada
baris 21-34 pada Program 4.6. Tujuan dari metode BacaNamaFile adalah agar user dapat memilih file yang akan dibuka.
Amati kode ini lebih dekat:
Baris 24: Ini adalah awal dari metode. Metode ini memiliki
parameter keluran string dengan nama
fileTerseleksi. Ketika Anda
memanggil metode ini, Anda melewatkan sebuah variabel string sebagai argumen.
Metode dipakai agar user dapat memilih file yang akan dibuka dan menyimpa file
dan pathnya di dalam parameter fileTerseleksi.
Baris 26-33: Statemen if
ini memanggil metode ShowDialog dari
kontrol bukaFile. Jika user mengklik
tombol Open, metode ini akan
menghasilkan nilai Dialog.Result.OK,
dan baris 28 akan menugaskan nama dari file terseleksi kepada parameter fileTerseleksi. Jika user mengklik
tombol Cancel, maka baris 32 akan
menugaskan string kosong kepada parameter fileTerseleksi.
Langkah 5: Ketikkan komentar dan kode untuk metode BacaPropinsi,
seperti ditunjukkan pada baris 36-70 pada Program 4.6. Metode ini menerima
sebuah nama file sebagai argumen, membaca isi dari file tertentu, dan
menambahkannya pada kontrol kotakListPropinsi.
Berikut adalah deskripsi detil dari tiap bagian metode:
Baris 41: Ini adalah awal dari statemen try-catch, yang menangani setiap eksepsi yang dilemparkan ketika
file sedang diproses. Jika eksepsi dilemparkan oleh sembarang statemen di dalam
blok try, maka program akan melompat
ke klausa catch pada baris 68.
Baris 44: Statemen ini mendeklarasikan variabel string dengan
nama namaPropinsi, yang memuat
baris-baris teks yang dibaca dari file.
Baris 47: Statemen ini mendeklarasikan variabel StreamReader dengan nama fileMasukan.
Baris 50: Setelah statemen ini dieksekusi, file yang ditetapkan
oleh parameter namaFile dibuka untuk
operasi pembacaan, dan variabel fileMasukan
mereferensi sebuah objek StreamReader
yang dikaitkan dengan file itu.
Baris 53: Statemen ini membersihkan segala sesuatu yang
ditampilkan pada kontrol kotakListPropinsi.
Baris 56: Ini adalah awal dari loop while yang beriterasi sepanjang akhir file tidak dicapai.
Baris 59: Statemen ini membaca sebaris teks dari file dan
menugaskannya kepada variabel namaPropinsi.
Baris 62: Statemen ini menambahkan isi dari variabel namaPropinsi pada ListBox.
Baris 66: Statemen ini menutup file.
Langkah 6: Buka form Form1
pada mode Designer. Klik ganda pada tombolBaca. Ini akan membuka editor
kode, dan Anda akan melihat sebuah event handler kosong dengan nama tombolBaca_Click. Sempurnakan event
handler ini dengan menuliskan kode yang ditunjukkan pada baris 77-83 pada
Program 4.6. Amati kode ini lebih dekat:
Baris 77: Statemen ini mendeklarasikan sebuah variabel string
dengan nama namaFile.
Baris 80: Statemen ini memanggil metode BacaNamaFile, yang melewatkan variabel namaFile sebagai argumen. Ketika metode ini selesai dieksekusi,
variabel namaFile akan memuat nama
file yang diseleksi oleh user.
Baris 83: Statemen ini memanggil metode BacaPropinsi, yang melewatkan variabel namaFile sebagai argumen. Metode membuka file tertentu dan mengisi
kontrol kotakListPropinsi dengan
isinya.
Langkah 7: Kembali ke mode Designer
dan klik ganda pada kontrol tombolKeluar.
Pada editor kode, Anda akan melihat sebuah event handler kosong dengan nama tombolKeluar_Click. Sempurnakan kode
ini dengan menuliskan kode yang ditunjukkan pada baris 88-89 pada Program 4.6.
Langkah 8: Simpan projek dan jalankan aplikasi. Ketika aplikasi
dijalankan, klik pada tombol Baca Propinsi. Sebuah kotak dialog Open akan ditampilkan. Pilih file RepublikIndonesia.txt dan klik tombol Open. ini akan mengisi kontrol ListBox dengan nama-nama propinsi,
seperti ditunjukkan pada Gambar 4.18. Klik tombol Keluar untuk mengakhiri aplikasi.
Program 4.6 Kode utuh untuk Form1
pada aplikasi Republik Indonesia
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
namespace Republik_Indonesia
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
BacaNamaFile membaca nama file dari
//user
dan menugaskannya kepada variabel yang dilewatkan
//sebagai
argumen
private
void BacaNamaFile(out string fileTerseleksi)
{
if
(bukaFile.ShowDialog() == DialogResult.OK)
{
fileTerseleksi = bukaFile.FileName;
}
else
{
fileTerseleksi = "";
}
}
//Metode
BacaPropinsi menerima nama file sebagai sebuah
//argumen. Ia membuka file tertentu dan menampilkan
//isinya
pada kontrol kotakListPropinsi
private
void BacaPropinsi(string namaFile)
{
try
{
//Mendeklarasikan sebuah variabel untuk memuat nama propinsi
string namaPropinsi;
//Mendeklarasikan sebuah variabel StreamReader
StreamReader fileMasukan;
//Membuka file dan membaca objek StreamReader
fileMasukan = File.OpenText(namaFile);
//Membersihkan ListBox
kotakListPropinsi.Items.Clear();
//Membaca isi file
while (!fileMasukan.EndOfStream)
{
//Membaca nama propinsi
namaPropinsi = fileMasukan.ReadLine();
//Menambahkan nama negara pada ListBox
kotakListPropinsi.Items.Add(namaPropinsi);
}
//Menutup file
fileMasukan.Close();
}
catch
(Exception ex)
{
//Menampilkan error
MessageBox.Show(ex.Message);
}
}
private
void tombolBaca_Click(object sender, EventArgs e)
{
string namaFile; //Untuk memuat nama file
//Membaca nama file dari user
BacaNamaFile(out namaFile);
//Membaca propinsi-propinsi dari file
BacaPropinsi(namaFile);
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
4.5 Metode Penghasil Nilai
KONSEP:
Metode penghasil-nilai adalah metode yang menghasilkan suatu nilai balik yang
diserahkan kepada program yang memanggilnya.
Metode penghasil-nilai memiliki kesamaan
dengan metode void dalam beberapa
hal:
·
Ia memuat sekelompok statemen untuk melakukan pekerjaan tertentu.
·
Ketika Anda ingin mengeksekusi metode, Anda perlu memanggilnya
Ketika metode penghasil-nilai selesai dieksekusi,
ia akan menghasilkan sebuah nilai yang diberikan kepada statemen yang
memanggilnya. Nilai yang dihasilkan dari suatu metode dapat dipakai seperti
nilai lainnya: Ia dapat ditugaskan kepada variabel, ditampilkan pada layar,
digunakan pada ekspresi matemetis, dan lainnya.
Anda telah sering menggunakan metode-metode
penghasil-nilai dari .NET Framework. Sebagai contoh, metode int.Parse menerima
sebuah string sebagai argumen dan menghasilkan nilai balik berupa string yang
dikonversi menjadi sebuah int. Amati
bagaimana metode ini bekerja. Pada statemen berikut, asumsikan angka adalah sebuah variabel int:
angka =
int.Parse("100");
Bagian dari statemen yang dibaca
int.Parse(“100”) adalah suatu pemanggilan terhadap metode int.Parse, dengan string “100” dilewatkan sebagai argumen. Gambar 4.19
mengilustrasikan bagian dari statemen ini.
Perhatikan bahwa pemanggilan terhadap metode int.Parse ditampilkan di sebelah kanan
dari operator =. Ketika metode dipanggil, ia akan menghasilkan suatu integer.
Integer yang dihasilkan ditugaskan kepada variabel angka, seperti ditunjukkan pada Gambar 4.20.
Menuliskan Fungsi Penghasil-Nilai
Sendiri
Anda menuliskan metode penghasil-nilai dengan
cara yang sama seperti ketika Anda menuliskan metode void, dengan dua pengecualian:
·
Anda perlu menetapkan tipe data untuk metode penghasil-nilai. Nilai yang
dihasilkan dari metode harus memiliki tipe data tertentu.
· Metode penghasil-nilai harus memiliki sebuah statemen return. Statemen return menyebabkan sebuah nilai dihasilkan dari metode.
Berikut adalah bentuk umum dari sebuah definisi
metode penghasil-nilai dalam C#:
PemodifikasiAkses TipeData NamaMetode(DaftarParameter)
{
statemen;
statemen;
dan seterusnya.
return ekspresi;
}
·
PemodifikasiAkses adalah sebuah
pemodifikasi akses seperti private
atau public.
· TipeData adalah tipe data
dari nilai yang dihasilkan oleh metode. Umumnya Anda mengenal ini dengan tipe
nilai balik dari metode. Sebagai contoh, jika metode menghasilkan sebuah
integer, maka kata int ditempatkan
di sini. Jika metode menghasilkan sebuah double,
maka kata double ditempatkan di
sini. Sama halnya, jika metode menghasilkan sebuah decimal, maka kata decimal
ditempatkan di sini.
·
NamaMetode adalah nama dari
metode.
· DaftarParameter adalah daftar
parameter opsional. Jika metode tidak menerima argumen apapun, maka tanda
kurung dibiarkan kosong.
Salah satu statemen yang ada di dalam metode
penghasil-nilai harus berupa statemen return,
yang memiliki bentuk:
return
ekspresi;
Nilai dari ekspresi yang mengikuti katakunci return dikirim kembali ke statemen yang memanggil metode. Ekspresi
ini dapat berupa sembarang nilai, variabel, atau ekspresi yang memiliki suatu
nilai (seperti ekspresi matematis). Nilai yang dihasilkan harus bertipe data
sama dengan tipe nilai balik pada header metode. Jika tidak, error kompilasi
akan terjadi. Berikut adalah salah satu contoh metode penghasil-nilai:
private
int Jum(int angka1, int angk2)
{
return angka1+ angk2;
}
Gambar 4.21 mengilustrasikan sejumlah bagian
dari header metode. Perhatikan bahwa metode ini menghasilkan sebuah int, nama metode adalah Jum, dan metode memiliki dua parameter int dengan nama angka1 dan angka2.
Tujuan dari metode ini adalah untuk menerima
dua nilai int sebagai argumennya dan
menghasilkan hasil penjumlahan atas kedua nilai itu. Perhatikan bahwa statemen return menghasilkan nilai dari ekspresi
angka1 + angka2. Ketika statemen return
dieksekusi, metode ini mengakhiri eksekusinya dan mengirimkan nilai dari angka1 + angka2 kembali ke bagian
program yang memanggil metode.
Lihat pada sebuah program utuh yang
mendemonstrasikan metode Jum. Di
dalam CD yang menyertai buku ini, Anda akan mendapati sebuah projek dengan nama
Jum. Gambar 4.22 menunjukkan form
aplikasi, dan Program 4.7 menunjukkan kode form. Ketika Anda menjalankan
aplikasi, Anda memasukkan dua integer ke dalam kontrol teksUsia1 dan teksUsia2.
Ketika Anda mengklik tombol Hitung Usia Terkombinasi, penjumlahan atas kedua integer akan ditampilkan pada
kontrol labelUsiaTerkombinasi.
Program 4.7 Kode utuh untuk Form1 pada aplikasi Jum
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Jum
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
Jum menerima dua argumen int
//dan
menghasilkan penjumlahan atas kedua argumen
private
int Jum(int angka1, int angka2)
{
return angka1 + angka2;
}
private
void tombolUsiaTerkombinasi_Click(object sender, EventArgs e)
{
//Mendeklarasikan variabel-variabel untuk memuat dua usia dan
penjumlahannya
int
usiaUser, usiaTeman, usiaTerkombinasi;
//Membaca usia user
if
(int.TryParse(teksUsia1.Text, out usiaUser))
{
//Membaca usia teman
if (int.TryParse(teksUsia2.Text, out usiaTeman))
{
//Menghitung penjumlahan usia
usiaTerkombinasi = Jum(usiaUser, usiaTeman);
//Menampilkan usia terkombinasi
labelUsiaTerkombinasi.Text = usiaTerkombinasi.ToString();
}
else
{
//Menampilkan pesan error
MessageBox.Show("Masukkan sebuah integer untuk usia.");
}
}
else
{
//Menampilkan pesan error
MessageBox.Show("Masukkan sebuah integer untuk usia.");
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Pada baris 33, nilai yang dimasukkan ke dalam
kontrol teksUsia1 dikonversi menjadi
sebuah int dan disimpan di dalam
variabel usiaUser. Pada baris 36,
nilai yang dimasukkan ke dalam kontrol teksUsia2
dikonversi menjadi sebuah int dan
disimpan di dalam variabel usiaTeman.
Baris 39 melewatkan variabel usiaUser
dan usiaTeman sebagai
argumen-argumen kepada metode Jum.
Penjumlahan atas dua variabel dihasilkan dari metode dan ditugaskan kepada
variabel usiaTerkombinasi. Pada
baris 42, nilai dari variabel usiaTerkombinasi
dikonversi menjadi string dan ditampilkan pada kontrol labelUsiaTerkombinasi.
Asumsikan bahwa variabel usiaUser ditetapkan menjadi nilai 23 dan variabel usiaTeman ditetapkan menjadi nilai 25.
Gamabr 4.23 menunjukkan bagaimana argumen-argumen dilewatkan kepada metode dan
bagaimana sebuah nilai dihasilkan dari metode.
Ketika Anda memanggil sebuah metode
penghasil-nilai, Anda umumnya ingin melakukan sesuatu yang berguna pada nilai
yang dihasilkan oleh metode itu. Pada baris 39 pada Program 4.7, nilai yang
dihasilkan dari metode Jum ditugaskan
kepada suatu variabel. Ini biasanya bagaimana nilai digunakan, tetapi Anda bisa
melakukan hal-hal lain pada nilai itu. Sebagai contoh, kode berikut menunjukkan
ekspresi matematis yang menggunakan pemanggilan terhadap metode Jum:
int
x = 10, y = 15;
double
rerata;
rerata
= Jum(x, y) / 2.0;
Pada statemen terakhir, metode Jum dipanggil dengan x dan y sebagai
argumen. Nilai balik dari metode, yaitu 25, dibagi dengan 2.0. Hasilnya, 12.5,
ditugaskan kepada rerata. Berikut
adalah contoh lain:
int
x = 10, y = 15;
MessageBox.Show("Penjumlahannya
adalah " + Jum(x, y));
Kode ini mengirim nilai balik metode kepada MessageBox.Show, sehingga ia dapat
ditampilkan di layar. Pesan Penjumlahannya
adalah 25 ditampikan. Ingat, metode penghasil-nilai menghasilkan sebuah
nilai dengan tipe data tertentu. Anda dapat menggunakan nilai balik metode di
tempat dimana Anda dapat menggunakan nilai biasa dengan tipe data sama. Ini
berarti bahwa dimanapun suatu nilai int
dapat digunakan, pemanggilan terhadap metode penghasil-nilai int dapat juga digunakan. Sama halnya,
dimanapun suatu nilai double dapat
digunakan, pemanggilan terhadap metode penghasil-nilai double dapat juga digunakan.
Pada Tutorial 4.4, Anda menciptakan suatu
aplikasi yang mengkonversi suatu nilai dari satu unit pengukuran ke unit lain.
Kode ini akan menggunakan suatu metode penghasil-nilai untuk melakukan konversi
tersebut.
Tutorial 4.4: Menuliskan Metode
Penghasil-Nilai
Cangkir dan
ons cairan adalah dua unit pengukuran yang umum dipakai untuk makanan.
Kadangkala, ketika resep untuk suatu item diukur dalam cangkir, Anda mendapati
bahwa supermarket menjualnya dalam ons cairan. Untuk mengetahui seberapa banyak
yang perlu Anda beli untuk resep, Anda perlu mengkonversinya. Formula yang
diperlukan adalah:
Ons = Cangkir x 8
Pada tutorial
ini, Anda menciptakan aplikasi Cangkir
Ke Ons yang dapat Anda temukan di dalam CD yang menyertai buku ini. Form
aplikasi telah diciptakan dan ditampilkan pada Gambar 4.24a. Ketika Anda
menyelesaikan aplikasi, Anda akan bisa memasukkan banyak cangkir ke dalam
kontrol teksCangkir, mengklik tombol
Konversi, dan melihat jumlah
ekivalen dari ons cairan pada kontrol labelOns.
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka
projek dengan nama Cangkir Ke Ons.
Langkah 2: Buka form Form1
pada mode Designer. Form
ditunjukkan, berikut dengan nama dari tiap kontrol penting, pada Gambar 4.24.
Langkah 3: Program 4.8, di akhir dari tutorial ini, menunjukkan
kode utuh dari form. Buka editor kode dan ketikkan komentar dan kode untuk
metode CangkirKeOns yang ditunjukkan
pada baris 20-26 pada Program 4.8. Tujuan dari metode ini adalah untuk menerima
sejumlah cangkir sebagai argumen dan menghasilkan nilai itu yang dikonversi
menjadi ons cairan. Anda dapat melihat pada baris 23 bahwa metode memiliki
sebuah paramete double dengan nama cangkir, dan pada baris 25 metode
menghasilkan nilai dari cangkir yang
dikalikan dengan 8.
Langkah 4: Sekarang Anda akan menciptakan event handler untuk tiap
kontrol Button. Kembali ke mode Designer dan klik ganda pada kontrol tombolKonversi. Ini akan membuka editor
kode, dan Anda akan melihat sebuah event handler kosong dengan nama tombolKonversi_Click. Sempurnakan event
handler ini dengan menuliskan kode yang ditunjukkan pada baris 30-46 pada
Program 4.8. Amati kode ini lebih dekat:
Baris 31: Statemen ini mendeklarasikan variabel cangkir dan ons, yang memuat jumlah cangkir dan jumlah ons.
Baris 34-46: Statemen if
pada baris 34 mengkonversi properti Text
dari kontrol teksCangkir menjadi
sebuah double, dan hasilnya disimpan
di dalam variabel cangkir. Jika
konversi berhasil dilakukan, maka baris 37 akan memanggil metode CangkirKeOns, yang melewatkan cangkir sebagai argumen. Nilai yang
dihasilkan dari metode ditugaskan kepada variabel ons, dan pada baris 40 nilai dari variabel ons ditampilkan pada kontrol labelOns.
Jika konversi tidak berhasil, maka baris 45 akan menampilkan pesan error.
Langkah 5: Kembali ke mode Designer
dan klik ganda pada kontrol tombolKeluar.
Pada editor kode, Anda akan melihat sebuah event handler kosong dengan nama tombolKeluar_Click. Sempurnakan event
handler ini dengan menuliskan kode yang ditunjukkan pada baris 51-52 pada
Program 4.8.
Langkah 6: Simpan projek dan jalankan aplikasi. Ketika aplikasi
dijalankan, masukkan nilai 1 ke dalam kontrol teksCangkir dan klik tombol Konversi.
Aplikasi akan menampilkan 8.0 sebagai ons cairan. Lanjutkan aplikasi untuk
nilai lain, seperti ditunjukkan pada Gambar 4.24b.
Program 4.8 Kode utuh untuk Form1
pada aplikasi Cangkir Ke Ons
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Cangkir_Ke_Ons
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
CangkirKeOns menerima sejumlah
//cangkir sebagai argumen dan menghasilkan
//jumlah
ons cairan ekivalen
private
double CangkirKeOns(double cangkir)
{
return cangkir * 8.0;
}
private
void tombolKonversi_Click(object sender, EventArgs e)
{
//Variabel-variabel untuk memuat cangkir dan ons
double cangkir, ons;
//Membaca banyak cangkir
if
(double.TryParse(teksCangkir.Text, out cangkir))
{
//Mengkonversi cangkir ke ons
ons = CangkirKeOns(cangkir);
//Menampilkan ons
labelOns.Text = ons.ToString("n1");
}
else
{
//Menampilkan pesan error
MessageBox.Show("Masukkan nilai yang valid.");
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Metode Boolean
Metode Boolean menghasilkan true atau false. Anda dapat menggunakan sebuah metode Boolean untuk menguji
kondisi, dan kemudian menghasilkan nilai true
atau false untuk mengindikasikan
apakah kondisi memenuhi atau tidak. Metode Boolean berguna untuk menyederhakan
kondisi-kondisi kompleks yang diuji pada struktur keputusan dan repetisi.
Sebagai contoh, dimisalkan bahwa Anda sedang
menuliskan sebuah program yang meminta user untuk memasukkan suatu nilai dan
kemudian menentukan apakah nilai itu ganjil atau genap. Kode berikut
menunjukkan bagaimana Anda membuat penentuan itu. Asumsikan bahwa angka adalah sebuah variabel int yang memuat nilai yang dimasukkan
oleh user.
if (angka % 2 == 0)
{
MessageBox.Show("Angka genap.");
}
else
{
MessageBox.Show("Angka ganjil.");
}
Makna dari ekspresi Boolean yang sedang diuji
oleh statemen if-else ini tidak
jelas, jadi amati lebih dekat:
angka % 2 == 0
Ekspresi ini menggunakan operator %. Ingat
bahwa operator % membagi dua integer dan menghasilkan sisa pembagian. Jadi,
kode ini berkata, jika sisa dari angka
yang dibagi dengan 2 adalah 0, maka tampilkan pesan yang mengindikasikan bahwa
angka genap, jika tidak, maka tampilkan pesan yang mengindikasikan bahwa angka
ganjil.
Karena pembagian suatu nilai genap dengan 2
selalu menghasilkan sisa 0, logika ini dapat diterapkan. Kode ini lebih mudah
dipahami, namun hal ini lebih baik bila dilakukan menggunakan sebuah metode
Boolean. Pada contoh ini, Anda dapat menuliskan suatu metode Boolean dengan
nama ApaGenap yang menerima sebuah int sebagai argumen dan menghasilkan true jika angka genap atau false jika angka ganjil. Berikut adalah
sebuah contoh bagaimana metode ApaGenap
dituliskan:
private bool ApaGenap(int angka)
{
//Variabel lokal untuk memuat true atau false
bool angkaGenap;
//Menentukan apakah angka genap
if (angka % 2 == 0)
{
angkaGenap = true;
}
else
{
angkaGenap = false;
}
//Memberikan hasil
return angkaGenap;
}
Kemudian, Anda dapat menuliskan statemen if-else sehingga ia memanggil metode ApaGenap untuk menentukan apakah angka genap atau tidak:
if (ApaGenap(angka))
{
MessageBox.Show("Angka genap.");
}
else
{
MessageBox.Show("Angka ganjil.");
}
Bukan hanya logika ini lebih mudah dipahami,
tetapi sekarang Anda memiliki sebuah metode yang dapat Anda panggil di dalam
program kapanpun Anda perlu menguji apakah suatu angka genap atau tidak.
Menggunakan Metode Boolean Untuk
Memodularisasi Validasi Masukan
Metode Boolean dapat berguna dalam
memodularisasi validasi masukan. Ketika suatu form memiliki sejumlah kontrol TextBox, validasi masukan umumnya
memiliki sejumlah statemen if
bersarang. Pada banyak kasus, Anda dapat menyederhanakan kode dengan
menciptakan sebuah metode Boolean yang melakukan semua validasi masukan dan
menghasilkan true jika ada yang
tidak valid. Pada Tutorial 4.5, Anda akan menciptakan suatu aplikasi yang
menggunakan pendekatan ini.
Tutorial 4.5: Memodularisasi Validasi Masukan dengan
Metode Boolean
Sebuah perusahaan memberikan bonus tahunan
kepada tiap karyawannya. Perusahaan juga memberikan 5% dari komponensasi (gaji
kotor ditambah bonus) dari tiap karyawan untuk akun pensiun. Pada tutorial ini,
Anda akan menciptakan sebuah aplikasi agar Anda bisa memasukkan gaji kotor dari
karyawan dan jumlah bonus yang didapatkan dan menghitung jumlah kontribusi
pensiun. Projek ini dinamai dengan Gaji dan Bonus dan dapat Anda temukan di CD
yang menyertai buku ini. Gambar 4.25a menampilkan form aplikasi, yang telah
diciptakan bagi Anda.
Langkah 1: Awali Visual Studio (atau Visual Studio
Express). Buka projek dengan nama Gaji
dan Bonus.
Langkah 2: Buka kode form dari Form1 pada editor kode. Sisipkan komentar dan deklarasi bidang
konstanta yang ditunjukkan pada baris 15 dan baris 16 pada Program 4.9.
Konstanta ini, yang ditetapkan nilainya 0.05, dipakai dalam perhitungan
kontribusi akun pensiun.
Langkah 3: Ketikka komentar dan kode untuk metode ValidasiMasukan, yang ditunjukkan pada
baris 23 sampai baris 54 pada Program 4.9. Perhatikan pada baris 27 bahwa
metode ini memiliki parameter-parameter referensi untuk gaji kotor dan besar
bonus. Tujuan dari metode ini adalah untuk mendapatkan nilai-nilai yang
dimasukkan oleh user, mengkonversinya menjadi nilai-nilai decimal, dan
menugaskannya kepada variabel-variabel parameter. Jika masukan berhasil
dikonversi, maka metode akan menghasilkan true.
Jika tidak, pesan error akan ditampilkan dan metode akan menghasilkan false untuk mengindikasikan bahwa
masukan tidak valid.
Langkah 4: Buka form Form1 pada mode Designer.
Klik ganda pada kontrol tombolHitung.
Ini akan membuka editor kode, dan Anda akan melihat sebuah event handler kosong
dengan nama tombolHitung_Click.
Sempurnakan event handler ini dengan menuliskan kode yang ditunjukkan pada
baris 56-68 pada Program 4.9. Amati kode ini lebih dekat:
Baris 59: Statemen ini mendeklarasikan
variabel-variabel decimal untuk memuat gaji kotor, besar bonus, dan besar
kontribusi pensiun.
Baris 61-68: Statemen if ini memanggil metode ValidasiMasukan,
yang melewatkan variabel gajiKotor
dan bonus, dengan referensi, sebagai
argumen. Jika metode ini menghasilkan true,
maka variabel-variabel ini akan memuat gaji kotor dan besar bonus yang
dimasukkan oleh user. Pada kasus itu, baris 64 akan menghitung besar kontribusi
untuk rekening pensiun, dan baris 67 akan menampilkan jumlah itu.
Langkah 5: Kembali ke mode Designer dan klik ganda pada kontrol tombolKeluar. Pada editor kode, Anda akan melihat sebuah event
handler kosong dengan nama tombolKeluar_Click.
Sempurnakan event handler ini dengan menuliskan kode yang ditunjukkan pada
baris 73-74 pada Program 4.9.
Langkah 6: Simpan projek dan jalankan aplikasi. Ketika
aplikasi dijalankan, masukkan 8000000 untuk gaji kotor dan 2000000 untuk bonus.
Klik pada tombol Hitung Kontribusi. Aplikasi akan menampilkan
Rp. 500000 sebagai jumlah kontribusi untuk rekening pensiun. Coba nilai lain.
Klik tombol Keluar untuk mengakhiri
aplikasi.
Program 4.9 Kode utuh untuk Form1
pada aplikasi Gaji dan Bonus
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Gaji_dan_Bonus
{
public
partial class Form1 : Form
{
//Bidang
konstanta untuk persen kontribusi pensiun
private
const decimal PERSEN_KONTRIBUSI = 0.05m;
public
Form1()
{
InitializeComponent();
}
//Metode
ApaMasukanBaik mengkonversi masukan user dan menyimpannya
//pada
argumen-argumen yang dilewatkan dengan referensi. Jika konversi
//berhasil, metode ini akan menghasilkan true. Jika tidak,
//ia
menghasilkan false.
private
bool ApaMasukanValid(ref decimal gaji, ref decimal bonus)
{
//Variabel bendera untuk mengindikasikan apakah masukan baik
bool
masukanBaik = false;
//Mencoba mengkonversi kedua masukan menjadi decimal
if
(decimal.TryParse(teksGaji.Text, out gaji))
{
if (decimal.TryParse(teksBonus.Text, out bonus))
{
//Kedua masukan baik
masukanBaik = true;
}
else
{
//Menampilkan pesan error untuk bonus.
MessageBox.Show("Besar bonus tidak valid.");
}
}
else
{
//Menampilkan pesan error untuk gaji kotor
MessageBox.Show("Gaji kotor tidak valid.");
}
//Menampilkan hasil
return masukanBaik;
}
private
void tombolHitung_Click(object sender, EventArgs e)
{
//Variabel-variabel untuk memuat gaji, bonus, kontribusi
decimal gajiKotor = 0m, bonus = 0m, kontribusi = 0m;
if
(ApaMasukanValid(ref gajiKotor, ref bonus))
{
//Menghitung jumlah kontribusi
kontribusi = (gajiKotor + bonus) * PERSEN_KONTRIBUSI;
//Menampilkan kontribusi
labelKontribusi.Text = "Rp. " + kontribusi.ToString();
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Menghasilkan String dari Sebuah Metode
Sejauh ini, Anda telah melihat contoh-contoh
metode yang menghasilkan nilai-nilai dan nilai Boolean. Anda dapat menuliskan
metode yang menghasilkan tipe data apapun. Lihat pada contoh program berikut
yang menggunakan sebuah metode penghasil-string. Pada CD, Anda akan menemukan
sebuah projek dengan nama Nama Lengkap. Gambar 4.26a menunjukkan form
aplikasi dan Program 4.10 menunjukkan kode form. Ketika Anda menjalankan
aplikasi, Anda memasukkan nama depan, nama tengah, dan nama belakang pada
kontrol-kontrol TextBox. Ketika Anda
mengklik tombol Tampilkan Nama Lengkap, nama lengkap Anda akan ditampilkan pada kontrol labelNamaLengkap.
Program 4.9 Kode utuh untuk Form1 pada aplikasi Gaji dan
Bonus
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Nama_Lengkap
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
NamaLengkap menerima argumen untuk nama
//depan,
nama tengah, dan nama belakang. Ia menghasilkan
//nama
lengkap
private
string NamaLengkap(string depan, string tengah, string belakang)
{
return depan + " " + tengah + " " + belakang;
}
private void tombolTampil_Click(object
sender, EventArgs e)
{
//Variabel-variabel untuk memuat nama depan, tengah, belakang, dan nama
lengkap
string depan, tengah, belakang, lengkap;
//Membaca nama depan, tengah, dan belakang
depan
= teksNamaDepan.Text;
tengah = teksNamaTengah.Text;
belakang = teksNamaBelakang.Text;
//Mendapatkan nama lengkap
lengkap = NamaLengkap(depan, tengah, belakang);
//Menampilkan nama lengkap
labelNamaLengkap.Text = lengkap;
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
No comments:
Post a Comment