Kelas dan Multiform
7.1 Pengantar Kelas
KONSEP: Kelas
adalah cetak-biru untuk sebuah objek. Ia menetapkan bidang-bidang dan
metode-metode yang dimiliki oleh tipe objek tertentu. Dari kelas, satu atau
lebih objek dapat diciptakan.
Ketika Anda membaca buku ini dari awal, Anda
telah menggunakan objek-objek secara ekstensif pada semua program yang telah
Anda tuliskan. Beberapa objek, seperti kontrol-kontrol yang Anda tempatkan pada
sebuah form, adalah objek-objek visual. Objek-objek lain, seperti objek Random, array, objek List, dan kontrol ImageList, tidak bisa dilihat di layar tetapi ada di dalam memori
dan melakukan pekerjaan penting.
Objek tidak secara begitu saja muncul pada
program Anda. Sebelum objek dengan tipe tertentu dapat digunakan, objek itu
harus diciptakan di dalam memori. Dan, sebelum suatu objek dapat diciptakan di
dalam memori, Anda harus memiliki sebuah kelas untuk objek itu.
Kelas adalah kode yang menjelaskan tipe
tertentu dari objek. Ia menetapkan data yang dapat dimuat di dalam sebuah objek
(bidang-bidang dan properti-properti) dan aksi-aksi yang dapat dilakukannya
(metode-metode). Anda dapat memandang kelas sebagai cetak-biru kode yang dapat
dipakai untuk menciptakan tipe tertentu dari objek. Ia berperan dengan tujuan
yang sama seperti cetak-biru untuk rumah. Cetak-biru itu sendiri bukanlah
sebuah rumah tetapi merupakan deskripsi detil dari sebuah rumah. Ketika Anda
menggunakan cetak-biru untuk membangun rumah aktual, Anda dapat mengatakan
bahwa Anda sedang membangun suatu contoh rumah atau instansi rumah atau objek
rumah yang dijelaskan oleh cetak-biru. Jika Anda inginkan, Anda bisa membangun
sejumlah rumah identik dari cetak-biru yang sama. Setiap rumah merupakan suatu
objek terpisah dari rumah yang dijelaskan oleh cetak-biru. Ide ini
diilustrasikan pada Gambar 7.1.
Gambar 7.1 Sebuah cetak-biru dan rumah-rumah yang
dibangun dari cetak-biru
Jadi, kelas bukanlah objek melainkan
deskripsi dari suatu objek. Ketika program dijalankan, ia dapat menggunakan
kelas untuk menciptakan, di dalam memori, sebanyak mungkin objek dengan tipe tertentu
yang diperlukan. Setiap objek yang diciptakan dari sebuah kelas dinamakan
dengan instansi kelas atau objek kelas.
Sebagai contoh, Jesika adalah seorang
entomologist (seseorang yang mempelajari serangga), dan ia juga menikmati
menulis program komputer. Ia merancang sebuah program yang mengkatalogkan
sejumlah tipe berbeda dari serangga. Sebagai bagian dari program, ia
menciptakan sebuah kelas dengan nama Serangga,
yang menetapkan bidang-bidang, properti-properti, dan metode-metode untuk
memuat dan memanipulasi data yang umum ada pada semua jenis serangga. Kelas Serangga bukanlah objek tetapi
merupakan spesifikasi dari mana objek-objek dapat diciptakan. Selanjutnya, ia
menulis statemen-statemen pemrograman yang menciptakan sebuah objek lalat, yang merupakan suatu objek dari
kelas Serangga. Objek lalat merupakan suatu entitas yang
menempati memori dan menyimpan data tentang serangga jenis lalat. Ia memiliki
bidang-bidang, properti-properti, dan metode-metode yang ditetapkan oleh kelas Serangga. Kemudian ia menulis
statemen-statemen pemrograman untuk menciptakan sebuah objek nyamuk. Objek nyamuk juga merupakan suatu objek dari kelas Serangga. Ia memiliki tempat sendiri di dalam memori dan menyimpan
data tentang nyamuk. Meskipun objek lalat dan objek nyamuk adalah dua entitas
yang terpisah di dalam memori komputer, keduanya diciptakan dari kelas Serangga. Ini berarti bahwa setiap
objek memiliki bidang-bidang, properti-properti, dan metode-metode yang
dijelaskan oleh kelas Serangga. Ini
diilustrasikan pada Gambar 7.2.
Gambar 7.2 Objek lalat
dan objek nyamuk adalah objek-objek
dari kelas Serangga
Menciptakan
Kelas
Anda menciptakan sebuah kelas dengan
menuliskan deklarasi kelas. Ini merupakan bentuk umum dari
sebuah deklarasi kelas:
class NamaKelas
{
Deklarasi anggota-anggota
kelas di sini…
}
Baris pertama dari sebuah deklarasi kelas
dikenal sebagai header kelas. Ia diawali dengan kata class,
yang diikuti dengan nama kelas. Aturan penamaan variabel berlaku juga pada
penamaan kelas. Kebanyakan programer mengikuti konvensi dengan memberikan huruf
besar diawal nama kelas. Ini dapat membantu mempermudah membedakan nama kelas
dari nama variabel ketika membaca kode.
Yang ada setelah header kelas adalah kurung
kurawal pembuka. Selanjutnya, Anda menuliskan deklarasi-deklarasi anggota
kelas. Ini merupakan statemen-statemen yang mendefinisikan bidang-bidang,
properti-properti, dan metode-metode. Sebuah kurung kurawal penutup ditempatkan
di akhir deklarasi kelas.
Lihat contoh sederhana berikut. Dimisalkan
bahwa Anda sedang menuliskan sebuah program untuk mensimulasikan pelemparan
koin. Pada program, Anda perlu secara berulang melempar sebuah koin dan
menentukan apakah kepala atau ekor yang merupakan sisi yang ada di atas.
Pertama, Anda menuliskan sebuah kelas dengan nama Koin yang dapat melakukan watak koin. Kode berikut menunjukkan
kelas Koin. (Perhatikan bahwa kelas
ini hanya sebagian dari kode aplikasi. Sebentar lagi, Anda akan melihat di mana
ia dapat ditempatkan di dalam projek, tetapi untuk sekarang, Anda hanya perlu
fokus pada kelas ini saja).
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
|
class Koin
{
//Bidang untuk merepresentasikan sisi yang menghadap ke atas
private string sisiAtas;
//Konstruktor
public Koin()
{
sisiAtas = "Kepala";
}
//Metode Lempar mensimulasikan pelemparan
koin
public void Lempar()
{
//Menciptakan sebuah objek Random
Random rand = new Random();
//Menggunakan sebuah nilai acak untuk
menentukan
//sisi koin yang menghadap ke atas
//0 = Kepala, 1 = Ekor
if (rand.Next(2) == 0)
{
sisiAtas = "Kepala";
}
else
{
sisiAtas = "Ekor";
}
}
//Metode GetSisiAtas menghasilkan nilai
dari
//bidang sisiAtas
public string GetSisiAtas()
{
return sisiAtas;
}
}
|
Baris pertama adalah header kelas. Ia
menetapkan bahwa nama kelas adalah Koin.
Kurung kurawal yang ada pada baris 2 dan baris 37 mengapit isi kelas. Amati
lebih dekat kode yang ada di dalam kelas:
Baris 4: Statemen ini mendeklarasikan sebuah bidang
dengan nama sisiAtas. Bidang
sisiAtas marupakan variabel string yang mengindikasikan sisi koin mana yang
menghadap ke atas. Jika sisi kepala menghadap ke atas, maka string “Kepala”
ditugaskan kepada bidang ini. Jika sisi ekor menghadap ke atas, maka string
“Ekor” ditugaskan kepada bidang ini.
Perhatikan bahwa deklarasi bidang diawali
dengan katakunci private. Katakunci private merupakan pemodifikasi akses
yang menetapkan bahwa bidang tidak dapat diakses secara langsung oleh
statemen-statemen dari luar kelas.
Dengan menggunakan pemodifikasi akses
private, sebuah kelas dapat menyembunyikan datanya dari kode di luar kelas.
Ketika bidang-bidang dari suatu kelas tersembunyi dari kode yang ada di luar
kelas, maka data itu diproteksi dari pemodifikasian data yang tak diinginkan.
Hal ini merupakan pendekatan umum yang dilakukan untuk membuat semua bidang private
dan untuk menyediakan akses terhadap bidang-bidang itu hanya melalui
metode-metode di dalam kelas saja.
Baris 7-10: Kode ini mendefinisikan suatu metode
spesial yang dikenal sebagai konstruktor.
Konstruktor adalah sebuah metode yang secara otomatis dieksekusi ketika suatu
objek diciptakan. Pada banyak kasus, konstruktor dipakai untuk menginisialisasi
bidang-bidang dari sebuah objek dengan nilai-nilai awal. Metode ini dikatakan
konstruktor karena ia membantu mengkonstruksi suatu objek.
Konstruktor ini melakukan pekerjaan
sederhana. Pada baris 9, ia menugaskan string “Kepala” kepada bidang sisiAtas. Hasilnya, setiap kali Anda
menciptakan suatu objek dari kelas Koin,
bidang sisiAtas dari objek itu
awalnya akan ditugasi string “Kepala”.
Perhatikan hal berikut tentang header
konstruktor pada baris 7:
·
Nama konstruktor sama dengan nama kelas. Pada kasus ini, nama
konstruktor adalah Koin.
·
Header tidak menetapkan tipe nilai balik, bahkan tidak void.
· Header konstruktor diawali dengan pemodifikasi akses public. Pada banyak kasus, kontruktor
dideklarasikan public. Pada buku
ini, Anda akan selalu menggunakan pemodifikasi publik pada konstruktor.
Baris 13-29: Kode ini mendefinisikan sebuah metode void dengan nama Lempar. Perhatikan bahwa pemodifikasi akses public dipakai pada header metode pada baris 13. Karena metode
dideklarasikan publik, ia dapat dipanggil dari kode di luar kelas Koin.
Tujuan dari metode Lempar adalah untuk mensimpulasikan pelemparan koin. Ketika metode
ini dipanggil, baris 16 akan menciptakan sebuah objek Random, yang direferensi oleh variabel rand. Statemen if pada
baris 21 mendapatkan suatu nilai acak dalam rentang 0 atau 1. Jika nilai acak
adalah 0, maka baris 23 akan menugaskan string “Kepala” kepada bidang sisiAtas. Sebaliknya, baris 27 menugaskan
string “Ekor” kepada bidang sisiAtas.
Baris 33-36: Kode ini mendefinisikan suatu metode dengan
nama GetSisiAtas. Perhatikan bahwa
pemodifikasi akses public digunakan
pada baris 33, yang berarti bahwa metode ini dapat dipanggil dari kode di luar
kelas Koin. Selain itu, perhatikan
bahwa metode ini menghasilkan suatu string.
Tujuan dari metode GetSisiAtas adalah untuk menghasilkan sebuah string yang mengindikasikan
sisi mana dari koin yang menghadap ke atas. Perhatikan bahwa pada baris 35,
nilai dari bidang sisiAtas dijadikan
nilai balik.
Menciptakan Objek
Ingat, kelas bukanlah sebuah objek tetapi
deskripsi dari suatu objek. Kelas Koin
menetapkan apa yang dimuat di dalam suatu objek Koin, tetapi kelas itu sendiri tidak menciptakan sebuah objek Koin di dalam memori. Untuk menciptakan
suatu objek Koin, Anda perlu
menuliskan statemen semacam ini:
Koin koinKu = new Koin();
Pada titik ini, Anda telah menciptakan banyak
objek, jadi statemen semacam ini tentu familiar bagi Anda. Sebagai contoh,
objek Random, array, dan List semuanya diciptakan dengan cara
ini. Lihat bagian-bagian yang berbeda dari statemen ini:
·
Bagian pertama dari statemen, yang ditampilkan di sisi kiri dari
operator =, yaitu Koin koinKu. Ini mendeklarasikan suatu
variabel dengan nama koinKu yang
dapat dipakai untuk mereferensi sebuah objek dari kelas Koin.
·
Bagian kedua dari statemen, yang ditampilkan di sisi kanan dari operator
=, yaitu new Koin(). Ekspresi ini
menciptakan sebuah objek dari kelas Koin
dan memanggil konstruktor kelas. Operator new
menghasilkan sebuah referensi yang menunjuk ke objek itu.
·
Operator = menugaskan referensi yang dihasilkan dari operator new kepada variabel koinKu.
Setelah statemen ini dieksekusi, variabel koinKu akan mereferensi suatu objek Koin, seperti ditunjukkan pada Gambar 7.3.
Perhatikan pada gambar bahwa bidang sisiAtas
dari objek ditetapkan menjadi “Kepala”, sebagai hasil dari konstruktor.
Gambar 7.3 Variabel koinKu mereferensi sebuah objek Koin
CATATAN: Kelas adalah tipe refeensi. Ketika Anda
menciptakan sebuah objek dari suatu kelas, Anda dapat menggunakan sebuah variabel
referensi untuk mereferensi objek itu. Ketika Anda ingin bekerja dengan objek
itu, Anda menggunakan variabel referensi tersebut.
Setelah Anda menciptakan sebuah objek Koin, Anda dapat menerapkan
operasi-operasi terhadap objek itu. Sebagai contoh, dengan mengasumsikan
variabel koinKu mereferensi sebuah
objek Koin, statemen berikut
memanggil metode Lempar dari objek:
koinKu.Lempar();
Dan, statemen berikut menampilkan sisi koin
yang menghadap ke atas:
MessageBox.Show(koinKu.GetSisiAtas());
Di mana Menulis Deklarasi Kelas
Dalam C#, Anda memiliki fleksibilitas dalam
memilih di mana menuliskan deklarasi kelas. Ketika Anda memulai menuliskan
kelas sendiri di dalam sebuah projek, adalah dimungkinkan untuk menuliskannya
di dalam file yang sama yang memuat kelas form. Gambar 7.4 menunjukkan sebuah
contoh bagaimana kelas Koin dapat
dituliskan di dalam file yang sama dengan kelas Form1 dari projek. Perhatikan pada gambar bahwa kelas Koin dituliskan di dalam namespace
projek. Hal ini tidak diharuskan, tetapi adalah hal yang baik karena kelas Koin merupakan bagian dari projek.
Meskipun pendekatan ini dapat diterima untuk
kelas yang berukuran kecil, Anda direkomendasikan bahwa Anda menuliskan setiap
kelas pada file terpisah. Dengan melakukannya, kode Anda dapat lebih
terorganisir. Pada buku ini, Anda akan selalu menyimpan kelas pada file
terpisah.
Gambar 7.4 Kelas Form1
dan kelas Koin berada di dalam file
yang sama
Visual Studio mempermudah proses penambahan
sebuah file kelas baru pada suatu projek. Ketika Anda ingin menuliskan sebuah
kelas baru, ikuti langkah-langkah berikut:
1. Dengan projek terbuka
pada Visual Studio, klik pada PROJECT
pada batang menu; kemudian pilih Add
Class…. Ini ditampilkan pada Gambar 7.5.
2. Jendela Add New Item, seperti
ditunjukkan pada Gambar 7.6, akan ditampilkan. Pastikan Class diseleksi sebagai tipe item. Perhatikan pada gambar bahwa Class1.cs ditampilkan pada kotak teks Name. Ini merupakan nama file default
yang disediakan oleh Visual Studio. Ubah namanya sesuai dengan nama kelas yang
Anda ciptakan. Sebagai contoh, jika Anda menciptakan sebuah kelas dengan nama Koin, Anda mengubah namanya menjadi Koin.cs. (Pastikan agar nama file
diakhiri dengan ekstensi .cs).
3.
Klik tombol Add.
Setelah melakukan langkah-langkah ini, file
kode sumber akan diciptakan pada projek dan akan ditampilkan pada editor kode.
File kode sumber akan memuat sejumlah direktif using dan sebuah deklarasi kelas
kosong yang dapat Anda edit. Gambar 7.7 menunjukkan salah satu contohnya. Anda
juga akan melihat sebuah entri untuk file kode sumber baru pada jendela Solution Explorer, seperti ditunjukkan pada gambar 7.8.
Gambar 7.7 Sebuah file kelas baru ditampilkan pada
editor kode
Tutorial 7.1 memandu Anda dalam proses
menciptakan kelas Koin pada sebuah
aplikasi yang menggunakannya untuk mensimulasikan pelemparan koin.
Gambar 7.8 Jendela Solution
Explorer
Tutorial 7.1: Menciptakan dan Menggunakan Kelas Koin
Pada tutorial
ini, Anda akan menciptakan sebuah aplikasi Melempar
Koin. Form aplikasi, yang telah
diciptakan untuk Anda, ditampilkan pada Gambar 7.9. Ketika Anda menjalankan
aplikasi, Anda dapat mengklik tombol Lempar
Lima Kali dan aplikasi akan mensimulasikan sebuah koin yang sedang dilempar
lima kali. Hasil dari tiap pelemparan koin akan ditampilkan pada kotak list.
Gambar 7.9 Form aplikasi Melempar
Koin
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka projek dengan nama Melempar Koin.
Langkah 2: Klik menu PROJECT pada batang menu Visual Studio dan kemudian klik Add Class…. Jendela Add New Item
akan ditampilkan. Pastikan Class
diseleksi sebagai tipe item. Ubah nama file default menjadi Koin.cs, seperti ditunjukkan pada
Gambar 7.10, dan kemudian klik pada tombol Add.
Ini akan menambahkan sebuah kode sumber dengan nama Koin.cs pada projek.
Langkah 3: File AkunSimpanan.cs
sekarang akan ditampilkan pada editor kode, seperti ditunjukkan pada Gambar 7.11.
Perhatikan bahwa file telah memuat sejumlah direktif using dan sebuah kelas Koin
kosong yang telah diciptakan. Sempurnakan kode untuk kelas Koin dengan mengetikkan baris 11-45 pada Program 7.11.
Langkah 4: Selanjutnya, Anda menciptakan event-event
handler Click untuk kontrol-kontrol
Button. Klik tab dengan tuliskan Form1.cs
[Design] untuk mengganti view Anda menjadi mode Design.
Gambar 7.10 Nama file diubah menjadi Koin.cs
Gambar 7.11 File Koin.cs
pada editor kode
Program 7.1 Kode utuh untuk file Koin.cs pada projek Melempar
Koin
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
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Melempar_Koin
{
class Koin
{
//Bidang
untuk merepresentasikan sisi yang menghadap ke atas
private
string sisiAtas;
Random
rand = new Random();
//Konstruktor
public
Koin()
{
sisiAtas = "Kepala";
}
//Metode
Lempar mensimulasikan pelemparan koin
public
void Lempar()
{
//Menciptakan sebuah objek Random
Random rand = new Random();
//Menggunakan suatu nilai acak untuk menentukan
//sisi koin yang menghadap ke atas
//0 =
Kepala, 1 = Ekor
if
(rand.Next(2) == 0)
{
sisiAtas = "Kepala";
}
else
{
sisiAtas = "Ekor";
}
}
//Metode
GetSisiAtas menghasilkan nilai dari
//bidang
sisiAtas
public
string GetSisiAtas()
{
return sisiAtas;
}
}
}
|
Langkah 5: Klik ganda pada kontrol tombolLempar. Ini membukan file Form1.cs pada editor kode, dan Anda
akan melihat sebuah event handler kosong dengan nama tombolLempar_Click. Sempurnakan event handler tersebut dengan
menetapkan kode yang ditunjukkan pada baris 22-36 pada Program 7.2. Amati kode
ini:
Baris 23: Statemen ini melakukan hal-hal berikut:
·
Ia mendeklarasikan sebuah variabel referensi Koin dengan nama koinKu.
·
Ia menciptakan sebuah objek Koin
di dalam memori dan memanggil konstruktornya.
·
Ia menugaskan sebuah referensi yang menunjuk ke objek Koin kepada variabel koinKu.
Setelah statemen ini dieksekusi, variabel koinKu akan mereferensi sebuah objek Koin. Bidang sisiAtas dari objek akan ditetapkan “Kepala”.
Baris 26: Statemen ini menghapus kontrol kotakListKeluaran.
Baris 29-36: Loop for
ini beriterasi lima kali, yang mensimulasikan lima kali pelemparan koin. Selama
tiap iterasi, aksi-aksi berikut terjadi:
·
Baris 32 memanggil metode koinKu.Lempar().
·
Baris 35 memanggil metode koinKu.GetSisiAtas()
untuk mendapatkan sisi koin yang menghadap ke atas. Hasil dari pemanggilan
metode ini ditampilkan pada kontrol kotakListKeluaran.
Langkah 6: Tukar view Anda kembali ke mode Design dari form Form1 dan klik ganda pada kontrol tombolKeluar. Pada editor kode, Anda akan melihat sebuah event
handler kosong dengan nama tombolKeluar_Click.
Sempurnakan event handler tersebut dengan mengetikkan kode yang ditunjukkan
pada baris 41-42 pada Program 7.2.
Program 7.2 Kode utuh untuk Form1 pada projek Melempar
Koin
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
|
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 Melempar_Koin
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
private
void tombolLempar_Click(object sender, EventArgs e)
{
//Menciptakan sebuah objek Koin
Koin
koinKu = new Koin();
//Membersikan ListBox
kotakListKeluaran.Items.Clear();
//Melempar koin lima kali
for
(int hitung = 0; hitung < 5; hitung++)
{
//Melempar koin
koinKu.Lempar();
//Menampilkan sisi yang mengharap ke atas
kotakListKeluaran.Items.Add(koinKu.GetSisiAtas());
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Langkah 7: Simpan projek. Kemudian tekan F5 atau klik Start Debugging untuk mengkompilasi dan menjalankan aplikasi. Ketika
aplikasi dijalankan, klik tombol Lempar
Lima Kali dan lihat hasil yang didapatkan. Gambar 7.12 menunjukkan salah
satu contoh keluaran dari aplikasi.
Gambar 7.12 Contoh keluaran dari aplikasi Melempar Koin
Melewatkan
Objek Kepada Metode
Ketika Anda sedang mengembangkan
aplikasi-aplikasi yang bekerja dengan objek-objek, Anda seringkali perlu
menuliskan metode-metode yang menerima objek sebagai argumennya. Sebagai
contoh, kode berikut menunjukkan sebuah metode dengan nama TampilStatusKoin yang menerima sebuah objek Koin sebagai argumennya:
1
2
3
4
5
|
private void TampilStatusKoin(Koin
koin)
{
MessageBox.Show("Sisi koin ini
menghadap ke atas: " +
koin.GetSisiAtas());
}
|
Contoh kode berikut menunjukkan bagaimana
Anda menciptakan sebuah objek Koin
dan kemudian melewatkannya sebagai argumen kepada metode TampilStatusKoin:
Koin koinKu = new Koin();
TampilStatusKoin(koinKu);
Karena kelas adalah tipe referensi, objek
yang merupakan objek dari suatu kelas selalu dilewatkan dengan referensi.
Ketika Anda melewatkan sebuah objek dari suatu kelas sebagai argumen, apa yang
dilewatkan kepada variabel parameter adalah sebuah referensi ke objek itu.
Hasilnya, metode yang menerima objek sebagai argumen memiliki akses terhadap
objek aktual (bukan salinan objek). Sebagai contoh, lihat pada metode Balik berikut:
1
2
3
4
|
private void Balik(Koin koin)
{
koin.Lempar();
}
|
Metode ini menerima sebuah objek Koin sebagai argumennya, dan ia
memanggil metode Lempar. Kode
berikut mendemonstrasikan metode yang sedang dipanggil:
1
2
3
4
5
6
7
8
9
10
11
12
|
//Menciptakan sebuah objek Koin
Koin koinKu = new Koin();
//Ini akan menampilkan “Kepala”
MessageBox.Show(koinKu.GetSisiAtas());
//Melewatkan objek kepada metode
Balik
Balik(koinKu);
//Ini akan menampilkan “Kepala”,
atau ia akan
//menampilkan “Ekor”
MessageBox.Show(koinKu.GetSisiAtas());
|
Statemen pada baris 2 menciptakan sebuah
objek Koin, yang direferensi oleh
variabel koinKu. Baris 5 menampilkan
nilai dari bidang sisiAtas dari
objek koinKu. Karena konstruktor
objek menetapkan bidang sisiAtas
menjadi “Kepala”, Anda mengetahui bahwa baris 5 akan menampilkan string
“Kepala”. Baris 8 memanggil metode Balik,
yang melewatkan objek koinKu sebagai
argumen, dengan referensi. Di dalam metode Balik,
metode Lempar dari objek koinKu dipanggil. Baris 12 menampilkan
kembali nilai dari bidang sisiAtas
dari objek koinKu. Kali ini, Anda
tidak dapat memprediksi apakah “Kepala” atau “Ekor” yang akan ditampilkan
karena metode Lempar dari objek koinKu telah dipanggil.
7.2 Properti
KONSEP:
Properti adalah sebuah anggota kelas yang memuat sepotong data tentang suatu
objek. Properti diimplementasikan sebagai metode spesial yang menetapkan dan membaca
nilai dari bidang tertentu.
Properti adalah tipe spesial dari anggota
kelas sehingga suatu objek dapat memuat dan membaca sepotong data. Anda telah
familiar dengan properti karena Anda telah sering menggunakannya ketika
menciptakan form. Kontrol-kontrol GUI memiliki properti-properti yang
menentukan karakteristik-karakteristiknya. Sebagai contoh, properti Text dari sebuah kontrol Label menetukan teks yang akan
ditampilkan oleh kontrol.
Pada kode, Anda bekerja dengan properti
dengan cara sama ketika Anda bekerja dengan variabel. Sebagai contoh,
diasumsikan bahwa labelPesan adalah
nama dari kontrol Label. Anda dapat
menugaskan sebuah nilai spesifik kepada properti Text dari kontrol, seperti ditunjukkan di sini:
labelPesan.Text
= "Hallo";
Selain itu, Anda dapat menugaskan sebuah
properti kepada variabel. Statemen berikut menginisialisasi variabel str dengan properti Text dari kontrol labelPesan:
string
str = labelPesan.Text;
Dari contoh-contoh ini, Anda dapat melihat
bahwa sebuah properti adalah suatu anggota kelas yang berperilaku seperti
bidang publik. Properti memang bukanlah bidang publik. Ia memiliki dua metode
yang dikenal dengan aksesor, yang bekerja dalam kaitannya dengan bidang privat.
Bidang privat, yang dikenal sebagai bidang pendukung properti, memuat sembarang
data yang ditugaskan kepada properti. Aksesor dapat dipakai oleh kode dari luar
kelas untuk memperoleh nilai properti dan menugaskan nilai kepada properti.
Lihat contoh kelas sederhana yang memiliki
sebuah properti. Dimisalkan bahwa Anda ingin menciptakan sebuah kelas dengan
nama Peliharaan yang
merepresentasikan binatang peliharaan keluarga. Kode berikut menunjukkan
bagaiman kelas Peliharaan dapat
dituliskan:
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
|
class Peliharaan
{
//Bidang untuk nama peliharaan
private string _nama;
//Konstruktor
public Peliharaan()
{
_nama = "";
}
//Properti Nama
public string Nama
{
get
{
return _nama;
}
set
{
_nama = value;
}
}
}
|
Amati kode lebih dekat:
Baris 4: Statemen ini mendeklarasikan sebuah bidang
privat string dengan nama _nama.
Bidang _nama merupakan bidang
pendukung untuk properti Nama.
Ketika sebuah nilai ditugaskan kepada properti Nama, ia disimpan di dalam bidang _nama.
Perhatikan bahwa Anda telah mengawali nama
bidang dengan karakter garis-bawah. Ini bukanlah persyaratan, tetapi sejumlah
programer memulai nama dari bidang pendukung dengan karakter garis-bawah untuk
mengeliminasi kebingungan antara nama bidang dan nama properti. Dengan
mengikuti konvensi ini, ketika Anda membaca kode dan Anda melihat suatu nama
variabel yang diawali dengan karakter garis-bawah, Anda akan segera mengetahui
bahwa ia adalah sebuah bidang pendukung untuk suatu properti.
Baris 7-10: Ini adalah konstruktor kelas. Ketika sebuah
objek dari kelas Peliharaan
diciptakan, konstruktor ini akan menugaskan sebuah string kosong kepada bidang _nama.
Baris 13: Ini adalah awal dari suatu deklarasi
properti. Ia menetapkan tiga hal tentang properti:
·
public: Properti
dideklarasikan publik, sehingga ia dapat dipakai oleh kode yang ada di luar
kelas. (Hampir semua properti dideklarasikan publik).
·
string: Tipe data properti adalah
string.
·
Nama: Nama dari properti
adalah Nama.
Baris 14: Sebuah kurung kurawal pembuka ditampilkan
pada baris ini. Kurung kurawal penutup terkait ditampilkan pada baris 24. Di
antara kedua kurung kurawal ini adalah aksesor-aksesor properti Nama.
Baris 15-18: Ini adalah aksesor get dari properti. Anda
dapat memandang aksesor get sebagai sebuah metode yang menghasilkan nilai
properti. Anda dapat melihat bahwa baris 17 adalah sebuah statemen return, yang menghasilkan (menjadikan
nilai balik) nilai dari bidang _nama.
Aksesor get dieksekusi setiap kali
properti dibaca.
Baris 20-23: Ini adalah aksesor set dari properti. Tujuan dari aksesor set adalah untuk menetapkan properti menjadi suatu nilai tertentu.
Aksesor set memiliki sebuah parameter implisit dengan nama value. Ia dikatakan implisit karena ia tidak dideklarasikan,
seperti parameter biasa. Parameter value
secara otomatis diciptakan oleh kompiler, dan tipe datanya sama dengan tipe
data properti. Pada kasus ini, tipe data dari parameter value adalah string.
Setiap kali suatu nilai ditugaskan kepada properti, aksesor set dari properti itu akan dieksekusi,
dan nilai yang ditugaskan akan dilewatkan kepada parameter value. Baris 22 menugaskan parameter value kepada bidang _nama.
Kode berikut menunjukkan bagaimana Anda dapat
menggunakan properti Nama dari kelas
Peliharaan:
1
2
3
4
5
6
7
8
9
10
11
|
//Menciptakan dua objek
Peliharaan
Peliharaan anjingKu = new Peliharaan();
Peliharaan kucingKu = new Peliharaan();
//Menetapkan properti Nama
masing-masing objek
anjingKu.Nama = "Jaultop";
kucingKu.Nama = "Kati";
//Menampilkan nama
MessageBox.Show("Nama
anjingku adalah " + anjingKu.Nama);
MessageBox.Show("Nama
kucingku adalah " + kucingKu.Nama);
|
Amati kode ini lebih dekat:
Baris 2: Statemen ini menciptakan sebuah objek Peliharaan, memanggil konstruktor kelas
Peliharaan, dan menugaskan suatu referensi yang menunjuk ke objek Peliharaan kepada objek anjingKu. Setelah statemen ini
dieksekusi, variabel anjingKu akan
mereferensi sebuah objek Peliharaan.
Baris 3: Statemen ini menciptakan sebuah objek Peliharaan, memanggil konstruktor kelas
Peliharaan, dan menugaskan sebuah
referensi yang menunjuk ke objek kepada variabel kucingKu. Setelah statemen ini dieksekusi, variabel kucingKu akan mereferensi sebuah objek Peliharaan.
Baris 6: Statemen ini menetapkan properti Nama dari objek anjingKu menjadi “Jaultop”. Ketika statemen ini dieksekusi, aksesor
set dari properti Nama akan
dieksekusi, dan string “Jaultop” akan dilewatkan kepada parameter value. Parameter value kemudian
ditugaskan kepada bidang _nama dari
objek anjingKu. Proses ini
diilustrasikan pada Gambar 7.13.
Gambar 7.13 Menetapkan properti Nama dari objek anjingKu
menjadi “Jaultop”
Baris 7: Statemen ini menetapkan properti Nama dari objek kucingKu menjadi “Kati”. Ketika statemen ini dieksekusi, aksesor set dari properti Nama akan dieksekusi, dan string “Kati” akan dilewatkan kepada parameter value. Parameter value kemudian ditugaskan kepada bidang _nama dari objek kucingKu.
Baris 10: Statemen ini menampilkan pesan “Nama anjingku adalah Jaultop” pada
sebuah kotak pesan. Ketika properti Nama
dari objek anjingKu dibaca, aksesor get akan menghasilkan nilai dari bidang
_nama dari objek.
Baris 11: Statemen ini menampilkan pesan “Nama kucingku adalah Kati” pada sebuah
kotak pesan. Ketika properti Nama
dari objek kucingKu dibaca, aksesor get akan menghasilkan nilai dari bidang
_nama dari objek.
Ketika sebuah aksesor hanya memuat satu
statemen, banyak programer lebih memilih menuliskan keseluruhan aksesor dalam
satu baris kode. Sebagai contoh, properti Nama
pada kelas Peliharaan dapat dituliskan seperti ini:
//Properti
Nama
public
string Nama
{
get { return _nama; }
set { _nama = value; }
}
Gaya penulisan ringkas seperti ini mereduksi
banyak baris kode tanpa mengorbankan keterbacaan kode.
Properti Versus Bidang Publik
Pada titik ini, Anda mungkin bertanya-tanya
mengapa Anda perlu repot-repot menciptakan properti, sedangkan hal itu lebih
mudah dilakukan dengan hanya menciptakan bidang publik. Sebagai contoh, pada
kelas Peliharaan, bukankah Anda
cukup hanya mendeklarasikan sebuah bidang string
publik dengan nama Nama? Jika bidang
dideklarasikan publik, ia dapat diakses secara langsung oleh kode yang ada di
luar kelas tanpa dibutuhkan adanya aksesor.
Memang pendekatan ini dimungkinkan, tetapi hal
ini tidak direkomendasikan. Bidang kelas hampir selalu dideklarasikan private
untuk memproteksinya dari pemodifikasian yang tidak disengaja. Ketika kode yang
ada di luar kelas perlu mengakses suatu bidang, ia melakukannya melalui metode
publik (atau pada kasus properti, melalui aksesor). Ini memastikan bahwa objek
yang memiliki bidang dapat mengendalikan semua perubahan yang dilakukan pada
bidang tersebut.
Melewatkan Properti Sebagai Argumen
Anda dapat melewatkan sebuah properti sebagai
argumen kepada suatu metode. Sebagai contoh, baris 8 pada kode berikut
melewatkan sebuah properti Nama dari
objek Peliharaan sebagai argumen
kepada metode MessageBox.Show.
1
2
3
4
5
6
7
8
|
//Menciptakan sebuah objek
Peliharaan
Peliharaan anjingKu = new Peliharaan();
//Menetapkan properti Nama dari
objek
anjingKu.Nama = "Jaultop";
//Menampilkan properti Nama
MessageBox.Show(anjingKu.Nama);
|
Ketika Anda melewatkan sebuah properti
sebagai argumen kepada suatu metode, ada satu aturan: Properti hanya dapat
diakses lewat nilai. Jika Anda mencoba melewatkan sebuah properti kepada parameter
ref atau out, maka error akan terjadi.
Tutorial 7.2 akan memandu Anda dalam proses
menciptakan suatu kelas yang memuat beberapa properti. Anda akan menggunakan
kelas pada sebuah aplikasi yang menciptakan sebuah objek kelas dan menguji
properti-propertinya.
Tutorial 7.2: Menciptakan dan Menggunakan Kelas TeleponSel
Dimisalkan
bahwa Anda bekerja sebagai seorang programer untuk suatu perusahaan yang
menjual telepon seluler dan layanan nirkabel. Departemen Anda akan menciptakan
sebuah aplikasi untuk mengelola sistem inventori perusahaan. Anda diminta untuk
menciptakan sebuah kelas yang merepresentasikan sebuah telepon seluler. Kelas
tersebut harus memiliki data berikut perihal sebuah telepon seluler:
·
Nama merek telepon
·
Model telepon
·
Harga ritel telepon
Kelas
sebaiknya memiliki properti-properti berikut:
·
Merek: sebuah properti string yang akan menyimpan nama merek
telepon.
·
Model: sebuah properti string yang akan memuat model telepon.
·
Harga: sebuah properti decimal yang akan memuat harga ritel
telepon.
Kelas juga
akan memiliki bidang-bidang privat berikut:
·
_merek: sebuah string yang berperan sebagai bidang
pendukung untuk properti Merek.
·
_model: sebuah string yang berperan sebagai bidang
pendukung untuk properti Model.
·
_harga: sebuah decimal yang berperan sebagai bidang
pendukung untuk properti Harga.
Kelas ini
juga akan memiliki sebuah konstruktor yang menginisialisasi bidang-bidang
privat. Bidang _merek dan bidang _model akan diinisialisasi dengan
string kosong, dan bidang _harga
akan diinisialisasi dengan nilai 0.
Anda
menciptakan kelas TeleponSel pada
sebuah projek yang akan menciptakan sebuah objek kelas dan menguji
properti-properti objek. Projek diberi nama Uji Telepon Sel dan diciptakan bagi Anda. Gambar 7.14a menunjukan
form aplikasi. Pada saat aplikasi dijalankan, Anda akan memasukkan data telepon
seluler ke dalam kotak-kotak teks dan kemudian mengklik tombol Ciptakan Objek. Aplikasi akan menciptakan sebuah objek dari kelas TeleponSel dan menugaskan data dari
kotak-kotak teks tersebut kepada properti-properti objek. Ia kemudian membaca
dan menampilkan nilai dari tiap properti objek pada kontrol labelMerek, labelModel, dan labelHarga.
Gambar 7.14a Form aplikasi Uji Telepon Sel
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka projek dengan nama Uji Telepon Sel.
Langkah 2: Klik menu PROJECT pada batang menu Visual Studio dan kemudian klik Add Class…. Jendela Add New Item
akan ditampilkan. Pastikan Class
diseleksi sebagai tipe item. Ubah nama file default menjadi TeleponSel.cs dan kemudian klik pada
tombol Add. Ini akan menambahkan
sebuah kode sumber dengan nama TeleponSel.cs
pada projek.
Langkah 3: File TeleponSel.cs
akan ditampilkan pada editor kode. Sempurnakan kode untuk kelas TeleponSel dengan mengetikkan baris
11-43 pada Program 7.3.
Program 7.3 Kode utuh untuk file TeleponSel.cs pada projek Uji
Telepon Sel
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
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Uji_Telepon_Sel
{
class
TeleponSel
{
//
Bidang-Bidang
private
string _merek; //Merek telepon
private
string _model; //Model telepon
private
decimal _harga; //Harga ritel
//Konstruktor
public
TeleponSel()
{
_merek = "";
_model = "";
_harga = 0m;
}
//Properti
Merek
public
string Merek
{
get {
return _merek; }
set {
_merek = value; }
}
//Properti Model
public
string Model
{
get {
return _model; }
set {
_model = value; }
}
//Properti Harga
public
decimal Harga
{
get {
return _harga; }
set {
_harga = value; }
}
}
}
|
Langkah 5: Selanjutnya Anda menciptakan event-event handler untuk
kontrol-kontrol Button. Tukar view
Anda ke form Form1 pada mode Designer. Klik ganda pada kontrol tombolCiptakan. Ini akan membuka file Form1.cs pada editor kode, dan Anda
akan melihat sebuah event handler kosong dengan nama tombolCiptakan_Click. Sempurnakan event handler ini dengan
mengetikkan kode yang ditunjukkan pada baris 48-57 pada Program 7.4. Amati kode
ini dengan lebih dekat:
Baris 49: Statemen ini menciptakan sebuah objek TeleponSel di dalam memori, yang
direferensi oleh sebuah variabel dengan nama teleponKu.
Baris 52: Statemen ini memanggil metode GetDataTelepon, yang melewatkan objek teleponKu sebagai argumen.
Baris 55-57: Statemen-statemen ini menampilkan nilai dari properti Merek, Model, dan Harga dari
objek teleponKu pada kontrol labelMerek, labelModel, dan labelHarga.
Langkah 6: Tukar view kembali ke form Form1 pada 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 dengan mengetikkan kode yang ditunjukkan pada baris 62-63 pada Program 7.4.
Program 7.4 Kode utuh untuk file Form1.cs pada projek Uji
Telepon Sel
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
|
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 Uji_Telepon_Sel
{
public
partial class Form1 : Form
{
public
Form1()
{
InitializeComponent();
}
//Metode
GetDataTelepon menerima sebuah objek TeleponSel
//sebagai
argumen. Ia menugaskan data yang dimasukkan oleh
//user
kepada properti-properti dari objek
private
void GetDataTelepon(TeleponSel telepon)
{
//Variabel temporer untuk memuat harga
decimal harga;
//Membaca merek telepon
telepon.Merek = teksMerek.Text;
//Membaca model telepon
telepon.Model = teksModel.Text;
//Membaca harga telepon
if
(decimal.TryParse(teksHarga.Text, out harga))
{
telepon.Harga = harga;
}
else
{
//Menampilkan pesan error
MessageBox.Show("Harga tidak valid");
}
}
private
void tombolCiptakan_Click(object sender, EventArgs e)
{
//Menciptakan sebuah objek TeleponSel
TeleponSel teleponKu = new TeleponSel();
//Membaca data telepon
GetDataTelepon(teleponKu);
//Menampilkan data telepon
labelMerek.Text = teleponKu.Merek;
labelModel.Text = teleponKu.Model;
labelHarga.Text = "Rp. " + teleponKu.Harga.ToString();
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Langkah 7: Simpan projek dan jalankan aplikasi. Berikut adalah
salah satu contoh keluaran aplikasi, seperti ditunjukkan pada Gambar 7.14b.
Gambar 7.14b Contoh keluaran saat aplikasi dijalankan
Properti Read-Only
Kadangkala adalah berguna untuk membuat
sebuah properti menjadi read-only. Properti read-only dapat dibaca, tetapi ia
tidak dapat dimodifikasi. Jika Anda perlu membuat sebuah properti menjadi
read-only, Anda tidak perlu mencantumkan aksesor set untuk properti tersebut. Kelas Lingkaran berikut menunjukkan salah satu contohnya:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class Lingkaran
{
//Bidang
private double _diameter;
//Konstruktor
public Lingkaran()
{
_diameter = 0.0;
}
//Properti Diameter
public double Diameter
{
get { return _diameter; }
set { _diameter = value; }
}
//Properti Radius(read-only)
public double Radius
{
get { return _diameter / 2; }
}
}
|
Kelas ini memiliki dua properti. Diameter (didefinisikan pada baris
13-17) dan Radius (didefinisikan
pada baris 2023). Perhatikan bahwa properti Radius memiliki sebuah aksesor get
tetapi ia tidak memiliki aksesor set.
Properti Radius adalah properti
read-only. Oleh karena itu, jika Anda menciptakan sebuah objek dari kelas Lingkaran, Anda dapat memperoleh nilai
dari properti Radius, tetapi akan
terjadi error jika Anda mencoba untuk menugaskan suatu nilai kepada properti Radius.
7.3 Konstruktor Berparameter dan Pembebanan
(Overloading)
KONSEP:
Sebuah konstruktor yang menerima argumen dikenal dengan konstruktor
berparameter atau konstruktor terparameterisasi. Sebuah kelas yang memiliki
sejumlah versi dari metode yang sama dikenal dengan metode-metode yang
terbebani.
Konstruktor dapat menerima argumen dengan
cara yang sama seperti metode biasa. Konstruktor yang menerima argumen dikenal
sebagai konstruktor berparameter
karena ia memiliki variabel parameter.
Ketika sebuah kelas memiliki sebuah
konstruktor berparameter, Anda dapat melewatkan nilai-nilai inisialisasi kepada
konstruktor ketika Anda menciptakan suatu objek. Pada Tutorial 7.3, Anda akan
menuliskan sebuah kelas yang mensimulasikan sebuah akun bank. Konstruktor kelas
akan menerima sebuah argumen yang menetapkan saldo awal akun.
Tutorial 7.3: Menciptakan dan
Menggunakan Kelas AkunBank
Pada tutorial ini, Anda akan menuliskan
sebuah kelas dengan nama AkunBank
yang mensimulasikan sebuah akun bank. Ketika Anda menciptakan sebuah objek
kelas, Anda akan melewatkan saldo awal sebagai suatu argumen kepada
konstruktor. Kelas akan memiliki sebuah metode dengan nama Tabung yang menambahkan sejumlah uang pada saldo dan sebuah metode
dengan nama Tarik yang mengurangkan
sejumlah nilai dari saldo. Kelas juga akan memiliki sebuah properti read-only Saldo yang melaporkan saldo akun.
Kelas AkunBank
merupakan bagian dari aplikasi Simulator
Akun, yang telah disediakan bagi
Anda. Gambar 7.15a menunjukkan form dari aplikasi. Ketika aplikasi dijalankan,
ia menciptakan sebuah objek AkunBank
dengan saldo awal Rp. 10000. Saldo ini ditampilkan pada kontrol labelSaldo. Jika Anda ingin melakukan
penabungan, Anda dapat memasukkan sejumlah nilai ke dalam kontrol teksTabung dan mengklik tombol Tabung. Jika Anda ingin melakukan
penarikan, Anda dapat memasukkan suatu nilai ke dalam teksTarik dan mengklik tombol Tarik.
Setiap kali Anda melakukan salah satu aksi ini, sebuah saldo akun baru akan
ditampilkan.
Gambar 7.15a Form aplikasi dari Simulator Akun
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka projek dengan nama Simulator Akun.
Langkah 2: Klik menu PROJECT pada batang menu Visual Studio dan kemudian klik Add Class…. Jendela Add New Item
akan ditampilkan. Pastikan Class
diseleksi sebagai tipe item. Ubah nama file default menjadi AkunBank.cs dan kemudian klik pada
tombol Add. Ini akan menambahkan
sebuah kode sumber dengan nama AkunBank.cs
pada projek.
Langkah 3: File AkunBank.cs
akan ditampilkan pada editor kode. Sempurnakan kode untuk kelas AkunBank dengan mengetikkan baris 11-36
pada Program 7.5.
Amati kode lebih dekat:
Baris 12: Statemen ini mendeklarasikan sebuah bidang
privat decimal dengan nama _saldo.
Bidang _saldo merupakan bidang
pendukung untuk properti Saldo.
Baris 15-18: Baris-baris kode ini adalah konstruktor
kelas berparameter. Ketika sebuah objek kelas diciptakan, sebuah argumen yang
menetapkan saldo awal akun dilewatkan kepada parameter saldoAwal. Pada baris 17, parameter saldoAwal ditugaskan kepada bidang _saldo.
Baris 21-24: Ini adalah kode untuk properti Saldo. Perhatikan bahwa properti ini
tidak memiliki aksesor set, jadi ia merupakan properti read-only.
Baris 27-30: Ini adalah metode Tabung, yang menerima sebuah argumen decimal dan menambahkan argumen pada bidang _saldo.
Baris 33-36: Inia adalah metode Tarik, yang menerima sebuah argumen decimal, dan mengurangkan
argumen dari bidang _saldo.
Program 7.5 Kode utuh untuk file AkunBank.cs pada projek Simulator
Akun
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
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Simulator_Akun
{
class
AkunBank
{
//Bidang
private
decimal _saldo;
//Konstruktor
public
AkunBank(decimal saldoAwal)
{
_saldo = saldoAwal;
}
//Properti Saldo (read-only)
public
decimal Saldo
{
get {
return _saldo; }
}
//Metode
Tabung
public
void Tabung(decimal jumlah)
{
_saldo += jumlah;
}
//Metode
Tarik
public
void Tarik(decimal jumlah)
{
_saldo -= jumlah;
}
}
}
|
Langkah 4: Buka file Form1.cs pada editor kode. Ketikkan komentar dan deklarasi yang
ditunjukkan pada baris 15 dan baris 16 dari Program 7.6. Statemen pada baris 16
melakukan hal berikut:
·
Ia menciptakan sebuah objek dari kelas AkunBank, yang melewatkan nilai 1000 sebagai argumen kepada
konstruktor.
·
Ia menugaskan sebuah referensi yang menunjuk ke objek kepada sebuah
bidang dengan nama akun.
Karena variabel akun dideklarasikan sebagai
sebuah bidang, maka semau metode di dalam kelas Form1 dapat mengaksesnya.
Langkah 5: Selanjutnya, Anda menciptakan sebuah event
handler Load untuk form. Event
handler Load menampilkan saldo akun
pada kontrol labelSaldo. Tukar view
Anda ke Form1 pada mode Designer dan klik ganda pada bagian
dari form yang tidak memuat kontrol. Ini akan membuka editor kode, dan Anda
akan melihat sebuah event handler kosong dengan nama Form1_Load. Sempurnakan event handler ini dengan mengetikkan kode
yang ditampilkan pada baris 25 dan baris 26 pada Program 7.6. Perhatikan pada
baris 26 menggunakan metode ToString
untuk menampilkan properti Saldo
dari objek akun dan menugaskan
hasilkan kepada properti Text dari
kontrol labelSaldo.
Langkah 6: Sekarang Anda menciptakan event-event
handler Click untuk kontrol-kontrol Button. Tukar view kembali ke form Form1 pada mode Designer dan klik ganda pada kontrol tombolTabung. Ini akan membuka editor kode, dan Anda akan melihat
sebuah event handler kosong dengan nama tombolTabung_Click.
Sempurnakan event handler ini dengan mengetikkan kode pada baris 31-49 pada
Program 7.6. Amati kode tersebut:
Baris 31: Statemen ini mendeklarasikan sebuah
variabel decimal lokal dengan nama jumlah. Ini akan memuat nilai yang
ingin ditabung oleh user.
Baris 34-49: Statemen if pada baris 34 memanggil metode decimal.TryParse untuk mengkonversi properti Text dari kontrol teksTabung
menjadi sebuah decimal, dan ia
menyimpan hasilnya pada variabel jumlah.
Jika konversi berhasil dilakukan, aksi-aksi berikut dilakukan:
·
Baris 37 memanggil metode Tabung
dari objek akun, yang melewatkan jumlah sebagai argumen.
·
Baris 40 menampilkan saldo akun.
·
Baris 43 membersihkan kontrol teksTabung.
Jika konversi tidak berhasil, baris 48 akan
menampilkan pesan error.
Langkah 7: Tukar view kembali ke form Form1 pada mode Designer dan klik ganda pada kontrol tombolTarik. Ini akan membuka editor kode, dan Anda akan melihat
sebuah event handler kosong dengan nama tombolTarik_Click.
Sempurnakan event handler ini dengan mengetikkan kode pada baris 54-72 pada
Program 7.6. Amati kode tersebut:
Baris 54: Statemen ini mendeklarasikan sebuah
variabel decimal lokal dengan nama jumlah. Ini akan memuat nilai yang
ingin ditarik oleh user.
Baris 57-72: Statemen if pada baris 57 memanggil metode decimal.TryParse untuk mengkonversi properti Text dari kontrol teksTarik
menjadi sebuah decimal, dan ia
menyimpan hasilnya pada variabel jumlah.
Jika konversi berhasil dilakukan, aksi-aksi berikut dilakukan:
·
Baris 60 memanggil metode Tarik
dari objek akun, yang melewatkan jumlah sebagai argumen.
·
Baris 63 menampilkan saldo akun.
·
Baris 66 membersihkan kontrol teksTarik.
Jika konversi tidak berhasil, baris 71 akan
menampilkan pesan error.
Gambar 7.15b Contoh keluaran ketika aplikasi dijalankan
Langkah 8: Kembali ke form Form1 pada 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 dengan menuliskan kode yang ditunjukkan pada baris 77-78 pada Program 7.6.
Langkah 9: Simpan projek dan jalankan aplikasi,
seperti ditunjukkan pada Gambar 7.15b.
Program 7.6 Kode utuh untuk file Form1.cs pada projek Simulator
Akun
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
|
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 Simulator_Akun
{
public
partial class Form1 : Form
{
//Bidang
AkunBank dengan saldo awal Rp. 1000
private
AkunBank akun = new AkunBank(1000);
public
Form1()
{
InitializeComponent();
}
private
void Form1_Load(object sender, EventArgs e)
{
//Menampilkan saldo awal
labelSaldo.Text = "Rp. " + akun.Saldo.ToString();
}
private
void tombolTabung_Click(object sender, EventArgs e)
{
decimal jumlah; //Memuat jumlah penabungan
//Mengkonversi jumlah menjadi sebuah decimal
if
(decimal.TryParse(teksTabung.Text, out jumlah))
{
//Menabung jumlah ke dalam akun
akun.Tabung(jumlah);
//Menampilkan saldo baru
labelSaldo.Text = "Rp. " + akun.Saldo.ToString();
//Membersikan kotak teks
teksTabung.Clear();
}
else
{
//Menampilkan pesan error
MessageBox.Show("Jumlah tidak valid");
}
}
private
void tombolTarik_Click(object sender, EventArgs e)
{
decimal jumlah; //Memuat jumlah penarikan
//Mengkonversi jumlah menjadi sebuah decimal
if
(decimal.TryParse(teksTarik.Text, out jumlah))
{
//Menarik jumlah dari akun
akun.Tarik(jumlah);
//Menampilkan saldo baru
labelSaldo.Text = "Rp. " + akun.Saldo.ToString();
//Membersikan kotak teks
teksTarik.Clear();
}
else
{
//Menampilkan pesan error
MessageBox.Show("Jumlah tidak valid");
}
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Pembebanan Metode
Kadangkala Anda memerlukan pelbagai cara
dalam melakukan operasi yang sama. Sebagai contoh, kelas AkunBank yang telah Anda tuliskan pada Tutorial 7.3 memiliki sebuah
metode Tabung yang menerima sebuah
argumen decimal. Dimisalkan bahwa
Anda sedang menggunakan kelas pada sebuah aplikasi yang perlu melewatkan sebuah
variabel double kepada metode. Pada
aplikasi ini, sebelum Anda memanggil metode Tabung, Anda perlu mengkonversi variabel double menjadi sebuah decimal sehingga ia dapat dilewatkan kepada
metode. Akan lebih baik jika metode Tabung
dapat menerima baik argumen decimal
maupun argumen double. Jadi, tidak
diperlukan untuk mengkonversi variabel double sebelum melewatkannya kepada metode.
Ini dapat dilakukan dengan pembebanan.
Ketika sebuah metode dibebani, ini berarti
bahwa beberapa metode di dalam kelas yang sama memiliki nama sama tetapi
menggunakan tipe-tipe parameter yang berbeda. Berikut adalah sebuah contoh
bagaimana Anda membebani metode Tabung
di dalam kelas AkunBank:
1
2
3
4
5
6
7
8
9
10
11
|
//Metode Tabung
public void Tabung(decimal jumlah)
{
_saldo += jumlah;
}
//Metode Tabung
public void Tabung(double jumlah)
{
_saldo += (decimal)jumlah;
}
|
Metode Tabung
pertama (pada baris 2-5) menerima sebuah argumen decimal, yang ditambahkan pada bidang _saldo pada baris 4). Metode Tabung
kedua (pada baris 8-11) menerima sebuah argumen double. Baris 10 menggunakan sebuah operator cast untuk
mengkonversi nilainya menjadi sebuah decimal,
dan menugaskan hasilnya kepada bidang _saldo.
Ketika Anda menuliskan suatu pemanggilan
terhadap metode Tabung, kompiler akan menenukan metode terbebani mana yang Anda
inginkan. Proses pencocokan pemanggilan metode disebut dengan pengikatan.
Ketika sebuah beban yang terbebani dipanggil, kompiler akan menggunakan nama
metode dan daftar parameter untuk menentukan metode mana yang diikat oleh
pemanggilan itu. Jika Anda memanggil metode Tabung dan melewatkan sebuah argumen decimal, maka versi dari metode yang memiliki sebuah parameter decimal lah yang dipanggil. Sama
halnya, jika Anda memanggil metode Tabung
dan melewatkan sebuah argumen double,
maka versi dari metode yang memiliki sebuah parameter double lah yang dipanggil.
Kompiler menggunakan sidik metode dalam
membedakan antara metode dengan nama sama. Sidik suatu metode memuat nama
metode dan tipe data dan jenis argumen (dengan nilai, ref, atau out), dari
kiri ke kanan. Sebagai contoh, berikut adalah dua sidik dari metode-metode Tabung:
Tabung(decimal)
Tabung(double)
Perhatikan bahwa tipe nilai balik dari metode
tidak menjadi bagian dari sidik. Karena alasan ini, Anda tidak bisa membebani
metode-metode dengan memberikannya tipe nilai balik yang berbeda.
Membebani Konstruktor
Konstruktor juga dapat dibebani, yang berarti
bahwa sebuah kelas dapat memiliki lebih dari satu konstruktor. Aturan dalam
pembebanan konstruktor sama dengan pembebanan metode biasa: Setiap versi
konstruktor harus memiliki daftar parameter yang berbeda. Sepanjang setiap
konstruktor memiliki sidik yang unik, kompiler dapat membedakannya. Berikut
adalah sebuah contoh bagaimana Anda membebani konstruktor kelas AkunBank:
1
2
3
4
5
6
7
8
9
10
11
|
//Konstruktor
public AkunBank()
{
_saldo = 0;
}
//Konstruktor
public AkunBank(decimal saldoAwal)
{
_saldo = saldoAwal;
}
|
Konstruktor pertama (baris 2-5) merupakan
suatu konstruktor tanpa parameter, yang berarti bahwa ia tidak menerima argumen
apapun. Statemen berikut memanggil konstruktor tanpa parameter ketika ia
menciptakan sebuah objek AkunBank:
AkunBank akun = new AkunBank();
Konstruktor kedua (baris 8-11) menerima
sebuah argumen decimal. Statemen
berikut memanggil konstruktor ini ketika ia menciptakan sebuah objek AkunBank:
AkunBank
akun = new AkunBank(500m);
Statemen berikut juga memanggil konstruktor
kedua (baris 8-11) karena suatu nilai integer dapat secara implisit dikonversi
menjadi suatu decimal:
AkunBank
akun = new AkunBank(500);
Kode berikut akan menyebabkan error, karena
tidak ada konstruktor yang menerima sebuah argumen double:
AkunBank
akun = new AkunBank(500.0);
Konstruktor Default
Adalah legal untuk menuliskan sebuah kelas
tanpa konstruktor. Jika Anda menuliskan sebuah kelas tanpa konstruktor,
kompiler akan menyediakan sebuah konstruktor default. Konstruktor default
adalah sebuah konstruktor tanpa parameter (ia tidak menerima argumen apapun),
dan ia menginisialisasi bidang-bidang objek dengan 0. (jika ada bidang yang
merupakan variabel referensi, variabel itu akan diinisialisasi dengan nilai
null).
7.4 Menyimpan Objek-Objek Tipe Kelas Di Dalam
Array dan List
KONSEP: Anda
dapat menyimpan sekumpulan objek bertipe kelas di dalam sebuah array atau
sebuah List.
Array yang
Memuat Objek-Objek Tipe Kelas
Objek-objek kelas dapat disimpan di dalam
suatu array. Sebagai contoh, diasumsikan bahwa kelas TeleponSel ada di dalam suatu aplikasi. Kode berikut menciptakan
sebuah array TeleponSel dengan empat
elemen:
const int UKURAN = 4;
TeleponSel[] telepon = new TeleponSel[UKURAN];
Meskipun kode ini menciptakan suatu array, ia
belum memuat satu objek pun. Ketika Anda menciptakan sebuah array dengan tipe
kelas, setiap elemen array merupakan variabel referensi. Secara default, setiap
elemen akan diinisialisasi dengan nilai null.
Langkah selanjutnya adalah menciptakan objek-objek yang akan direferensi oleh
setiap elemen. Ini dapat dilakukan satu per satu, seperti ditunjukkan di sini:
telepon[0] = new TeleponSel();
telepon[1] = new TeleponSel();
telepon[2] = new TeleponSel();
telepon[3] = new TeleponSel();
Atau, hal ini dapat dilakukan dengan loop,
seperti ditunjukkan di sini:
for (int indeks = 0; indeks < telepon.Length; indeks++)
{
telepon[indeks] = new TeleponSel();
}
Secara alternatif, Anda dapat
menginisialisasi elemen-elemen array di dalam statemen deklarasi:
TeleponSel[]
telepon = {
new TeleponSel(),
new TeleponSel(),
new TeleponSel(),
new TeleponSel()
};
Kode berikut menunjukkan contoh lain. Kode
ini menciptakan sebuah array AkunBank
dan menginisialisasi elemen-elemennya dengan referensi-referensi yang menunjuk
ke objek-objek AkunBank:
AkunBank[]
akun = {
new AkunBank(1000),
new AkunBank(2000),
new AkunBank(3000),
new AkunBank(4000)
};
Perhatikan argumen-argumen yang dilewatkan
kepada konstruktor AkunBank untuk
tiap objek. Jika kode berikut dieksekusi, ia akan menampilkan “Saldo adalah
1000”, “Saldo adalah 2000”, dan seterusnya:
for
(int indeks = 0; indeks < akun.Length; indeks++)
{
MessageBox.Show("Saldo
adalah " +
akun[indeks].Saldo);
}
List yang Memuat Objek-Objek Tipe
Kelas
Pada Bab 7, Anda telah mempelajari kelas List, yang merupakan sebuah kontainer
untuk menyimpan sekumpulan objek. Berikut adalah sebuah contoh bagaimana Anda
menciptakan sebuah List yang dapat
menampung objek-objek TeleponSel:
List<TeleponSel> daftarTelepon = new List<TeleponSel>();
Statemen ini menciptakan sebuah List, yang direferensi oleh variabel daftarTelepon. Perhatikan bahwa kata TeleponSel dituliskan di dalam kurung
siku, <>, yang ditempatkan setelah katakunci List. Ini menetapkan bahwa List
hanya dapat memuat objek-objek dari tipe kelas TeleponSel. Untuk menambahkan sebuah objek ke dalam sebuah List, Anda dapat menggunakan metode Add. Kode berikut menunjukkan salah
satu contohnya:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//Menciptakan sebuah List untuk
memuat objek-objek TeleponSel
List<TeleponSel> daftarTelepon
= new List<TeleponSel>();
//Menciptakan sebuah objek dari
kelas TeleponSel
TeleponSel teleponKu = new TeleponSel();
//Menugaskan nilai-nilai kepada
properti-properti dari objek
teleponKu.Merek = "Acme
Electronics";
teleponKu.Model = "M1000";
teleponKu.Harga = 199000;
//Menambahkan objek ke dalam
List
daftarTelepon.Add(teleponKu);
|
Statemen pada baris 2 menciptakan sebuah List dengan nama daftarTelepon yang dapat memuat objek-objek TeleponSel. Baris 5 menciptakan sebuah objek dari kelas TeleponSel, yang direferensi oleh
variabel teleponKu. Baris 8-10
menugaskan nilai-nilai kepada properti-properti dari objek. Baris 13
menambahkan objek itu ke dalam List.
Pada Tutorial 7.4, Anda menciptakan suatu aplikasi yang menggunakan sebuah List untuk menampung sekumpulan objek TeleponSel.
Tutorial 7.4: Menciptakan Aplikasi Inventori Telepon Sel
Pada tutorial
ini, Anda akan menciptakan sebuah aplikasi Inventori
Telepon Sel. Gambar 7.16 menunjukkan form aplikasi, yang telah disediakan
bagi Anda. Ketika Anda menjalankan aplikasi, Anda dapat memasukkan data tentang
sebuah telepon sel ke dalam kontrol-kontrol TextBox. Ketika Anda mengklik tombol Tambahkan Telepon, data
itu akan ditugaskan kepada properti-properti dari objek TeleponSel dan kemudian objek itu ditambahkan ke dalam suatu List. Anda dapat melakukan ini sebanyak
mungkin yang Anda inginkan. Setiap kali Anda menambahkan sebuah telepon sel,
merek dan modelnya akan ditampilkan pada kotak list. Jika Anda memilih sebuah
telepon pada kotak list, aplikasi akan menampilkan harga telepon tersebut.
Gambar 7.17
menunjukkan sebuah contoh dari aplikasi saat dijalankan, Pada gambar, lima
telepon sel telah ditambahkan, dan Atlantic Mobile S2 teleh dipilih pada kotak
list. Harga telepon terseleksi ditampilkan pada kotak pesan.
Gambar 7.16 Form aplikasi Inventori Telepon Sel
Langkah 1: Awali Visual Studio (atau Visual Studio Express). Buka
projek dengan nama Inventori Telepon Sel. Perhatikan bahwa kelas TeleponSel
telah ditambahkan pada projek untuk Anda pada file TeleponSel.cs.
Langkah 2: Buka Form1.cs
pada editor kode. Tuliskan komentar dan deklarasi untuk daftarTelepon, yang ditampilkan pada baris 15 dan baris 16 pada
Program 7.7. Perhatikan bahwa daftarTelepon
dideklarasikan sebagai sebuah bidang pada kelas Form1. Bidang itu tersedia untuk semua metode di dalam kelas.
Gambar 7.17 Aplikasi Inventori Telepon Sel saat dijalankan
Langkah 3: Ketikkan komentar dan kode untuk metode GetDataTelepon, seperti ditunjukkan
pada baris 23-47 pada Program 7.7. Perhatikan bahwa metode ini menerima sebuah
objek TeleponSel sebagai argumen.
Tujuan dari metode GetDataTelepon
adalah untuk membaca data yang dimasukkan user ke dalam kotak-kotak teks dan
menyimpan data itu ke dalam properti-properti dari objek argumen.
Langkah 4: Tukar view ke form Form1
pada mode Designer dan klik ganda
pada kontrol tombolTambahkan. Ini
akan membuka editor kode, dan Anda akan melihat sebuah event handler kosong
dengan nama tombolTambahkan_Click.
Sempurnakan event handler dengan mengetikkan kode yang ditunjukkan pada baris
51-70 pada Program 7.7. Amati kode tersebut:
Baris 52: Statemen ini menciptakan sebuah objek TeleponSel di dalam memori, yang
direferensi oleh sebuah variabel dengan nama teleponKu.
Baris 55: Statemen ini memanggil metode GetDataTelepon, yang melewatkan objek teleponKu sebagai argumen. Setelah metode ini dieksekusi, properti-properti
dari objek teleponKu akan ditetapkan
menjadi data yang dimasukkan oleh user.
Baris 58: Statemen ini menambahkan objek teleponKu pada daftarTelepon.
Baris 61-62: Statemen-statemen ini menambahkan sebuah entri pada
kontrol kotakListTelepon yang menampilkan
properti Merek dan Model dari objek teleponKu.
Baris 65-67: Statemen-statemen ini menghapus isi dari
kontrol-kontrol TextBox.
Baris 70: Statemen ini menetapkan fokus ke kontrol teksMerek.
Perhatikan
bahwa setiap objek TeleponSel yang
ditambahkan pada daftarTelepon
memiliki item terkait pada kontrol ListBox.
Sebuah objek di dalam daftarTelepon
dan item terkait di dalam ListBox
memiliki indeks yang sama. Sebagai contoh,
·
Objek TeleponSel pada indeks
0 di dalam daftarTelepon berkaitan
dengan item pada indeks 0 di dalam ListBox.
·
Objek TeleponSel pada indeks
1 di dalam daftarTelepon berkaitan
dengan item pada indeks 1 di dalam ListBox.
Ingat dari
Bab 8 bahwa ketika item-item di dalam dua struktur data berelasi dengan indeks,
dapat dikatakan bahwa relasi paralele ada di antara dua struktur data tersebut.
Langkah 5: Selanjutnya, Anda menciptakan event handler SelectedIndexChange untuk kontrol kotakListTelepon. Kembali ke mode Designer dan klik ganda pada kontrol kotakListTelepon. Ini akan membuka
editor kode, dan Anda akan melihat sebuah event handler kosong dengan nama kotakListTelepon_SelectedIndexChange.
Sempurnakan event handler ini dengan mengetikkan kode yang ditunjukkan pada
baris 75-79 pada Program 7.7.
Telah
disebutkan pada Langkah 4 bahwa item-item di dalam kotak list dan objek-objek
di dalam daftarTelepon berelasi
dengan indeks. Ketika user menyeleksi sebuah item dari kotak list, apa yang
perlu Anda lakukan adalah mendapatkan indeks item dan kemudian menggunakan
indeks itu untuk membaca objek terkait dari daftarTelepon. Inilah yang terjadi di dalam event handler ini.
Baris 76 membaca indeks dari item terseleksi di dalam kontrol kotakListTelepon dan menugaskannya
kepada variabel indeks. Baris 79
menggunakan variabel indeks untuk
mendapatkan sebuah objek dari daftarTelepon
dan menampilkan properti Harga-nya
pada sebuah kotak pesan.
Langkah 6: Ganti view 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 mengetikkan kode yang ditunjukkan pada
baris 84 dan baris 85 pada Program 7.7.
Langkah 7: Simpan projek dan jalankan aplikasi.
Program 7.7 Kode utuh untuk file Form1.cs pada projek Inventori
Telepon Sel
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
|
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 Inventori_Telepon_Sel
{
public
partial class Form1 : Form
{
//List
untuk memuat objek-objek TeleponSel
List<TeleponSel> daftarTelepon = new List<TeleponSel>();
public
Form1()
{
InitializeComponent();
}
//Metode
GetDataTelepon menerima sebuah objek TeleponSel
//sebagai
argumen. Ia menugaskan data yang dimasukkan oleh
//user
kepada properti-properti dari objek
private
void GetDataTelepon(TeleponSel telepon)
{
//Variabel temporer untuk memuat harga
decimal harga;
//Membaca merek telepon
telepon.Merek = teksMerek.Text;
//Membaca model telepon
telepon.Model = teksModel.Text;
//Membaca harga telepon
if
(decimal.TryParse(teksHarga.Text, out harga))
{
telepon.Harga = harga;
}
else
{
//Menampilkan pesan error
MessageBox.Show("Harga tidak valid");
}
}
private
void tombolTambahkan_Click(object sender, EventArgs e)
{
//Menciptakan sebuah objek TeleponSel
TeleponSel teleponKu = new TeleponSel();
//Membaca data telepon
GetDataTelepon(teleponKu);
//Menambahkan objek TeleponSel pada List
daftarTelepon.Add(teleponKu);
//Menambahkan sebuah entri ke kotak list
kotakListTelepon.Items.Add(teleponKu.Merek + " " +
teleponKu.Model);
//Membersihkan kontrol-kontrol TextBox
teksMerek.Clear();
teksModel.Clear();
teksHarga.Clear();
//Mengembalikan fokus
teksMerek.Focus();
}
private
void kotakListTelepon_SelectedIndexChanged(…)
{
//Membaca indeks dari item terseleksi
int
indeks = kotakListTelepon.SelectedIndex;
//Menampilkan harga item terseleksi
MessageBox.Show(daftarTelepon[indeks].Harga.ToString());
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
7.5 Menciptakan Beberapa Form Pada Sebuah
Projek
KONSEP:
Projek Visual C# dapat memiliki beberapa form. Setiap form memiliki kelas
sendiri yang dapat diinstansiasi dan ditampilkan di layar.
Aplikasi-aplikasi yang telah Anda ciptakan
sejauh ini hanya menggunakan satu form, dengan nama Form1. Form Form1
ditampilkan ketika aplikasi dijalankan, dan ketika form Form1 ditutup, aplikasi akan berhenti. Anda tidak dibatasi untuk
hanya memiliki satu form di dalam sebuah projek. Anda dapat menciptakan
beberapa form di dalam suatu projek. Kemudian Anda bisa menampilkan form-form
ini ketika diperlukan.
Setiap form di dalam suatu projek Visual C#
memiliki sebuah kelas. Sebagai contoh, jika suatu projek memiliki sebuah form
dengan nama Form1, maka projek itu
memiliki sebuah kelas dengan nama Form1,
yang disimpan di dalam suatu file dengan nama Form1.cs. Ketika Anda menambahkan form-form lain ke dalam projek,
Anda menambahkan kelas-kelas lain, yang disimpan di dalam file sendiri-sendiri.
Ketika Anda menciptakan event handler untuk kontrol pada form tertentu, Anda
menuliskannya seperti metode biasa pada kelas form tersebut.
Mengganti Nama Form Form1
Ketika Anda menambahkan form pada suatu
projek Visual C#, form itu akan diberikan nama default seperti Form1, Form2, dan seterusnya. Jika Anda hanya memiliki satu form pada
sebuah projek, maka tidak ada alasan untuk mengganti nama form. Namun, ketika
Anda memiliki beberapa form pada sebuah projek, Anda perlu memberikan setiap
form nama yang menjelaskan tujuannya masing-masing.
Sebelum Anda menambahkan sebuah form baru
pada suatu projek, adalah hal baik untuk mengubah nama dari form Form1. Pada buku ini, Anda selalu
mengganti nama dari Form1 menjadi FormUtama karena ia merupakan form
utama pada suatu aplikasi. Untuk mengubah nama form, Anda menggunakan jendela Solution Explorer untuk mengganti nama dari Form1.cs menjadi FormUtama.cs.
Ketika Anda melakukannya, Visual Studio secara otomatis akan mengubah nama dari
form Form1 menjadi FormUtama. Berikut adalah prosedur yang
perlu diikuti:
1. Klik kanan pada entri
Form1.cs yang ada pada jendela Solution Explorer. Menu yang ditunjukkan pada Gambar 7.18 akan ditampilkan.
Gambar 7.18 Pengklikan-kanan pada file form pada jendela
Solution Explorer
2. Pilih Rename dari
menu yang ditampilkan.
3. Pada jendela Solution Explorer, nama file dari form akan disorot. Ketikkan nama baru,
yaitu FormUtama.cs dan tekan Enter.
(Pastikan untuk mempertahankan ekstensi .cs).
4. Kotak dialog yang
ditunjukkan pada Gambar 7.19 akan ditampilkan. Klik Yes untuk mengganti nama
form.
Gambar 7.20 menunjukkan sebuah contoh dari Solution Explorer
setelah file Form1.cs diganti
namanya menjadi FormUtama.cs.
Menambahkan
Form Baru Pada Projek
Ikuti langkah-langkah berikut untuk menambahkan
sebuah form baru pada suatu projek:
1. Klik PROJECT pada batang menu Visual Studio,
dan kemudian pilih Add Windows Form…
dari menu PROJECT. Jendela Add New Item, yang ditunjukkan pada
Gambar 7.21, akan ditampilkan.
2.
Di bagian bawah dari jendela Add
New Item, sebuah kotak teks Name
ditampilkan, dimana Anda dapat menetapkan nama file dari form baru. Awalnya,
nama default akan ditampilkan di sini. (Perhatikan bahwa pada Gambar 7.21 nama
default Form1.cs diberikan. Nama
aktual yang ditampilkan pada layar bisa saja berbeda). Ubah nama default yang
ada pada kotak teks Name menjadi nama yang lebih deskriptif. Sebagai contoh,
jika Anda ingin menamai form baru dengan FormError,
masukkan FormError.cs pada kotak
teks Name. Pastikan untuk
mempertahankan ekstensi .cs pada nama file yang Anda masukkan).
3.
Klik tombol Add.
Setelah menyelesaikan langkah-langkah ini,
sebuah form kosong baru akan ditambahkan pada projek Anda. Form baru itu
ditampilkan pada mode Designer, dan sebuah entri untuk file form baru
ditampilkan pada jendela Solution Explorer. Gambar 7.22 menunjukkan suatu
contoh dari jendela Solution Explorer dengan dua file form: FormError.cs dan FormUtama.cs. Setelah Anda menambahkan sebuah form pada suatu
projek, Anda dapat menambahkan kontrol-kontrol pada form itu dan menuliskan
event handler untuk setiap kontrol tersebut.
Gambar 7.22 Jendela Solution
Explorer yang menunjukkan dua form
Menukar View Antara Form dan Kode Form
Pada Visual Studio, Anda dapat dengan mudah
menukar view Anda ke form lain dengan mengklik ganda entri form pada jendela Solution Explorer. Form kemudian ditampilkan pada mode Designer. Anda dapat pula menggunakan tab-tab yang ada di atas
Designer untuk menampilkan sejumlah form atau kode form yang berbeda. Sebagai
contoh, lihat pada Gambar 7.23, yang menunjukkan tab-tab pada suatu projek
dengan dua form. FormError dan FormUtama.
Gambar 7.23 Tab-Tab pada Projek
Ketika Anda membuka sebuah form pada editor
kode, Anda akan melihat sejumlah direktif using, sebuah deklarasi namespace,
dan kelas form. Gambar 7.24 menunjukkan salah satu contoh. File di dalam gambar
memuat kode untuk sebuah form dengan nama FormError.
Perhatikan bahwa kelas form diberi nama FormError.
Gambar 7.24 Sebuah file kode sumber yang memuat suatu
kelas form
Menghapus Form
Jika Anda ingin menghapus sebuah form dari
suatu projek dan menghapus filenya dari disk, ikuti langkah-langkah berikut:
1. Klik kanan pada entri
form pada jendela Solution Explorer.
2. Pada menu yang
ditampilkan, klik Delete.
Jika Anda
ingin menghapus sebuah form dari suatu projek tetapi Anda tidak ingin menghapus
filenya dari disk, ikuti langkah-langkah berikut:
1. Klik kanan pada entri
form pada jendela Solution Explorer.
2. Pada menu yang
ditampilkan, klik Exclude From Project.
Menampilkan Form
Pada kode aplikasi Anda, langkah pertama
dalam menampilkan sebuah form adalah dengan menciptakan suatu objek dari kelas
form. Sebagai contoh, dimisalkan bahwa suatu projek memiliki sebuah form dengan
nama FormError. Statemen berikut
menciptakan sebuah objek dari kelas FormError:
FormError formErrorKu = new FormError();
Statemen ini mendeklarasikan sebuah variabel
referensi dengan nama formErrorKu.
Ia juga menciptakan sebuah objek dari kelas FormError di dalam memori dan menugaskan sebuah referensi yang menunjuk
ke objek itu kepada variabel formErrorKu.
Setelah statemen ini dieksekusi, Anda akan dapat menggunakan variabel formErrorKu untuk melakukan
operasi-operasi pada form.
Penciptaan suatu objek dari kelas form tidak
menampilkan form pada layar. Langkah selanjutnya adalah memanggil metode ShowDialog dari form. Berikut adalah
salah satu contohnya:
formErrorKu.ShowDialog();
Metode ShowDialog
menampilkan sebuah form di layar, dan ia memberikan fokus pada form itu. Ini
berarti bahwa kendali aplikasi dialihkan ke form itu. Ketika user menutup form,
kendali aplikasi kembali ke titik di mana metode ShowDialog dipanggil, dan eksekusi dimulai kembali.
Setelah Anda mempelajari konsep-konsep
penciptaan dan penampilan suatu form, Anda akan mempelajari langkah-langkah
pada Tutorial 7.5. Pada tutorial itu, Anda akan menciptakan sebuah aplikasi
sederhana yang memiliki dua form.
Tutorial 7.5: Menciptakan Sebuah Aplikasi Dengan Dua Form
Langkah 1: Awali Visual Studio (atau Visual Studio Express).
Ciptakan sebuah projek Windows Forms Application baru dengan nama Latihan
Multiform.
Langkah 2: Pada jendela Solution
Explorer, ganti nama file Form1.cs menjadi FormUtama.cs. (Klik kanan pada file Form1.cs dan kemudian pilih Rename
dari menu yang ditampilkan). Pengubahan nama file form menjadi FormUtama.cs akan mengubah nama form
menjadi FormUtama. Jendela Solution Explorer akan ditampilkan seperti pada Gambar 7.25.
Langkah 3: Pada mode Designer,
bangun form FormUtama seperti
ditunjukkan pada Gambar 7.26.
Langkah 4: Lakukan hal berikut untuk menciptakan form lain dengan
nama FormPesan pada projek:
·
Klik PROJECT pada batang menu
Visual Studio dan kemudian pilih Add Windows
Form….
·
Jendela Add New Item akan ditampilkan. Masukkan FormPesan.cs sebagai namanya.
·
Klik tombol Add.
Seperti
ditunjukkan pada Gambar 7.27, sebuah form baru dengan nama FormPesan akan ditampilkan pada mode Designer. Perhatikan bahwa sebuah entri untuk FormPesan.cs ditampilkan pada jendela Solution Explorer.
Gambar 7.25 Jendela Solution
Explorer setelah pengubahan Form1.cs menjadi FormUtama.cs
Gambar 7.26 Form FormUtama
Gambar 7.27 FormPesan ditambahkan pada projek
Langkah 5: Pada mode Designer,
bangun FormPesan seperti ditunjukkan
pada Gambar 7.28.
Langkah 6: Selanjutnya, Anda menciptakan event handler Click untuk kontrol tombolTutup. Pada Designer, klik ganda pada kontrol tombolTutup. Ini akan menampilkan file FormPesan.cs pada editor kode, dan Anda akan melihat sebuah event
handler kosong dengan nama tombolTutup_Click.
Sempurnakan event handler ini dengan menuliskan kode yang ditunjukkan pada
baris 22-23 pada Program 7.8. Ketika user mengklik kontrol tombolTutup, event handler ini akan menutup form.
Langkah 7: Gunakan tab-tab untuk menukar FormUtama,cs [Designer]. Ini akan membawa Anda ke FormUtama pada mode Designer.
Gambar 7.28 Form FormPesan
Program 7.8 Kode utuh untuk form FormPesan
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
|
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 Latihan_Multiform
{
public
partial class FormPesan : Form
{
public
FormPesan()
{
InitializeComponent();
}
private
void tombolTutup_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
Langkah 8: Sekarang Anda menciptakan event handle Click untuk kontrol tombolTampilkan. Klik ganda pada
kontrol tombolTampilkan. Ini akan
menampilkan file FormUtama.cs pada
editor kode, dan Anda akan melihat sebuah event handler kosong dengan nama tombolTampilkan_Click. Sempurnakan
event handler dengan mengetikkan kode yang ditunjukkan pada baris 22-26 pada
Program 7.9. Amati kode ini:
Baris 23: Statemen ini melakukan hal berikut:
·
Ia mendeklarasikan sebuah variabel referensi FormPesan dengan nama formPesanKu.
·
Ia menciptakan sebuah objek FormPesan
di dalam memori.
· Ia menugaskan sebuah referensi yang menunjuk ke objek FormPesan kepada variabel formPesanKu.
Setelah
statemen ini dieksekusi, variabel formPesanKu
akan mereferensi sebuah objek FormPesan.
Baris 26: Statemen ini menampilkan FormPesan di layar dan mengalihkan aplikasi pada form.
Langkah 9: Tukar view ke form FormUtama
pada mode Designer dan klik ganda
pada kontrol tombolKeluar. Pada
editor kode, Anda akan melihat sebuah event handler kosong dengan nama tombolKeluar_Click. Selesaikan event
handler ini dengan mengetikkan kode yang ditunjukkan pada baris 31-32 pada
Program 7.9.
Langkah 10: Simpan projek dan jalankan aplikasi. Ketika aplikasi
dijalankan, FormUtama akan
ditampilkan, seperti ditunjukkan pada Gambar 7.29. Klik tombol Tampilkan Form. Form FormPesan
akan ditampilkan, seperti ditunjukkan di sisi kanan pada Gambar 7.29.
Langkah 11: Pada FormPesan,
klik tombol Tutup. Ini akan menutup FormPesan. Selanjutnya, klik pada
tombol Keluar pada FormUtama untuk mengakhiri aplikasi.
Gambar 7.29 Form FormUtama
dan FormPesan ditampilkan
Program 7.9 Kode utuh untuk form FormUtama
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
|
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 Latihan_Multiform
{
public
partial class FormUtama : Form
{
public
FormUtama()
{
InitializeComponent();
}
private
void tombolTampilkan_Click(object sender, EventArgs e)
{
//Menciptakan sebuah objek dari kelas FormPesan
FormPesan formPesanKu = new FormPesan();
//Menampilkan form
formPesanKu.ShowDialog();
}
private
void tombolKeluar_Click(object sender, EventArgs e)
{
//Menutup form
this.Close();
}
}
}
|
No comments:
Post a Comment