Belajar Bahasa C sharp/Bab II: Perbedaan antara revisi
Konten dihapus Konten ditambahkan
k tambahan |
|||
Baris 603:
</source>
Dan, akhirnya kode di atas merupakan kode dalam bahasa C# yang lengkap. Bagaimana cara membaca kode di atas? Kode tersebut hanya mengandung satu buah kelas, yang diberi nama Program. Kelas <code>Program</code> tersebut memiliki satu buah metode yang disebut dengan <code>Main</code>. Metode <code>Main </code>mendeklarasikan empat buah variabel dengan jenis data bilangan bulat. Program tersebut terdiri atas empat buah statemen penugasan.
==''Edit, Compile, Run''==
Sebuah program komputer memulai hidupnya sebagai berkas teks yang ditulis oleh kita, para (calon) ''programmer''. Berkas teks tersebut umumnya disebut dengan '''kode sumber''' ('''''source code'''''). Kode sumber program dalam bahasa pemrograman C# menurut konvensi, merupakan sebuah berkas teks dengan ekstensi <code>*.CS</code> (singkatan dari ''C Sharp''). Sebuah program juga bisa terdiri atas satu berkas kode sumber atau bahkan lebih dari satu (dan ini merupakan hal yang paling sering dilakukan).
Setelah kita membuat berkas kode sumber, baik itu satu berkas atau beberapa berkas, kita harus melakukan kompilasi terhadapnya dengan menjalankan program yang disebut dengan '''kompiler''' atau '''kompilator''' ('''''complier'''''). Kompiler bahasa C# adalah sebuah program yang terkandung di dalam [[w:Microsoft .NET Framework|Microsoft .NET Framework]] yang dapat membaca kode sumber yang kita buat dan akan mengubah kode sumber kita ke dalam bahasa yang dimengerti oleh komputer, yang di dalam .NET Framework disebut dengan [[w:Common Intermediate Language|Microsoft Intermediate Language]] (MSIL), yang pada umumnya dalam bentuk berkas biner dengan ekstensi <code>*.EXE</code> (singkatan dari ''Executable'').
Kompiler C# akan mencoba membaca kode sumber yang kita buat, dan jika memang ia menemukan sebuah masalah dengan kode sumber yang kita buat, maka ia akan memberitahukan kepada kita mengenai masalah tersebut dan mungkin bagaimana cara mengatasi masalah tersebut. Masalah-masalah pengetikan yang salah atau kesalahan lainnya yang terjadi saat kompilasi, umumnya disebut dengan '''kesalahan sintaksis''' ('''''syntax error''''') atau '''kesalahan waktu kompilasi''' ('''''compile-time error'''''). Jika kompiler melaporkan adanya kesalahan, kita harus menyunting ulang kode sumber kita untuk mengoreksi kesalahan tersebut. Kadang-kadang, ''compile-time error'' juga dipanggil dengan sebutan '''''compiler error''''', seolah-olah kompiler merupakan pihak yang salah, bukannya kita sebagai ''programmer'' yang salah. Meskipun memang, kompiler juga sering melakukan kesalahan dalam melakukan kompilasi, hal yang paling sering terjadi adalah kompiler menemukan kesalahan yang kita buat dalam kode kita.
Setelah pada akhirnya kita dapat "membujuk" kompiler agar membuatkan berkas <code>*.EXE</code> dari kode sumber program kita, kita dapat menjalankan program tersebut. Pada saat dijalankan, program tersebut berada di dalam kendali [[w:sistem operasi|sistem operasi]], dan karena bahasa C# merupakan salah satu anggota dari bahasa .NET Framework, program yang dibangun dengan menggunakan C# dijalankan dengan menggunakan '''''[[w:Common Language Runtime|Common Language Runtime]]''''' (CLR) yang tergabung ke dalam .NET Framework.
Sistem operasi atau CLR akan mencoba menjalankan program yang kita buat, akan tetapi mungkin saja program yang kita buat tidak mampu melakukan apa yang kita harapkan dengan sempurna. Kadang-kadang, kode yang kita buat itu mencoba untuk melakukan hal-hal yang tidak diperbolehkan (seperti mengakses area memori yang tidak dimiliki olehnya). Akhirnya, program tersebut pun mengalami kesalahan saat berjalan, dan CLR atau sistem operasi akan memberikan laporan kesalahan dengan menggunakan sebuah kotak dialog. '''Masalah-masalah yang terjadi saat program dijalankan, disebut dengan ''runtime error'' atau ''exception'''''. Karena berkas EXE merupakan berkas biner yang sulit untuk dilihat dengan menggunakan editor teks biasa, maka untuk mengoreksinya kita harus membuka kembali berkas kode sumber yang membentuk berkas <code>EXE</code> yang bersangkutan.
Keseluruhan proses di atas, dikenal juga dengan sebutan '''<code>Edit-Compile-Run</code>''', dan merupakan bagian yang sering dilakukan dalam rangka membuat dan mengembangkan program. Semua program, kecuali program-program yang kecil, melalui beberapa kali proses '''Edit-Compile-Run''' sebelum akhirnya selesai dan dapat dipublikasikan. Ketika menulis program yang besar, saya seringnya melakukan proses tersebut secepat mungkin, untuk mengetahui apakah program yang masih belum besar tersebut benar-benar berjalan dengan sempurna atau tidak.
Nah, ketika kita akhirnya melihat bahwa program yang kita buat terkesan baik-baik saja tanpa ada yang "mencurigakan", ada satu tugas lagi yang menunggu kita, yaitu '''pengujian'''. Mungkin, kita akan menemukan bahwa program yang kita buat masih tidak berjalan dengan benar. Masalah di dalam program yang sudah jadi ini, disebut dengan istilah "'''''bug'''''." Menemukan ''bug'' sama seperti mencari kecoa di kamar kita, kadang-kadang gampang, kadang-kadang sulit, tetapi kesulitan merupakan hal yang sering dialami oleh para ''programmer''. '''Sebuah ilmu khusus dibutuhkan untuk mencari, menemukan, dan mengoreksi ''bug'' dalam program, yang disebut dengan ''debugging'''''. Sayangnya, karena ''debugging'' merupakan topik tingkat lanjut, hal itu (mungkin) tidak akan diulas di kumpulan artikel ini.
===Alat bantu Edit-Compile-Run===
Seperti yang telah disebutkan di dalam beberapa bab pendahuluan, kita memiliki segudang cara untuk melakukan <code>Edit-Compile-Run</code> terhadap program C# yang kita buat. Mulai dari mengetiknya secara manual dengan menggunakan <code>Notepad</code> hingga menggunakan alat bantu khusus yang didesain untuk melakukannya. Cara paling enak yang dapat digunakan adalah menggunakan Microsoft Visual Studio (jika memang Anda punya uang untuk membeli lisensinya) atau Microsoft Visual C# Express Edition (yang gratis). Jika memang Anda tidak punya uang untuk membeli lisensinya, mungkin Anda bisa mencoba program Sharp Develop (#develop) yang dikembangkan oleh komunitas ''open-source'' dan juga [[w:Eclipse|Eclipse]] dengan ''plug-in'' yang didesain khusus untuk melakukan Edit-Compile-Run terhadap program C# kita. Meskipun mahal, saya menyarankan Microsoft Visual C# dan Microsoft Visual Studio, karena memang menawarkan beberapa hal yang tidak dimiliki oleh beberapa program lainnya.
Di dalam Visual C# dan Visual Studio, program yang kita buat dinamakan dengan '''''Project'''''. Sebuah ''Project'' dapat mengandung satu berkas teks berisi kode sumber atau lebih. Sebuah ''Project'' harus diberi nama yang, tidak seperti nama ''identifier'', bersifat ''case-insensitive''. Nama Project yang kita tentukan ini nantinya akan digunakan sebagai nama berkas <code>EXE</code> yang akan dibentuk oleh kompiler. Sebagai contoh, ketika kita menggunakan nama <code>Program</code> sebagai nama ''Project'' yang kita buat, maka hasilnya adalah <code>PROGRAM.EXE</code>.
Penggunaan alat bantu pemrograman C# memang adalah hak Anda untuk memilih, mana menurut Anda lebih baik, mengingat setiap produk memiliki kelebihan dan kekurangannya masing-masing. Akan tetapi setiap alat bantu tersebut menawarkan editor kode sumber yang mampu memberikan warna masing-masing terhadap kode sumber yang kita tuliskan, sehingga nanti terlihat jelas sintaksis-sintaksisnya dan lebih mudah dalam membaca kodenya.
Coba Anda ketikkan kode di bawah ini di dalam alat bantu pemrograman yang Anda gunakan, dan simpan di dalam nama “Program01.cs”:
<source lang="csharp">
class Programku
{
static void Main()
{
int JumlahHariIzin, JumlahHariAlfa, JumlahHariSakit;
int TotalAbsensi;
JumlahHariIzin = 10;
JumlahHariGhaib = 2;
JumlahHariSakit = 10;
TotalAbsensi = JumlahHariIzin + JumlahHariSakit + JumlahHariAlfa;
}
}
</source>
Anda harus menekan tombol <code>Enter</code> untuk mengganti setiap baris di atas. Jika Anda menggunakan editor teks biasa seperti Notepad, Anda mungkin tidak akan mengenali kata-kata kunci di dalam C# yang digunakan di dalam kode sumber program di atas. Akan tetapi, ketika Anda menggunakan alat-alat bantu yang telah saya sebutkan di atas, Anda akan menyadari bahwa alat tersebut dilengkapi dengan fitur pemberian warna terhadap kata-kata kunci C# (dan semua bahasa yang didukung oleh editor tersebut), yang dinamakan dengan '''''syntax highlighting'''''. Jika kita cermati, editor tersebut akan menggunakan warna-warna berbeda untuk setiap komponen di dalam program di atas. Sebagai contoh, di dalam editor Microsoft Visual C#, editor akan menampilkan semua kata kunci dengan warna biru, dan baris pertama dan kedua yang diawali dengan dua karakter garis miring atau ''double-slash''(<code>//</code>) diberi warna hijau.
Ketika Anda telah mengetik kode di atas, proses selanjutnya adalah melakukan kompilasi terhadap kode sumber agar dibuat menjadi program yang dapat dieksekusi oleh komputer. Jika Anda menginginkan kesederhanaan tanpa alat bantu pemrograman seperti yang disebutkan di atas, Anda harus melakukan kompilasi secara manual dengan menggunakan program kompiler C#, yang diletakkan di dalam direktori <code>C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705</code> (untuk .NET Framework 1.0), <code>C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322</code> (untuk .NET Framework 1.1), atau <code>C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727</code> (untuk .NET Framework 2.0), menggunakan baris perintah yang "merepotkan". Anda harus membuka Microsoft Command Prompt (<code>C:\Windows\System32\cmd.exe</code>) dan memasukkan perintah seperti di bawah ini:
C:\>csc Program01.cs
yang kemudian akan menampilkan pesan dari pembuat kompiler:
[[Berkas:BelajarCSharp-Gambar0101.png|CSC.EXE (C Sharp Compiler)]]
yang kemudian akan mengubah kode sumber di atas menjadi program siap guna. Akan tetapi, jika Anda menggunakan alat-alat bantu pemrograman seperti disebutkan di atas, Anda dapat melakukannya secara lebih mudah. Penggunaan alat bantu pemrograman hanya membutuhkan satu langkah saja yang harus dilakukan, yakni menekan menu '''Build Solution''' atau '''Build Program'''. Semua hal yang berkaitan dengan ''Edit-Compile-Run'' dilakukan secara langsung oleh alat bantu tersebut, dengan sedikit intervensi dari kita. Jika memang terjadi kesalahan pada saat kompilasi, maka kesalahan-kesalahan tersebut akan ditampilkan dalam jendela Error List di bawah editor teks. Anda bisa menuju ke lokasi di mana kesalahan tersebut berada dengan mengklik ganda pada sebuah entri di dalam jendela Error List tersebut.
Saat Anda menjalankan program yang Anda buat, maka sebuah jendela ''console'' akan keluar. Judul yang digunakan oleh jendela console tersebut adalah nama berkas yang digunakan oleh proyek Anda. Setelah itu, ada sebuah baris yang berbunyi:
Press any key to continue
yang berarti bahwa program tersebut telah selesai berjalan. Mengapa kok belum keluar output apa-apa, program saya langsung selesai dieksekusi? Itu memang karena di dalam kode program tersebut tidak diberi sebuah perintah untuk menampilkan bagaimana hasil dari program tersebut—kita hanya menyuruh komputer agar menjalankan instruksi penjumlahan saja, tidak lebih dan tidak kurang. Kembali ke layar program yang Anda buat tadi, saat Anda menekan tombol apapun dari ''keyboard'', jendela tersebut akan "dihancurkan."
Metode apapun yang kita gunakan untuk melakukan kompilasi program yang kita buat, mungkin kita akan menghabiskan waktu dalam rangka melakukan eksperimen terhadap kode kita dan mencoba-coba banyak hal—dengan kata lain menggunakan metode circle-back. Eksperimen merupakan aktivitas yang sangat penting—mungkin bisa dibilang paling penting—dalam melakukan pemrograman, dan juga ketika belajar bahasa pemrograman. Yang "menyenangkan" dalam eksperimen di bidang komputer adalah eksperimen bisa dilakukan oleh siapa saja dengan mudah dan aman, tidak seperti eksperimen kimia, fisika, atau biologi. Kita tidak bakal membakar rumah kita saat melakukan eksperimen dengan komputer. Sebagai contoh eksperimen kita yang pertama, coba kita hapus salah satu statemen penugasan dari program kita yang pertama. Lihat apa yang terjadi jika satu variabel, seperti halnya <code>JumlahHariIzin</code> atau <code>JumlahHariAlfa</code> dihapuskan oleh kita dan menjadikannya tidak memiliki nilai sama sekali. Dengan melakukan eksperimen seperti ini, kita mungkin akan terbiasa dengan pesan kesalahan yang datang dari kompiler dan akhirnya mengetahui apa sih penyebabnya. Kita juga bisa membuang statemen penugasan yang menghitung nilai <code>TotalAbsensi</code>. Hal itu memang tidak membuat kesalahan, akan tetapi coba perhatikan apa yang dikatakan oleh kompiler C#?
Coba ganti kata <code>class</code> dengan kata <code>struct</code> (yang merupakan singkatan dari kata '''structure''') di dalam kode sumber program. Program yang kita buat mungkin terlihat akan bekerja dengan normal, dan tidak ada perbedaan dengan ketika kita menggunakan kata kunci <code>class</code>. Padahal, di antara <code>class</code> dan <code>struct</code>, terdapat perbedaan yang sangat besar, dan memahami perbedaan tersebut, merupakan salah satu aspek terpenting dalam belajar bahasa pemrograman berorientasi objek seperti halnya bahasa C#.
==Input dan Output==
Pada saat-saat awal pengembangan program kita, kita hanyalah pengguna program tersebut, dan peranan kita pun berganti-ganti antara pengguna, penguji dan ''programmer''. Program yang kita buat haruslah memiliki beberapa cara untuk menampilkan ''output'' bagi pengguna, dan juga mampu menerima ''input'' dari mereka. Kedua hal tersebut dinamakan juga dengan '''I/O''' atau '''Input dan Output'''.
Metode untuk melakukannya, yang sering disebut dengan '''model I/O''', berbeda-beda antar program, tergantung cara kerja program tersebut. Program yang berjalan di atas sistem operasi Windows akan menerima ''input'' dari pengguna dengan menggunakan ''keyboard'', ''mouse'', dan beberapa kontrol lainnya (seperti halnya tombol dalam layar dan baris gulung/''scroll bar''). Program-program Windows menampilkan output kepada pengguna dalam bentuk teks dan grafik-grafik berwarna. Akan tetapi, program yang dimiliki di dalam perangkat lainnya, seperti di dalam oven ''microwave'' atau kulkas yang ada komputer digital di dalamnya, pasti memiliki model I/O yang sangat berbeda dengan model I/O yang digunakan oleh program Windows. Alat input yang digunakan mungkin hanya beberapa buah tombol saja yang diletakkan di panel depan, sementara alat outputnya adalah perangkat yang mampu mematikan atau menyalakan ''oven microwave'', menyalakan lampu dan mematikannya, dan masih banyak lagi yang lainnya.
Seperti halnya bahasa C, bahasa C# tidak mengandung sesuatu yang spesifik yang mendukung I/O dengan pengguna. Mungkin, hal ini terdengar seperti sebuah kekurangan, akan tetapi sebenarnya bukan merupakan sebuah kekurangan. Mungkin, lebih tepatnya, C# dapat dikatakan tidak memiliki model I/O tertentu yang harus digunakan oleh programmer. Dan tugas Andalah (sebagai calon programmer) untuk memilih I/O yang hendak digunakan oleh program buatan Anda!
Meskipun demikian, untuk membangun program, baik itu program Windows, program Web, ataupun aplikasi ''console'', kita dapat menggunakan kelas yang didefinisikan di dalam .NET Framework. Untuk menjelajahi kelas-kelas tersebut, mau tidak mau, kita harus mau membaca dokumentasi .NET Framework, yang bisa didapatkan secara ''online'' (melalui [http://msdn.microsoft.com/library MSDN Library]) ataupun secara ''offline'' (dengan menginstalasikan MSDN Library ke dalam komputer kita). Dengan membuka entri <code>Class Library</code>, kita dapat memperoleh informasi mengenai kelas-kelas yang disediakan oleh Microsoft .NET Framework.
Sekarang, yang harus Anda lakukan adalah "jangan merinding" melihat daftar yang sangat panjang yang muncul di dalam MSDN library. Sebagian besar hal yang terdapat di sana mungkin tidak akan kita gunakan di dalam program kita. Apa yang kita lihat di sini merupakan daftar '''ruang nama''' (dalam C# disebut juga dengan nama <code>namespace</code>), yang bertugas untuk membagi kelas-kelas .NET ke dalam beberapa kelompok fungsional tertentu. Ruang nama yang memiliki sebagian besar kelas dasar adalah ruang nama yang disebut sebagai System. Di dalam ruang nama tersebut, kita akan menemukan kelas <code>Console</code>, dan di dalam kelas <code>Console</code> terdapat metode-metode yang dapat digunakan oleh program yang kita buat untuk membaca input dari pengguna dengan menggunakan ''console'' dan menampilkan output kepada pengguna. Nah, itulah yang akan kita gunakan di dalam program di atas.
OKE. Kita mulai dengan output! Untuk menampilkan output ke dalam ''console'', kita dapat menggunakan dua metode yang memiliki nama <code>System.Console.Write</code> (yang dapat dibaca "<code>System dot Console dot Write</code>") dan juga <code>System.Console.WriteLine</code>.
Sebagai contoh, untuk menampilkan nilai dari variabel <code>TotalAbsensi</code> kepada pengguna, kita dapat menambahkan baris berikut ke dalam program yang kita bangun dari awal tadi, tepat setelah ada pernyataan penugasan bagi variabel TotalAbsensi:
<source lang="csharp">
. . .
System.Console.WriteLine(TotalAbsensi);
. . .
</source>
Simpan, lakukan kompilasi ulang terhadap program tersebut, dan jalankan. Sekarang, Anda akan melihat angka keluar ke layar:
22
Press any key to continue.
Jika Anda melihat hasil program seperti di atas, maka program pertama yang Anda buat telah berjalan.
Kita juga bisa mencoba menulis sebagai berikut:
<source lang="csharp">
. . .
System.Console.Write(TotalAbsensi);
. . .
</source>
Dalam kasus ini, Anda akan mendapatkan:
22Press any key to continue.
Perbedaan di antara <code>System.Console.Write</code> dan <code>System.Console.WriteLine</code> adalah bahwa <code>WriteLine</code> akan mengganti baris setelah menampilkan hasil ''output''-nya, sementara <code>Write</code> tidak. Metode <code>Write</code> dapat digunakan untuk menampilkan beberapa hal di dalam baris yang sama.
Setiap metode di dalam .NET Framework memiliki tiga buah nama. "<code>WriteLine</code>" adalah nama sebenarnya dari sebuah metode. Tentu kita telah mengetahui, apa itu metode, karena memang kita telah mempelajarinya dari metode Main—meski belum tahu definisinya. Definisi yang umum mengenai sebuah metode adalah '''koleksi kode yang melakukan sesuatu pekerjaan tertentu'''. Dalam kasus <code>WriteLine</code>, pekerjaannya adalah untuk menampilkan output program ke dalam layar ''console''.
Nama kedua yakni "<code>Console</code>", adalah apa yang disebut dengan kelas (<code>class</code>). Kita juga tahu apa itu kelas, karena <code>Programku</code> adalah sebuah kelas. Seperti halnya <code>Main</code> yang merupakan sebuah method di dalam kelas Programku, metode <code>WriteLine</code> juga merupakan metode yang terdapat di dalam kelas <code>Console</code>.
Nama terakhir "<code>System</code>", adalah apa yang disebut sebagai ruang nama (''namespace''). Semua kelas di dalam .NET Framework disusun sedemikian rupa di dalam sebuah ''namespace'' yang membagi kelas-kelas tersebut ke dalam sebuah kelompok fungsional tertentu. Mungkin saja di sana ada sebuah ''namespace'' lainnya yang memiliki kelas dengan nama <code>Console</code>, dan hal tersebut sah-sah saja!
Dalam buku "'''The C# Language Specification'''", sebuah pernyataan seperti di bawah ini
<source lang="csharp">
System.Console.Write(TotalAbsensi);
</source>
disebut sebagai '''ekspresi permintaan''' ('''''invocation expression'''''), tetapi sebagian besar ''programmer'' menyebutnya sebagai '''pemanggilan metode''' ('''''method call'''''). Program yang kita buat di atas akan memanggil metode WriteLine, yang pada dasarnya akan menangani nilai dari variabel <code>TotalAbsensi</code>, yang harus diapit oleh tanda kurung buka dan kurung tutup setelah nama metode tersebut. Kita juga bisa mengatakan bahwa program kita memberikan variabel <code>TotalAbsensi</code> kepada metode <code>WriteLine</code> untuk diproses, atau kita juga bisa mengatakan bahwa variabel <code>TotalAbsensi</code> adalah argumen yang dimasukkan kepada metode <code>WriteLine</code>.
OKE! Ketika saya menjelaskan mengenai deklarasi metode <code>Main</code>, saya mengatakan bahwa metode <code>Main</code> tidak memiliki parameter input. Deklarasi <code>Main</code> di dalam program kita akan kita ketahui karena memang setelah nama metode, terdapat tanda kurung buka dan tanda kurung tutup.
<source lang="csharp">
static void Main()
{
}
</source>
Kata kunci <code>void</code> yang tertulis di atas menandakan bahwa <code>Main</code> tidak memiliki '''nilai kembalian''' ('''''return value''''').
Dalam kode sumber yang membangun .NET Framework, deklarasi WriteLine mungkin akan berbentuk seperti ini:
<source lang="csharp">
namespace System
{
public sealed class Console
{
public static void WriteLine(int value)
{
...
}
}
}
</source>
Saya mengatakan "mungkin", karena memang kode sumber .NET Framework merupakan hak cipta yang dimiliki oleh Microsoft Corporation, dan orang biasa seperti saya belum pernah melihatnya—dan kalaupun melihatnya saya belum tentu paham. Kode kecil imajiner di atas juga mencakup beberapa kata kunci yang mungkin Anda anggap baru, karena memang baru Anda temukan (seperti kata kunci <code>namespace</code>, <code>public</code>, dan <code>sealed</code>). Tenang saja. Kita akan mendiskusikannya lebih lanjut seiring dengan waktu. Ruang nama <code>System</code>, yang mengandung kelas <code>Console</code>, memiliki banyak sekali kelas-kelas lainnya selain <code>Console</code>; sementara kelas <code>Console</code>, yang mengandung metode <code>WriteLine</code>, memiliki banyak metode lainnya.
Ngomong apa sih, bertele-tele? Yang ingin saya tekankan di dalam paragraf di atas adalah bahwa metode <code>WriteLine</code> dideklarasikan dengan sebuah parameter di dalam kurungan, setelah nama metodenya.
<source lang="csharp">
public static void WriteLine(int value)
{
...
}
</source>
Saat sebuah program menggunakan metode <code>WriteLine</code>, maka program tersebut akan meneruskan argumennya ke dalam metode tersebut. Perhatikan contoh kode di bawah ini:
<source lang="csharp">
System.Console.WriteLine(TotalAbsensi);
</source>
Saat program memanggil metode <code>WriteLine</code>, parameter <code>value</code> dalam metode <code>WriteLine</code> akan mengambil nilai argumen yang dimasukkan, yakni <code>TotalAbsensi</code>. Metode <code>WriteLine</code> di dalam .NET Framework akan menampilkan variabel <code>value</code> tersebut (yang kini memiliki nilai yang sama dengan nilai variabel <code>TotalAbsensi</code>) ke dalam layar ''console''. Ketika <code>WriteLine</code> telah melakukan apa yang harus dikerjakannya, <code>WriteLine</code> dikatakan mengembalikan kendali kepada program yang memanggilnya, yang kemudian program tersebut melanjutkan eksekusinya.
Saya terus menerus menggunakan istilah "parameter" dan "argumen". Sebenarnya apa sih? Saya mengatakan bahwa metode <code>WriteLine</code> memiliki sebuah parameter yang diberi nama <code>value</code>. Saya juga mengatakan bahwa saat program memanggil metode <code>WriteLine</code>, maka program tersebut akan memasukkan argumen kepada metode tersebut, yang dalam contoh ini adalah <code>TotalAbsensi</code>. Terlihat jelas, bahwa di sana terdapat hubungan yang sangat dekat antara ''parameter'' dan ''argumen''—bahkan banyak ''programmer'' pun sering menyebut dua hal tersebut seperti dibolak-balik. Akan tetapi, sebagai seorang programmer yang handal (amin), kita jangan mengikuti jejak-jejak yang kurang baik dari para ''programmer'' terdahulu: kita harus bisa membedakan antara kata argumen dan parameter. Lalu di mana perbedaannya? Perbedaan dasarnya adalah hanya satu perspektif, tergantung kita melihatnya dari dalam metode atau dari luar metode. Jika kita bisa "masuk" ke dalam metode <code>WriteLine</code>, maka kita akan melihat kode yang dapat menampilkan parameter <code>value</code> ke dalam layar ''console''. Akan tetapi, kode tersebut tidak akan dieksekusi hingga ada sebuah program memanggil <code>WriteLine</code> dengan sebuah argumen.
Mari kita kembali lagi ke pemanggilan metode di atas:
<source lang="csharp">
System.Console.WriteLine(TotalAbsensi);
</source>
Beberapa ''programmer'' menggunakan spasi kosong untuk memisahkan tanda kurung dengan argumen, seperti di bawah ini:
<source lang="csharp">
System.Console.WriteLine( TotalAbsensi );
</source>
Dan hasilnya akan sama saja seperti bentuk yang di atas. Yang harus kita lakukan adalah mengeja <code>System</code>, <code>Console</code>, atau <code>WriteLine</code> dengan baik dan benar, dengan menggunakan kapitalisasi huruf yang tepat. Jika tidak, kompiler C# akan mengalami "kebingungan", sehingga program kita tidak akan berjalan. Nah lho!!!
Kita juga bisa meneruskan ekspresi numerik ke metode <code>WriteLine</code>. Sebagai contoh, kita dapat melenyapkan variabel TotalAbsensi dan hanya menggunakan tiga variabel lainnya yang membentuk TotalAbsensi, sehingga bentuknya adalah seperti berikut ini:
<source lang="csharp">
System.Console.WriteLine(JumlahHariIzin + JumlahHariSakit + JumlahHariAlfa);
</source>
Jika memang kita hanya menginginkan komputer agar menambahkan angka-angka <code>10</code>, <code>2</code> dan <code>10</code> (nilai-nilai variabel tersebut), kita juga bisa menghapus secara keseluruhan variabel-variabel tersebut, sehingga pernyataannya menjadi:
<source lang="csharp">
System.Console.WriteLine(10 + 2 + 10);
</source>
Akan tetapi, meskipun jika kita hanya berpura-pura bahwa kita membuat program yang melakukan hal yang berguna, adalah hal yang sangat baik untuk menggunakan variabel yang mengindikasikan apa yang harus dilakukan oleh program.
Mungkin kita mengira, bahwa metode <code>WriteLine</code> hanya mentransfer nilai dari angka di dalam variabel ke dalam layar ''console'', akan tetapi sebenarnya <code>WriteLine</code> melakukan hal yang lebih dahsyat lagi dibandingkan dengan apa yang kita bayangkan selama ini. Angka-angka yang kita masukkan ke dalam komputer akan disimpan oleh komputer dalam bentuk pola dari bit-bit tertentu. Agar dapat ditampilkan ke dalam layar ''console'' dalam cara yang berguna, maka angka tersebut dapat diubah ke dalam bentuk teks, yang juga merupakan pola ''bit-bit'' tertentu, tetapi sangatlah berbeda dengan angka.
Jika memang program yang kita tuliskan memiliki banyak panggilan <code>System.Console.WriteLine</code> (seperti yang ditulis di dalam buku ini), maka kita dapat mengurangi kelelahan kita dalam mengetik, dengan membuang bagian ''namespace'' dari <code>System.Console.WriteLine</code>, sehingga yang tinggal adalah <code>Console.WriteLine</code>. Akan tetapi, yang harus Anda lakukan adalah memasukkan direktif <code>using</code> pada bagian awal sebuah program, sebelum deklarasi kelas dilakukan, seperti di bawah ini:
<source lang="csharp">
using System;
</source>
Kata kunci <code>using</code> selalu diikuti dengan nama <code>namespace</code> dan karakter titik koma. Baris ini dikenal juga sebagai '''direktif''' ('''''directive'''''), ketimbang dikenal sebagai sebuah statemen, karena memang baris tersebut tidak memiliki peranan yang penting atau sama sekali tidak memiliki peranan sama sekali saat program akhirnya dijalankan. Baris tersebut hanya menginstruksikan kompiler bahwa kelas apapun yang dirujuk ke dalam program mungkin merupakan anggota dari namespace <code>System</code>.
Jika kita memasukkan direktif seperti itu di dalam program kita, kita dapat memanggil WriteLine dengan hanya menuliskan nama kelas dan nama metodenya saja, seperti di bawah ini:
<source lang="csharp">
using System;
class Programku
{
static void Main()
{
int JumlahHariIzin, JumlahHariAlfa, JumlahHariSakit;
int TotalAbsensi;
JumlahHariIzin = 10;
JumlahHariAlfa = 2;
JumlahHariSakit = 10;
TotalAbsensi = JumlahHariIzin + JumlahHariSakit + JumlahHariAlfa;
Console.WriteLine(TotalAbsensi);
}
}
</source>
Jika kita lihat pada kode di atas, memang penggunaan direktif <code>using</code> di sini tidak mampu menghemat cara pengetikan yang kita lakukan, karena memang di sini hanya ada satu buah metode yang terdapat di dalam ruang nama <code>System</code> yang kita panggil. Akan tetapi, jika kita menulis program dengan banyak sekali rujukan ke dalam kelas-kelas yang berada di dalam ruang nama <code>System</code>, maka hal ini jelas sangat menghemat pengetikan. Karena dapat menghemat pengetikan, maka saya akan menggunakannya di dalam program-program selanjutnya di dalam artikel ini.
{{stub}}
| |||