Anda di halaman 1dari 61

KELOMPOK NAMA

: :

KELOMPOK 2 1.) HANS RAVIE ANDREAS 2.) DERRY APRIYANTO 3.) DWI WAHYU 4.) DEA DAMARA HIDYA 5.) DEWI SHINELURY 6.) DWI NURANI

TUGAS KELAS

: :

MEMBAHAS TENTANG VISUAL C# ( C SHARP ) 1KA4O ( SISTEM INFORMASI,KALIMALANG-BEKASI )

LABORATORIUM SISTEM INFORMASI UNIVERSITAS GUNADARMA 2011

KATA PENGANTAR
MATA KULIAH : PRATIKUM SISTEM INFORMASI KETUA PRATIKUM : INDRA PURNAMA TOPIK TUGAS : PENGENALAN VISUAL C# ( C SHARP ) KELAS : 1KA40 TANGGAL PENYERAHAN TUGAS : 13 NOVEMBER 2011-11-10

PERNYATAAN
Dengan ini kami dari kelompok 2 (dua) telah menyelesaikan tugas pratikum dengan lengkap.Dan kami menyatakan bahwa seluruh pekerjaan dalam tugas ini,kami buat sendiri tanpa plagiat dati orang atau teem lain.Kami juga memiliki sumber-sumber informasi yang terpecaya,teliti dan nyata.

PENYUSUN HANS RAVIE ANDREAS (NPM : 1311206)

PROGRAM SARJANA SISTEM INFORMASI UNIVERSITAS GUNADARMA 2011

DAFTAR ISI

PENDAHULUAN
1.PENGENALAN PROGRAM C# ( C SHARP ) Selamat Datang di tutorial C #. Dengan pengenalan kerangka. NET, Microsoft termasuk bahasa baru yang disebut C # (dibaca C Sharp). C # adalah dirancang untuk menjadi sederhana, modern, tujuan umum, berorientasi objek bahasa pemrograman, meminjam konsep-konsep kunci dari beberapa bahasa lain, terutama Jawa.

C # secara teoritis dapat dikompilasi ke kode mesin, tetapi dalam kehidupan nyata, itu selalu digunakan dalam kombinasi dengan kerangka. NET. Oleh karena itu, aplikasi yang ditulis dalam C #, membutuhkan kerangka. NET untuk diinstal pada komputer yang menjalankan aplikasi. Sementara kerangka. NET memungkinkan untuk menggunakan berbagai bahasa, C # kadang-kadang disebut sebagai THE bahasa. NET, mungkin karena ia dirancang bersama dengan framework.

C # adalah bahasa Object Oriented dan tidak menawarkan variabel global atau fungsi. Semuanya dibungkus dalam kelas-kelas, bahkan jenis sederhana seperti int dan string, yang mewarisi dari kelas System.Object. Dalam bab-bab berikut, Anda akan dipandu melalui topik yang paling penting tentang C #.

2. VISUAL C# EXPRESS C # dapat ditulis dengan editor teks apapun, seperti Windows Notepad, dan kemudian dikompilasi dengan compiler C # Command line, csc.exe, yang datang dengan kerangka. NET. Namun, kebanyakan orang lebih suka menggunakan IDE (Integrated Development Environment), dan Microsoft menawarkan beberapa pilihan untuk ini. Andalan mereka adalah Visual Studio, yang dapat digunakan untuk bekerja pada setiap aspek dari kerangka. NET. Produk ini sangat maju, dan datang dalam beberapa edisi. Visual Studio adalah tidak tepat murah, dan bahkan mungkin terlalu maju untuk programmer hobi. Dengan kerangka 2.0. NET, Microsoft memperkenalkan apa yang disebut versi Express, ditargetkan pada programmer hobi dan orang yang ingin mencoba NET,. Dan mereka melanjutkan tradisi ini dengan merilis kemudian NET 3.0 dan 3.5.. Versi Express hanya bekerja untuk satu bahasa, seperti C # atau VB.NET dan kehilangan beberapa fitur yang sangat canggih dari Visual Studio. Namun, mereka bebas dan akan bekerja dengan baik untuk belajar bahasa, itulah sebabnya kami akan menggunakannya untuk tutorial ini.

Untuk pemrograman C #, Anda harus men-download Visual C # Express dari http://www.microsoft.com/express/download/. Install, dan Anda siap untuk menulis pertama Anda C # aplikasi.

3.PROGRAM using System; menggunakan System.Collections.Generic; menggunakan System.Text;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { } } } Sebenarnya, semua baris ini tidak benar-benar mencapai apa-apa, atau setidaknya itu mungkin tampak begitu. Coba jalankan aplikasi dengan menekan F5 pada keyboard Anda. Ini akan membuat Visual C # Express mengkompilasi dan mengeksekusi kode Anda, tetapi karena Anda akan melihat, itu tidak berbuat banyak. Anda mungkin hanya akan melihat peluncuran jendela hitam dan tutup lagi. Itu karena aplikasi kita tidak melakukan apa pun. Dalam bab berikutnya kita akan melalui baris-baris untuk melihat apa yang mereka semua tentang, tetapi untuk sekarang, kita benar-benar ingin melihat beberapa hasil, jadi mari kita berpura-pura bahwa kita tahu semua tentang C # dan menambahkan beberapa baris untuk mendapatkan beberapa output . Dalam set terakhir dari {}, tambahkan baris ini: Console.WriteLine ("Hello, world!"); Console.ReadLine (); Kode aplikasi pertama Anda sekarang harus terlihat seperti ini:

using System; menggunakan System.Collections.Generic; menggunakan System.Text;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { Console.WriteLine ("Hello, world!"); Console.ReadLine (); } } } Sekali lagi, tekan F5 untuk menjalankannya, dan Anda akan melihat jendela hitam benar-benar tinggal, dan bahkan menampilkan salam kami kepada dunia. Oke, jadi kami menambahkan dua baris kode, tetapi apa yang harus mereka lakukan? Salah satu hal baik tentang C # dan kerangka. NET adalah fakta bahwa banyak kode masuk akal bahkan mata yang tak terlatih, yang contoh ini menunjukkan. Baris pertama menggunakan kelas Console untuk output baris teks, dan yang kedua membaca baris teks dari konsol. Baca? Mengapa? Sebenarnya ini adalah sedikit trik, karena tanpa itu, aplikasi hanya akan berakhir dan menutup jendela dengan output sebelum siapa pun bisa melihatnya. Perintah ReadLine memberitahu aplikasi untuk menunggu input dari user, dan ketika Anda akan melihat, jendela konsol sekarang memungkinkan Anda untuk memasukkan teks. Tekan Enter untuk menutupnya. Selamat, Anda baru saja membuat pertama Anda C # aplikasi! Baca di dalam bab berikut untuk informasi lebih lanjut tentang apa yang sebenarnya terjadi.

4.PENJELASAN LEBIH DALAM Dalam bab sebelumnya, kami mencoba menulis sepotong teks untuk konsol, terlebih dahulu aplikasi kita C #. Untuk melihat beberapa kemajuan yang sebenarnya, kita tidak pergi ke detail banyak tentang baris kode yang kita gunakan, sehingga bab ini adalah penjelasan dari kode contoh dunia Halo. Seperti Anda mungkin bisa melihat dari kode, beberapa garis terlihat mirip, sehingga kami akan membawa mereka kembali dalam kelompok-kelompok untuk penjelasan individu. Mari kita mulai dengan karakter terpendek dan paling umum dalam kode kami: {dan}. Mereka sering disebut sebagai kurung kurawal, dan di C #, mereka menandai awal dan akhir sebuah blok kode secara logis. Kurung kurawal digunakan dalam banyak bahasa lainnya, termasuk C + +, Java, JavaScript, dan banyak lainnya. Seperti yang Anda lihat dalam kode, mereka digunakan untuk membungkus beberapa baris kode yang dimiliki bersama-sama. Dalam contoh nanti, maka akan jelas bagaimana mereka digunakan.

Sekarang mari kita mulai dari awal: using System; menggunakan System.Collections.Generic; menggunakan System.Text; menggunakan adalah kata kunci, disorot dengan warna biru oleh editor. Kata kunci menggunakan namespace impor, dan namespace adalah kumpulan dari kelas. Kelas membawa kita semacam fungsi, dan ketika bekerja dengan IDE canggih seperti Visual C # Express, biasanya akan membuat bagian-bagian dari kode sepele bagi kita. Dalam hal ini, menciptakan sebuah kelas untuk kami, dan mengimpor ruang nama yang diperlukan atau diharapkan untuk digunakan umum. Dalam kasus ini, 3 ruang nama yang diimpor untuk kita, masing-masing berisi banyak kelas berguna. Sebagai contoh, kita menggunakan kelas Console, yang merupakan bagian dari namespace System.

Seperti yang Anda lihat, kita bahkan mendapatkan namespace kita sendiri: ConsoleApplication1 namespace Namespace ConsoleApplication1 sekarang namespace utama untuk aplikasi ini, dan kelas baru akan menjadi bagian dari itu secara default. Jelas, Anda dapat mengubah ini, dan menciptakan kelas-kelas dalam namespace lain. Dalam hal ini, Anda harus impor ini namespace baru untuk menggunakannya dalam aplikasi Anda, dengan pernyataan menggunakan, seperti namespace lain.

Selanjutnya, kita mendefinisikan kelas kami. Karena C # adalah benar-benar sebuah bahasa Object Oriented, setiap baris kode yang benar-benar melakukan sesuatu, ini dibungkus dalam kelas. Dalam kasus ini, kelas hanya disebut Program: Program kelas Kita dapat memiliki kelas yang lebih, bahkan dalam file yang sama. Untuk sekarang, kita hanya perlu satu kelas. Kelas A dapat berisi beberapa variabel, properti dan metode, konsep kita akan pergi lebih dalam di kemudian hari. Untuk saat ini, semua yang perlu Anda ketahui adalah bahwa kelas kami saat ini hanya berisi satu metode dan tidak ada lagi. Ini menyatakan seperti ini: static void Main (string [] args) Baris ini mungkin adalah salah satu yang paling rumit dalam contoh ini, jadi mari kita split sedikit. Kata pertama adalah statis. Kata kunci statis memberitahu kita bahwa metode ini harus accesible tanpa instantiate kelas, tetapi lebih tentang hal ini dalam bab tentang kelas-kelas. Kata kunci berikutnya adalah batal, dan memberitahu kita apa metode ini harus kembali. Misalnya, int dapat menjadi integer atau string teks, namun dalam kasus ini, kita tidak ingin metode kami untuk kembali apa pun, atau batal, yang sama sebagai jenis tidak ada. Kata berikutnya adalah utama, yang hanya nama metode kami. Metode ini disebut entry-titik aplikasi kita, yaitu, bagian pertama dari kode yang akan dieksekusi, dan dalam contoh kita, satu-satunya yang akan dieksekusi. Sekarang, setelah nama metode, satu set argumen dapat ditentukan dalam satu set tanda kurung. Dalam contoh kita, metode kami hanya membutuhkan satu argumen, yang disebut args. Jenis argumen adalah string, atau lebih tepatnya, array string, tetapi lebih pada nanti. Jika Anda berpikir tentang hal ini, ini masuk akal, karena aplikasi Windows selalu dapat disebut dengan seperangkat argumen optinal. Argumen-argumen ini akan diteruskan sebagai string teks dengan metode utama kami.

Dan itu saja. Anda sekarang harus memiliki pemahaman dasar pertama aplikasi kita C #, serta prinsip-prinsip dasar dari apa yang membuat sebuah karya aplikasi konsol.

5.TIPE DATA Tipe data yang digunakan di mana-mana dalam bahasa pemrograman seperti C #. Karena itu bahasa sangat diketik, Anda diminta untuk menginformasikan compiler tentang tipe data yang ingin Anda gunakan setiap kali Anda mendeklarasikan variabel, karena Anda akan melihat dalam bab tentang variabel. Dalam bab ini kita akan melihat beberapa jenis data yang paling sering digunakan dan bagaimana mereka bekerja.

bool adalah salah satu tipe data sederhana. Hal ini hanya dapat berisi 2 nilai - salah atau benar. Jenis bool adalah penting untuk memahami ketika menggunakan operator logika seperti pernyataan jika.

int adalah singkat untuk integer, tipe data untuk menyimpan nomor tanpa desimal. Ketika bekerja dengan angka, int adalah tipe data yang paling umum digunakan. Integer memiliki beberapa jenis data dalam C #, tergantung pada ukuran dari jumlah yang seharusnya untuk menyimpan.

string digunakan untuk menyimpan teks, yaitu, sejumlah karakter. Dalam C #, string yang berubah, yang berarti bahwa string tidak pernah berubah setelah mereka telah diciptakan. Bila menggunakan metode yang mengubah string, string sebenarnya tidak berubah - sebuah string baru dikembalikan sebagai gantinya.

char digunakan untuk menyimpan sebuah karakter tunggal.

float salah satu jenis data yang digunakan untuk menyimpan nomor yang mungkin atau mungkin tidak mengandung desimal.

6.VARIABEL Sebuah variabel dapat dibandingkan dengan ruang penyimpanan, dan sangat penting untuk programmer. Dalam C #, variabel dinyatakan seperti ini:

<tipe data> <name>;

Sebuah contoh bisa terlihat seperti ini:

string nama;

Itu versi yang paling dasar. Biasanya, Anda ingin untuk menetapkan visibilitas ke variabel, dan mungkin memberikan nilai untuk itu pada waktu yang sama. Hal ini dapat dilakukan seperti ini:

<visibility> <tipe data> <name> = <value>;

Dan dengan sebuah contoh: private string name = "John Doe"; Bagian visibilitas dijelaskan di bagian lain dalam tutorial ini, jadi mari kita berkonsentrasi pada bagian variabel. Kami akan melompat langsung ke contoh benarbenar menggunakan beberapa dari mereka: using System;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) {

String firstName = "John"; String NamaBelakang = "Doe";

Console.WriteLine ("Nama:" + firstName + "" + NamaBelakang);

Console.WriteLine ("Masukkan nama depan baru:"); firstName = Console.ReadLine ();

Console.WriteLine ("name:" + firstName + "" + NamaBelakang);

Console.ReadLine (); } } } Oke, banyak ini telah dijelaskan, jadi kami akan melompat langsung ke bagian yang menarik. Pertama-tama, kita mendeklarasikan beberapa variabel dari tipe string. Sebuah string hanya berisi teks, seperti yang Anda lihat, karena kita memberikan nilai langsung. Selanjutnya, kami output baris teks ke konsol, dimana kami menggunakan dua variabel. String adalah dibuat dengan menggunakan karakter + untuk "mengumpulkan" bagian yang berbeda.

Selanjutnya, kami mendesak pengguna untuk memasukkan nama baru pertama, dan kemudian kita menggunakan ReadLine () metode untuk membaca masukan pengguna dari konsol dan ke dalam variabel firstName. Setelah pengguna menekan tombol Enter, nama baru pertama ditugaskan untuk variabel, dan pada baris berikutnya kami output presentasi nama lagi, untuk menunjukkan perubahan. Kami telah hanya digunakan variabel pertama kami dan fitur yang paling penting dari suatu variabel: Kemampuan untuk mengubah nilainya pada saat runtime.

Contoh menarik lain adalah melakukan matematika. Berikut adalah salah satu, didasarkan pada banyak kode yang sama kita hanya digunakan:

int number1, number2;

Console.WriteLine ("Masukkan angka:"); number1 = int.Parse (Console.ReadLine ());

Console.WriteLine ("Terima kasih Satu lagi:."); number2 = int.Parse (Console.ReadLine ());

Console.WriteLine ("Menambahkan dua angka:" + (angka1 + number2));

Console.ReadLine (); Menempatkan ini dalam metode Utama kami, dan mencobanya. Hanya baru "trik" yang kita gunakan di sini, adalah int.Parse () metode. Ini hanya membaca string dan mengubahnya menjadi integer. Seperti yang Anda lihat, aplikasi ini tidak membuat upaya untuk memvalidasi input pengguna, dan jika anda memasukkan sesuatu yang bukan angka, pengecualian akan dibangkitkan. Lebih banyak tentang nanti.

7.STATMENT IF Salah satu pernyataan yang paling penting dalam setiap bahasa pemrograman adalah jika pernyataan. Mampu mengatur kode blok bersyarat adalah pokok mendasar dari menulis perangkat lunak. Dalam C #, jika pernyataan ini sangat mudah digunakan. Jika Anda telah menggunakan bahasa pemrograman lain, kemungkinan adalah bahwa Anda dapat menggunakan jika pernyataan C # langsung. Dalam kasus apapun, baca terus untuk melihat bagaimana hal itu digunakan. Pernyataan jika kebutuhan hasil boolean, yaitu, benar atau salah. Dalam beberapa bahasa pemrograman, beberapa tipe data dapat secara otomatis dikonversi ke boolean, tapi di C #, Anda harus secara khusus membuat hasil boolean. Misalnya, Anda tidak dapat menggunakan jika (jumlah), tetapi Anda dapat membandingkan angka untuk sesuatu, untuk menghasilkan benar atau salah, seperti yang kami lakukan di kemudian hari. Dalam bab sebelumnya kita melihat variabel, jadi kami akan memperluas pada salah satu contoh untuk melihat bagaimana logika bersyarat dapat digunakan. using System;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { int nomor;

Console.WriteLine ("Masukkan nomor antara 0 dan 10:"); nomor = int.Parse (Console.ReadLine ());

jika (nomor> 10) Console.WriteLine ("Hei Jumlah harus 10 atau kurang!!"); lain if (angka <0)

Console.WriteLine ("Hei Jumlah harus 0 atau lebih!!"); lain Console.WriteLine ("Good job!");

Console.ReadLine (); } } } Kami menggunakan 2 jika laporan untuk memeriksa apakah nomor yang dimasukkan adalah antara 0 dan 10, dan teman dari pernyataan jika: kata kunci lain. Maknanya harus jelas kepada siapa pun berbahasa Inggris - itu hanya menawarkan alternatif untuk kode yang sedang dieksekusi jika kondisi jika pernyataan ini tidak terpenuhi. Seperti Anda mungkin telah menyadari, kita tidak menggunakan karakter {dan} untuk menentukan blok bersyarat dari kode. Aturannya adalah bahwa jika blok hanya berisi satu baris kode, blok karakter tidak diperlukan. Sekarang, ini tampaknya seperti banyak baris untuk hanya memeriksa nomor satu, bukan? Hal ini dapat dilakukan dengan lebih sedikit baris kode, seperti ini: if ((nomor> 10) | | (jumlah <0)) Console.WriteLine ("Hei Jumlah harus 0 atau lebih dan 10 atau kurang!!"); lain Console.WriteLine ("Good job!"); Kami menempatkan kondisi masing-masing dalam satu set tanda kurung, dan kemudian kita menggunakan operator |, yang berarti "atau", untuk memeriksa apakah nomor tersebut baik lebih dari 10 ATAU kurang dari 0 |. Operator lain Anda akan menggunakan banyak adalah operator AND, yang ditulis seperti ini: & &. Bisakah kita telah menggunakan operator AND, bukan? Tentu saja, kita hanya memutarnya sedikit, seperti ini: jika ((jumlah <= 10) & & (nomor> = 0)) Console.WriteLine ("Good job!"); lain Console.WriteLine ("Hei Jumlah harus 0 atau lebih dan 10 atau kurang!!");

8.PERNYATAAN SWITCH PADA C# Pernyataan switch adalah seperti satu set pernyataan if. Ini adalah daftar kemungkinan, dengan tindakan untuk setiap kemungkinan, dan aksi default opsional, dalam kasus tidak ada lagi yang mengevaluasi untuk benar. Sebuah pernyataan switch sederhana terlihat seperti ini: int angka = 1; switch (angka) { case 0: Console.WriteLine ("Jumlah itu nol!"); break; kasus 1: Console.WriteLine ("Jumlah itu satu!"); break; } Identifier untuk memeriksa adalah diletakkan setelah kata kunci switch, dan kemudian ada daftar laporan kasus, di mana kita memeriksa identifier terhadap nilai yang diberikan. Anda akan melihat bahwa kita memiliki pernyataan break pada akhir setiap kasus. C # hanya mensyaratkan bahwa kita meninggalkan blok sebelum berakhir. Dalam kasus Anda sedang menulis fungsi, Anda bisa menggunakan pernyataan kembali bukan pernyataan break. Dalam kasus ini, kita menggunakan integer, tetapi bisa berupa string juga, atau jenis sederhana lainnya. Juga, Anda dapat menentukan tindakan yang sama untuk kasuskasus beberapa. Kami akan melakukan itu di contoh berikut juga, di mana kita mengambil sepotong masukan dari pengguna dan menggunakannya dalam pernyataan switch kami: Console.WriteLine ("Apakah Anda menikmati C # (ya / tidak / mungkin)?"); input string = Console.ReadLine (); switch (input.ToLower ()) { Kasus "ya":

kasus "mungkin": Console.WriteLine ("Bagus!"); break; kasus "tidak": Console.WriteLine ("Sayang sekali!"); break; } Dalam contoh ini, kami meminta pengguna pertanyaan, dan menyarankan bahwa mereka masuk baik ya, tidak atau mungkin. Kami kemudian membaca input pengguna, dan membuat pernyataan switch untuk itu. Untuk membantu pengguna, kita mengubah input menjadi huruf kecil sebelum kita memeriksa terhadap string huruf kecil kita, sehingga tidak ada perbedaan antara huruf kecil dan huruf besar. Namun, pengguna mungkin membuat kesalahan ketik atau mencoba menulis sesuatu yang sama sekali berbeda, dan dalam kasus itu, tidak ada output akan dihasilkan oleh pernyataan switch tertentu. Masukkan kata kunci default! Console.WriteLine ("Apakah Anda menikmati C # (ya / tidak / mungkin)?"); input string = Console.ReadLine (); switch (input.ToLower ()) { Kasus "ya": kasus "mungkin": Console.WriteLine ("Bagus!"); break; kasus "tidak": Console.WriteLine ("Sayang sekali!"); break; default: Console.WriteLine ("Maaf, saya tidak mengerti!"); break;}

9.LOOP Teknik lain yang penting ketika menulis perangkat lunak adalah perulangan kemampuan untuk mengulang blok kode X kali. Dalam C #, mereka datang dalam 4 varian yang berbeda, dan kami akan melihat pada masing-masing dari mereka. Loop sementara

Loop sementara mungkin yang paling sederhana satu, jadi kita akan mulai dengan itu. Loop sementara hanya mengeksekusi blok kode selama kondisi yang Anda berikan adalah benar. Sebuah contoh kecil, dan kemudian beberapa penjelasan: using System;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { int jumlah = 0;

sementara (nomor <5) { Console.WriteLine (jumlah); nomor = nomor + 1; }

Console.ReadLine (); } }

} Mencoba menjalankan kode. Anda akan mendapatkan daftar nomor yang bagus, dari 0 sampai 4. Jumlah ini pertama didefinisikan sebagai 0, dan setiap kali kode di loop dijalankan, itu bertambah satu. Tapi mengapa hal itu hanya bisa 4, ketika kode mengatakan 5? Untuk kondisi untuk kembali benar, nomor harus kurang dari 5, yang dalam hal ini berarti bahwa kode yang output jumlahnya tidak tercapai setelah jumlah ini sama dengan 5. Hal ini karena kondisi loop sementara dievaluasi sebelum memasuki blok kode. Loop lakukan

Sebaliknya adalah benar untuk loop lakukan, yang bekerja seperti loop sementara di aspek lain melalui. Loop melakukan mengevaluasi kondisi setelah loop telah dieksekusi, yang memastikan bahwa blok kode selalu dijalankan minimal sekali. melakukan { Console.WriteLine (jumlah); nomor = nomor + 1; } While (angka <5); Output adalah sama meskipun - sekali jumlah ini lebih dari 5, loop keluar. Untuk loop

Untuk loop adalah sedikit berbeda. Ini lebih disukai ketika Anda tahu berapa banyak iterasi yang Anda inginkan, baik karena Anda mengetahui jumlah yang tepat dari iterasi, atau karena Anda memiliki variabel yang berisi jumlah. Berikut adalah contoh untuk loop. using System;

ConsoleApplication1 namespace { Program kelas {

static void Main (string [] args) { int number = 5;

for (int i = 0; i <jumlah; i + +) Console.WriteLine (i);

Console.ReadLine (); } } } Hal ini menghasilkan output yang sama persis, tetapi karena Anda dapat melihat, untuk loop sedikit lebih kompak. Ini terdiri dari 3 bagian - kita menginisialisasi variabel untuk menghitung, membuat pernyataan bersyarat untuk menguji, dan kenaikan counter (+ + berarti sama dengan "variabel = variabel + 1"). Bagian pertama, di mana kita mendefinisikan variabel i dan set ke 0, hanya dieksekusi sekali, sebelum loop dimulai. 2 terakhir bagian tersebut dieksekusi pada setiap iterasi dari loop. Setiap kali, i dibandingkan dengan variabel nomor kami - jika saya lebih kecil dari jumlah, loop berjalan sekali lagi. Setelah itu, i adalah bertambah satu. Cobalah menjalankan program, dan setelah itu, cobalah mengubah nomor variabel untuk sesuatu yang lebih besar atau lebih kecil dari 5. Anda akan melihat loop merespon perubahan. Foreach lingkaran

Loop terakhir kita akan melihat, adalah loop foreach. Ini beroperasi pada koleksi item, untuk array misalnya atau built-in jenis daftar. Dalam contoh kita akan menggunakan salah satu daftar sederhana, yang disebut sebuah ArrayList. Ia bekerja seperti sebuah array, tapi jangan khawatir, kita akan melihat ke dalamnya pada bab berikutnya. using System; menggunakan System.Collections;

ConsoleApplication1 namespace

{ Program kelas { static void Main (string [] args) { ArrayList list = new ArrayList (); list.Add ("John Doe"); list.Add ("Jane Doe"); list.Add ("Orang Lain");

foreach (string nama dalam daftar) Console.WriteLine (nama);

Console.ReadLine (); } } } Oke, jadi kita membuat sebuah instance dari sebuah ArrayList, dan kemudian kita menambahkan beberapa item string untuk itu. Kami menggunakan loop foreach untuk menjalankan melalui setiap item, pengaturan variabel nama untuk item kita telah mencapai setiap waktu. Dengan begitu, kita memiliki variabel bernama untuk output. Seperti yang Anda lihat, kita mendeklarasikan variabel nama yang akan dari tipe string Anda selalu perlu memberitahu loop foreach yang datatype Anda mengharapkan untuk menarik keluar dari koleksi. Dalam kasus Anda memiliki daftar dari berbagai jenis, Anda dapat menggunakan kelas objek bukan kelas khusus, untuk menarik keluar setiap item sebagai obyek. Ketika bekerja dengan koleksi, Anda sangat mungkin akan menggunakan loop foreach sebagian besar waktu, terutama karena itu sederhana daripada loop lainnya untuk operasi semacam ini.

10.FUNGSI VISUAL C# Fungsi memungkinkan Anda untuk membungkus sepotong kode dan menyebutnya dari bagian lain dari kode Anda. Anda mungkin sangat segera berlari ke dalam situasi di mana Anda perlu untuk mengulang sepotong kode, dari beberapa tempat, dan ini adalah di mana fungsi masuk Dalam C #, pada dasarnya mereka menyatakan seperti ini: <visibility> <return data> <name> (<parameters>) { <function code> } Untuk memanggil fungsi, Anda hanya menulis namanya, sebuah kurung buka, maka parameter, jika ada, dan kemudian kurung penutup, seperti ini: DoStuff (); Berikut adalah contoh dari kita DoStuff () fungsi: public void DoStuff () { Console.WriteLine ("Saya melakukan sesuatu ..."); } Bagian pertama, publik, visibilitas, dan adalah opsional. Jika Anda tidak menentukan apapun, maka fungsi akan pribadi. Lebih lanjut tentang itu nanti. Berikutnya adalah jenis untuk kembali. Itu bisa tipe apapun yang benar dalam C #, atau seperti yang kita lakukan di sini, batal. Sebuah kekosongan berarti bahwa fungsi ini mengembalikan apa-apa. Juga, fungsi ini tidak membutuhkan parameter, seperti yang Anda lihat dari himpunan kosong dari kurung, sehingga sebenarnya hanya sedikit anak laki-laki membosankan. Mari kita ubah bahwa: public int AddNumbers (int number1, number2 int) { int hasil = angka1 + number2; kembali hasil; }

Kami telah mengubah hampir segalanya. Fungsi sekarang mengembalikan sebuah integer, dibutuhkan dua parameter (baik bilangan bulat), dan bukannya keluaran sesuatu, itu membuat perhitungan dan kemudian mengembalikan hasilnya. Ini berarti bahwa kita dapat menambahkan dua nomor dari berbagai tempat di kode kita, hanya dengan memanggil fungsi ini, daripada harus menulis kode perhitungan waktu masingmasing. Meskipun kami tidak menyimpan banyak waktu dan usaha dalam hal ini contoh kecil, Anda lebih percaya bahwa Anda akan belajar mencintai fungsi, semakin Anda menggunakan C #. Fungsi ini disebut seperti ini: int hasil = AddNumbers (10, 5); Console.WriteLine (hasil); Seperti disebutkan, fungsi ini benar-benar kembali sesuatu, dan itu harus, karena kita mengatakan C # yang itu seharusnya untuk melakukannya. Ketika mendeklarasikan hal lain daripada batal sebagai jenis kembali, kita memaksa diri kita untuk kembali sesuatu. Anda dapat mencoba menghapus garis kembali dari contoh di atas, dan melihat compiler mengeluh:

'AddNumbers (int, int)': tidak semua path kode mengembalikan nilai

Compiler adalah mengingatkan kita bahwa kita memiliki fungsi yang tidak mengembalikan sesuatu, meskipun kita berjanji. Dan compiler cukup pintar! Alih-alih menghapus baris, mencoba sesuatu seperti ini: public int AddNumbers (int number1, number2 int) { int hasil = angka1 + number2; if (hasil> 10) { kembali hasil; } } Anda akan melihat kesalahan yang sama persis - tapi kenapa? Karena tidak ada jaminan bahwa jika pernyataan kami akan mengevaluasi dengan benar dan jalur kembali dieksekusi. Anda dapat memecahkan ini dengan memiliki standar, kedua seperti pernyataan kembali pada akhirnya:

public int AddNumbers (int number1, number2 int) { int hasil = angka1 + number2; if (hasil> 10) { kembali hasil; } return 0; } Hal ini akan memperbaiki masalah yang kami ciptakan untuk diri kita, dan juga akan menunjukkan bahwa kita dapat memiliki lebih dari satu pernyataan kembali dalam fungsi kita. Segera setelah pernyataan kembali tercapai, fungsi dan kode yang tersisa tidak lebih di dalamnya dijalankan. Dalam hal ini, itu berarti bahwa selama hasilnya lebih tinggi dari 10, "return 0" tidak pernah tercapai.

11.PARAMETER FUNGSI Dalam bab sebelumnya, kita telah melihat fungsi. Kami singkat dibahas parameter, tapi hanya sebentar. Sementara parameter yang sangat sederhana dan lurus ke depan untuk digunakan, ada trik yang dapat membuat mereka banyak lebih kuat.

Hal pertama yang kita akan melihat, adalah keluar dan pengubah ref. C #, dan bahasa lainnya juga, berbeda antara dua parameter: "dengan nilai" dan "dengan referensi". Default di C # adalah "dengan nilai", yang pada dasarnya berarti bahwa ketika Anda lulus pada variabel ke pemanggilan fungsi, Anda benar-benar mengirimkan salinan objek, bukan referensi untuk itu. Ini juga berarti bahwa Anda dapat membuat perubahan pada parameter dari dalam fungsi, tanpa mempengaruhi objek asli Anda dikirimkan sebagai parameter.

Dengan kata kunci ref dan keluar, kita dapat mengubah perilaku ini, jadi kita meneruskan referensi ke objek, bukan nilainya. Ref pengubah

Perhatikan contoh berikut: static void Main (string [] args) { int jumlah = 20; AddFive (jumlah); Console.WriteLine (jumlah); Console.ReadKey (); }

AddFive static void (int angka) { jumlah = jumlah + 5; }

Kami menciptakan sebuah integer, menetapkan nomor 20 untuk itu, dan kemudian kita menggunakan AddFive () metode, yang harus menambahkan 5 ke nomor tersebut. Tapi apakah itu? Tidak nilai kita assign ke nomor di dalam fungsi, tidak pernah dilakukan fungsi, karena kita telah melewati salinan dari nilai angka bukan referensi untuk itu. Ini hanyalah bagaimana C # bekerja, dan dalam banyak kasus, itu hasil pilihan. Namun, dalam kasus ini, kita benar-benar ingin mengubah nomor dalam fungsi kita. Masukkan kata kunci ref: static void Main (string [] args) { int jumlah = 20; AddFive (ref angka); Console.WriteLine (jumlah); Console.ReadKey (); }

static void AddFive (ref int angka) { jumlah = jumlah + 5; } Seperti yang Anda lihat, semua yang kita lakukan adalah menambahkan kata kunci ref ke deklarasi fungsi serta panggilan ke fungsi. Jika Anda menjalankan program ini sekarang, Anda akan melihat bahwa nilai dari jumlah sekarang telah berubah, setelah kita kembali dari panggilan fungsi. Pengubah keluar

Pengubah keluar bekerja cukup banyak seperti pengubah ref. Mereka berdua memastikan bahwa parameter dilewatkan oleh referensi bukan oleh nilai, tetapi mereka datang dengan dua perbedaan penting: Sebuah nilai dilewatkan ke ref pengubah harus diinisialisasi sebelum memanggil metode - ini tidak benar untuk pengubah keluar, di mana Anda dapat menggunakan un-diinisialisasi nilai. Di sisi lain, Anda tidak dapat meninggalkan panggilan fungsi dengan parameter keluar, tanpa memberi nilai untuk itu. Karena Anda dapat lulus dalam un-diinisialisasi nilai sebagai parameter, Anda tidak

dapat benar-benar menggunakan parameter keluar di dalam fungsi - Anda hanya dapat menetapkan nilai baru untuk itu.

Apakah akan menggunakan keluar atau ref benar-benar tergantung pada situasi, karena Anda akan menyadari setelah Anda mulai menggunakan mereka. Keduanya biasanya digunakan untuk bekerja di sekitar masalah hanya bisa mengembalikan satu nilai dari fungsi, dengan C #.

Menggunakan pengubah keluar adalah seperti menggunakan pengubah ref, seperti yang ditunjukkan di atas. Cukup mengubah kata kunci ref untuk kata kunci keluar. Params pengubah

Sejauh ini, semua fungsi kami telah menerima jumlah yang tetap parameter. Namun, dalam beberapa kasus, Anda mungkin perlu fungsi yang mengambil nomor acak parameter. Hal ini tentu saja dapat dilakukan dengan menerima sebuah array atau daftar sebagai parameter, seperti ini:

GreetPersons void (string [] nama) {}

Namun, menyebutnya akan sedikit canggung. Dalam bentuk terpendek, akan terlihat seperti ini:

GreetPersons (string baru [] {"John", "Jane", "Tarzan"});

Hal ini dapat diterima, namun hal itu dapat dilakukan bahkan lebih cerdas, dengan kata kunci params:

static void GreetPersons (params string [] nama) {}

Memanggil maka akan terlihat seperti ini:

GreetPersons ("John", "Jane", "Tarzan");

Keuntungan lain menggunakan pendekatan params, adalah bahwa Anda diijinkan untuk melewati parameter nol untuk itu juga. Fungsi dengan params bahkan dapat mengambil parameter lain juga, selama sebagai parameter dengan kata kunci params adalah yang terakhir. Selain itu, hanya satu parameter dengan menggunakan kata kunci params dapat digunakan per fungsi. Berikut adalah contoh terakhir dan lebih lengkap: static void Main (string [] args) { GreetPersons (0); GreetPersons (25, "John", "Jane", "Tarzan"); Console.ReadKey (); }

GreetPersons void (int someUnusedParameter, params string [] nama) { foreach (string nama dalam nama) Console.WriteLine ("Hello," + nama); }

11.ARRAY Array bekerja sebagai koleksi barang, untuk string misalnya. Anda dapat menggunakannya untuk mengumpulkan barang-barang dalam kelompok tunggal, dan melakukan berbagai operasi pada mereka, misalnya penyortiran. Selain itu, beberapa metode dalam kerangka bekerja pada array, untuk memungkinkan untuk menerima berbagai item bukan hanya satu. Fakta ini saja membuat penting untuk mengetahui sedikit tentang array.

Array dinyatakan seperti variabel, dengan satu set [] kurung setelah datatype, seperti ini:

string [] nama;

Anda perlu untuk instantiate array untuk menggunakannya, yang dilakukan seperti ini:

string [] nama = string baru [2];

Jumlah (2) adalah ukuran dari array, yaitu, jumlah barang yang kami dapat menempatkan di dalamnya. Menempatkan item ke array cukup sederhana juga:

nama [0] = "John Doe";

Tapi kenapa 0? Karena dengan begitu banyak hal dalam dunia pemrograman, menghitung mulai dari 0 bukan 1. Jadi item pertama diindeks sebagai 0, berikutnya sebagai 1 dan seterusnya. Anda harus ingat ini ketika mengisi array dengan item, karena Overfilling akan menyebabkan pengecualian. Ketika Anda melihat penginisialisasi, pengaturan array untuk ukuran 2, mungkin tampak alami untuk menempatkan item nomor 0, 1 dan 2 ke dalamnya, namun ini adalah salah satu item yang terlalu banyak. Jika Anda melakukannya, pengecualian akan dilempar. Kami akan membahas pengecualian dalam bab berikutnya.

Sebelumnya, kami belajar tentang loop, dan jelas ini pergi besar dengan array. Cara yang paling umum untuk mendapatkan data dari array, adalah untuk loop melalui itu dan melakukan semacam operasi dengan nilai masing-masing. Mari kita menggunakan array dari sebelumnya, untuk membuat contoh nyata: using System; menggunakan System.Collections;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { string [] nama = string baru [2];

nama [0] = "John Doe"; nama [1] = "Jane Doe";

foreach (string s di nama) Console.WriteLine (s);

Console.ReadLine (); } } } Kami menggunakan loop foreach, karena itu yang paling mudah, tapi tentu saja kita bisa menggunakan salah satu jenis lain dari loop sebagai gantinya. Untuk loop yang baik dengan array juga, misalnya jika Anda perlu untuk menghitung setiap item, seperti ini: for (int i = 0; i <names.Length; i + +)

Console.WriteLine ("Item nomor" + i + ":" + nama [i]); Ini sebenarnya sangat sederhana. Kami menggunakan properti Panjang array untuk memutuskan berapa kali loop harus iterate, dan kemudian kita menggunakan counter (i) ke output mana kita berada dalam proses, serta mendapatkan item dari array. Sama seperti kita menggunakan nomor, disebut indexer, untuk menempatkan barang-barang ke dalam array, kita dapat menggunakannya untuk mendapatkan item tertentu keluar lagi.

Saya katakan sebelumnya bahwa kita bisa menggunakan array untuk mengurutkan berbagai nilai, dan itu sebenarnya sangat mudah. Kelas Array berisi sekumpulan metode pintar untuk bekerja dengan array. Contoh ini akan menggunakan angka bukan string, hanya untuk mencoba sesuatu yang lain, tetapi hanya bisa dengan mudah telah string. Saya ingin menunjukkan cara lain untuk mengisi sebuah array, yang jauh lebih mudah jika Anda memiliki satu set, kecil standar item yang Anda ingin dimasukkan ke dalam array Anda. Coba lihat:

int [] angka = new int [5] {4, 3, 8, 0, 5};

Dengan satu baris, kami telah membuat sebuah array dengan ukuran 5, dan mengisinya dengan 5 bilangan bulat. Dengan mengisi array seperti ini, Anda mendapatkan keuntungan ekstra, karena compiler akan memeriksa dan memastikan bahwa Anda tidak menaruh terlalu banyak item dalam array. Cobalah menambahkan nomor lebih Anda akan melihat compiler mengeluh tentang hal itu.

Sebenarnya, hal itu dapat dilakukan bahkan lebih pendek, seperti ini:

int [] angka = {4, 3, 8, 0, 5};

Ini adalah singkat, dan Anda tidak harus menentukan ukuran. Pendekatan pertama mungkin lebih mudah untuk dibaca di kemudian hari sekalipun. Mari kita coba menyortir array - berikut ini adalah contoh lengkap: using System; menggunakan System.Collections;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { int [] angka = {4, 3, 8, 0, 5};

Array.Sort (angka);

foreach (int i dalam angka) Console.WriteLine (i);

Console.ReadLine (); } } } Satu-satunya hal yang baru sebenarnya di sini adalah perintah Array.Sort. Hal ini dapat mengambil berbagai parameter, untuk berbagai jenis pemilahan, namun dalam kasus ini, itu hanya dibutuhkan array kita. Seperti yang dapat Anda lihat dari hasilnya, array kita telah disortir. Kelas Array memiliki metode lain juga, misalnya Reverse () metode. Anda dapat mencarinya di dokumentasi untuk melihat semua fitur dari kelas Array. Array kita telah menggunakan sejauh ini hanya memiliki satu dimensi. Namun, C # array dapat multidimensi, kadang-kadang disebut sebagai array dalam array. Array multidimensi datang dalam dua rasa dengan C #: Rectangular array dan array bergerigi. Perbedaannya adalah bahwa dengan array persegi panjang, semua dimensi harus ukuran yang sama, maka nama persegi panjang. Sebuah array bergerigi dapat memiliki dimensi dari berbagai ukuran. Array multidimensi adalah subjek berat, dan sedikit keluar dari lingkup tutorial ini.

12.PENGENALAN KELAS C# ( C SHARP ) Dalam banyak tutorial pemrograman, informasi mengenai kelas akan disimpan untuk kemudian. Namun, karena C # adalah semua tentang pemrograman Berorientasi Objek dan dengan demikian kelas, kita akan membuat pengenalan dasar hal-hal yang paling penting sudah sekarang.

Pertama-tama, kelas adalah sekelompok metode terkait dan variabel. Kelas A menggambarkan hal-hal ini, dan dalam kebanyakan kasus, Anda membuat sebuah instance dari kelas ini, sekarang disebut sebagai objek. Di obyek ini, Anda menggunakan metode yang didefinisikan dan variabel. Tentu saja, Anda dapat membuat sebagai banyak contoh kelas Anda seperti yang Anda mau. Kelas, dan pemrograman Berorientasi Obyek pada umumnya, adalah topik besar. Kami akan mencakup beberapa dari itu dalam bab ini maupun di bab-bab selanjutnya, tapi tidak semuanya.

Dalam bab Halo dunia, kami melihat kelas digunakan untuk pertama kalinya, karena segala sesuatu dalam C # adalah dibangun di atas kelas. Mari kita memperluas Halo contoh dunia kita dengan kelas kita membangun kita sendiri. using System;

ConsoleApplication1 namespace { Program kelas { static void Main (string [] args) { Mobil mobil;

mobil Mobil = baru ("Red"); Console.WriteLine (car.Describe ());

mobil Mobil = baru ("Hijau");

Console.WriteLine (car.Describe ());

Console.ReadLine ();

} }

Mobil kelas { swasta String warna;

publik Mobil (warna string) { this.color = warna; }

Jelaskan string publik () { kembali "Mobil ini adalah" + Warna; }

publik string yang Warna { mendapatkan {color kembali;} himpunan {color = nilai;} } }

} Oke, banyak hal baru di sini, tapi hampir semua itu didasarkan pada sesuatu yang kita sudah digunakan sebelumnya dalam tutorial ini. Seperti yang Anda lihat, kami telah membuat sebuah kelas baru, yang disebut Mobil. Ini dinyatakan dalam file yang sama sebagai aplikasi utama kami, untuk gambaran lebih mudah, Namun, biasanya kelas baru didefinisikan dalam file mereka sendiri. Ini mendefinisikan sebuah variabel tunggal, yang disebut warna, yang tentu saja digunakan untuk memberitahu warna mobil kami. Kami menyatakan itu sebagai pribadi, yang merupakan praktek yang baik - mengakses variabel dari luar harus dilakukan dengan menggunakan properti. Properti Warna didefinisikan di akhir kelas, memberikan akses ke variabel warna.

Selain itu, kelas Mobil kita mendefinisikan konstruktor. Dibutuhkan sebuah parameter yang memungkinkan kita untuk menginisialisasi objek dengan warna mobil. Karena hanya ada satu konstruktor, objek mobil hanya dapat dipakai dengan warna. Jelaskan metode () memungkinkan kita untuk mendapatkan sebuah pesan yang bagus dengan sepotong informasi yang kita merekam sekitar kita. Ini hanya mengembalikan sebuah string dengan informasi yang kami sediakan.

Sekarang, dalam aplikasi utama kami, kami mendeklarasikan variabel dari jenis Mobil. Setelah itu, kita membuat sebuah instance baru itu, dengan "Merah" sebagai parameter. Menurut kode kelas kami, ini berarti bahwa warna merah akan ditugaskan sebagai warna mobil. Untuk memverifikasi ini, kita sebut Jelaskan () metode, dan untuk menunjukkan betapa mudahnya kita dapat menciptakan beberapa contoh dari kelas yang sama, kami melakukannya lagi, tapi dengan warna lain. Kami baru saja menciptakan kelas fungsional kami dan menggunakannya.

Dalam bab-bab berikut, konsep-konsep seperti sifat, konstruktor dan visibilitas akan dijelaskan secara lebih mendalam.

13.POPERTI PADA C# ( C SHARP ) Properti memungkinkan Anda untuk mengontrol aksesibilitas dari variabel kelas, dan merupakan cara yang direkomendasikan untuk mengakses variabel dari luar dalam bahasa pemrograman berorientasi objek seperti C #. Dalam bab tentang kelas, kami melihat penggunaan properti untuk pertama kalinya, dan konsep ini sebenarnya cukup sederhana. Properti adalah seperti kombinasi dari variabel dan metode - tidak dapat mengambil parameter apapun, tetapi Anda dapat memproses nilai sebelum itu ditugaskan untuk kembali kita. Properti terdiri dari 2 bagian, mendapatkan dan metode ditetapkan, dibungkus dalam properti: swasta String warna;

publik string yang Warna { mendapatkan {color kembali;} himpunan {color = nilai;} } Metode mendapatkan harus kembali variabel, sedangkan metode yang ditetapkan harus menetapkan sebuah nilai ke dalamnya. Contoh kami adalah yang sederhana karena mendapat, tetapi dapat diperpanjang. Hal lain yang harus tahu tentang sifat-sifat adalah kenyataan bahwa hanya satu metode diperlukan - baik mendapatkan atau mengatur, yang lain adalah opsional. Hal ini memungkinkan Anda untuk menentukan sifat readonly dan menulis-hanya. Berikut adalah contoh yang lebih baik tentang mengapa sifat berguna: publik string yang Warna { mendapatkan { kembali color.ToUpper (); } mengatur { if (nilai == "Red")

color = nilai; lain Console.WriteLine ("Mobil ini hanya dapat merah!"); } } Oke, kita telah membuat properti kita sedikit lebih maju. Variabel warna sekarang akan dikembalikan dalam karakter huruf besar, karena kita menerapkan ToUpper () metode untuk itu sebelum kembali, dan ketika kita mencoba untuk mengatur warna, hanya nilai "Merah" akan diterima. Tentu, contoh ini tidak mengerikan berguna, tapi itu menunjukkan potensi properti.

14.KONSTRUKTOR DAN DESTRUKTOR Konstruktor adalah metode khusus, digunakan ketika instantiate kelas. Sebuah konstruktor tidak pernah dapat kembali apa-apa, yang mengapa Anda tidak harus mendefinisikan jenis kembali untuk itu. Sebuah metode yang normal didefinisikan seperti ini: Jelaskan string publik () Sebuah konstruktor dapat didefinisikan seperti ini: publik Mobil () Dalam contoh kami untuk bab ini, kami memiliki kelas Mobil, dengan konstruktor yang mengambil string sebagai argumen. Tentu saja, konstruktor dapat kelebihan beban juga, artinya kita dapat memiliki beberapa konstruktor, dengan nama yang sama, tetapi parameter yang berbeda. Berikut adalah suatu contoh: publik Mobil () {

publik Mobil (warna string) { this.color = warna; } Konstruktor dapat panggilan lain konstruktor, yang dapat berguna dalam beberapa situasi. Berikut adalah suatu contoh: publik Mobil () { Console.WriteLine ("Konstruktor tanpa parameter yang disebut!"); }

publik Mobil (warna string): ini ()

{ this.color = warna; Console.WriteLine ("Konstruktor dengan parameter warna yang disebut!"); } Jika Anda menjalankan kode ini, Anda akan melihat bahwa konstruktor tanpa parameter yang disebut pertama. Ini dapat digunakan untuk instantiate obyek berbagai kelas di konstruktor default, yang dapat dipanggil dari konstruktor dari kelas lain. Jika konstruktor Anda ingin menelepon mengambil parameter, Anda dapat melakukannya juga. Berikut ini adalah contoh sederhana: publik Mobil (warna string): ini () { this.color = warna; Console.WriteLine ("Konstruktor dengan parameter warna yang disebut!"); }

publik Mobil (string param1, param2 String): ini (param1) {

} Jika Anda memanggil konstruktor yang mengambil 2 parameter, parameter pertama akan digunakan untuk memanggil konstruktor yang mengambil 1 parameter. Destructors

Karena C # adalah sampah dikumpulkan, meaing bahwa kerangka akan membebaskan objek yang Anda gunakan tidak lagi, mungkin ada saat di mana Anda perlu melakukan beberapa pembersihan manual. Sebuah destructor, sebuah metode dipanggil sekali objek dibuang, dapat digunakan untuk pembersihan sumber daya yang digunakan oleh objek. Destructors tidak terlihat sangat banyak seperti metode lain dalam C #. Berikut adalah contoh dari sebuah destructor untuk kelas Mobil kami: ~ Mobil ()

{ Console.WriteLine ("Out .."); } Setelah objek yang dikumpulkan oleh kolektor sampah, metode ini disebut.

15.METODE OVERLOADING Banyak bahasa pemrograman mendukung teknik yang disebut default / parameter opsional. Hal ini memungkinkan programmer untuk membuat satu atau beberapa parameter opsional, dengan memberi mereka nilai default. Ini terutama praktis saat menambahkan fungsi ke kode yang ada. Misalnya, Anda mungkin ingin menambahkan fungsi ke fungsi yang ada, yang membutuhkan satu atau lebih parameter yang akan ditambahkan. Dengan demikian, Anda akan memecahkan kode yang ada memanggil fungsi ini, karena mereka sekarang akan tidak melewati jumlah yang diperlukan parameter. Untuk bekerja di sekitar ini, Anda bisa menentukan parameter baru ditambahkan sebagai opsional, dan memberi mereka nilai default yang sesuai dengan bagaimana kode akan bekerja sebelum menambahkan parameter.

Seperti tulisan ini, C # tidak mendukung parameter default. Mereka telah diumumkan untuk C # versi 4.0, tetapi sampai itu, C # coders telah menggunakan teknik yang berbeda, yang pada dasarnya tidak metode yang sama, yang disebut overloading. Hal ini memungkinkan programmer melakukan define beberapa metode dengan nama yang sama, selama mereka mengambil satu set yang berbeda dari parameter. Bila Anda menggunakan kelas dari kerangka. NET, Anda akan segera menyadari bahwa overloading metode yang digunakan di semua tempat. Sebuah contoh yang baik dari ini, adalah metode Substring () dari kelas String. Hal ini dengan kelebihan beban tambahan, seperti ini: String Substring (int startIndex) String Substring (int startIndex, int length) Anda dapat menyebutnya dengan satu atau dua parameter. Jika Anda hanya menyebutnya dengan satu parameter, parameter panjang diasumsikan sisa string, menyelamatkan kita waktu setiap kali kita hanya ingin mendapatkan bagian terakhir dari string.

Jadi, dengan mendefinisikan beberapa versi dari fungsi yang sama, bagaimana kita menghindari kode yang sama beberapa tempat? Ini sebenarnya cukup sederhana: Kami biarkan versi sederhana dari metode ini membuat versi yang kompleks itu melakukan semua pekerjaan. Perhatikan contoh berikut: kelas SillyMath { Ditambah int publik statis (int number1, number2 int)

{ kembali Plus (number1, number2, 0); }

Ditambah int publik statis (int number1, number2 int, int number3) { kembali angka1 + + number3 number2; } } Kami mendefinisikan sebuah metode Plus, dalam dua versi yang berbeda. Yang pertama mengambil dua paramaters, untuk menambahkan dua angka, sedangkan versi kedua mengambil tiga nomor. Pekerjaan yang sebenarnya dilakukan dalam versi yang mengambil tiga nomor - jika kita hanya ingin menambahkan dua, kita sebut versi tiga parameter, dan hanya menggunakan 0 sebagai paramater ketiga, bertindak sebagai nilai default. Aku tahu, aku tahu, itu contoh konyol, seperti ditunjukkan oleh nama kelas, tetapi harus memberikan Anda sebuah ide tentang bagaimana semuanya bekerja. Sekarang, setiap kali Anda merasa ingin melakukan matematika canggih dengan menambahkan total empat angka (hanya bercanda di sini), itu sangat sederhana untuk menambahkan overload baru: kelas SillyMath { Ditambah int publik statis (int number1, number2 int) { kembali Plus (number1, number2, 0); }

Ditambah int publik statis (int number1, number2 int, int number3) { kembali Plus (number1, number2, number3, 0); }

public static int Plus (int number1, number2 int, int number3, int number4) { kembali angka1 + number2 + + number4 number3; } } Hal keren tentang ini, adalah bahwa semua panggilan yang ada dengan metode Plus akan terus bekerja, seolah-olah tidak pernah berubah. Semakin banyak Anda menggunakan C #, semakin Anda akan belajar untuk menghargai metode overloading.

16.VISIBILITAS Visibilitas kelas, metode, variabel atau properti memberitahu kita bagaimana item ini dapat diakses. Jenis yang paling umum dari visibilitas yang pribadi dan publik, tetapi sebenarnya ada beberapa jenis lainnya visibilitas dalam C #. Berikut adalah daftar lengkap, dan meskipun beberapa dari mereka mungkin tidak merasa bahwa relevan bagi Anda sekarang, Anda selalu dapat kembali ke halaman ini dan membaca tentang mereka:

masyarakat - anggota dapat dicapai dari mana saja. Ini adalah visibilitas paling restriktif. Enum dan interface adalah, secara default, publik terlihat.

dilindungi - hanya anggota yang dapat dicapai dari dalam kelas yang sama, atau dari sebuah kelas yang mewarisi dari kelas ini.

internal - anggota dapat dicapai dari dalam proyek yang sama saja.

dilindungi internal - sama sebagai internal, kecuali yang juga kelas yang mewarisi dari kelas ini bisa mencapai itu anggota, bahkan dari proyek lain.

swasta - hanya dapat dicapai oleh anggota dari kelas yang sama. Ini adalah visibilitas paling ketat. Kelas dan struct adalah dengan default diatur ke visibilitas pribadi.

Jadi misalnya, jika Anda memiliki dua kelas, Class1 dan class2, anggota pribadi dari Class1 hanya dapat digunakan dalam Class1. Anda tidak dapat membuat sebuah instance baru dari Class1 dalam class2, dan kemudian berharap untuk dapat menggunakan anggota pribadi.

Jika class2 mewarisi dari Class1, maka hanya anggota non-swasta dapat dicapai dari dalam class2.

17.STATIC MEMBER Seperti kita lihat dalam bab sebelumnya, cara yang biasa untuk berkomunikasi dengan kelas, adalah untuk membuat sebuah instance baru dari kelas, dan kemudian bekerja pada objek yang dihasilkan. Dalam kebanyakan kasus, ini adalah apa kelas adalah semua tentang - kemampuan untuk instantiate beberapa salinan dari kelas yang sama dan kemudian menggunakannya berbeda dalam beberapa cara. Namun, dalam beberapa kasus, Anda mungkin ingin memiliki kelas yang Anda dapat menggunakan tanpa instantiate itu, atau setidaknya kelas mana Anda dapat menggunakan anggota tanpa menciptakan sebuah objek untuk itu. Misalnya, Anda mungkin memiliki kelas dengan variabel yang selalu tetap sama, tidak peduli di mana dan bagaimana itu digunakan. Ini disebut anggota statis, statis karena itu tetap sama.

Sebuah kelas dapat statis, dan dapat memiliki anggota statis, kedua fungsi dan bidang. Sebuah kelas statis tidak dapat instantiated, sehingga dalam kata lain, ia akan bekerja lebih sebagai pengelompokan anggota terkait dari kelas yang sebenarnya. Anda dapat memilih untuk menciptakan sebuah kelas non-statis bukan, tetapi biarlah itu memiliki anggota statis tertentu. Sebuah kelas non-statis masih dapat dipakai dan digunakan seperti kelas biasa, tetapi Anda tidak dapat menggunakan anggota statis pada sebuah objek dari kelas. Sebuah kelas statis hanya dapat berisi anggota statis.

Pertama, di sini adalah contoh dari kelas statis: public class Rectangle statis { public static int CalculateArea (int lebar, int tinggi) { kembali tinggi lebar *; } } Seperti yang Anda lihat, kita menggunakan kata kunci statis untuk menandai kelas sebagai statis, dan kemudian kita menggunakannya lagi untuk menandai metode, CalculateArea, sebagai statis juga. Jika kita tidak melakukan itu, compiler akan mengeluh, karena kita tidak dapat memiliki anggota non-statis dari kelas statis.

Untuk menggunakan metode ini, kita sebut secara langsung di kelas, seperti ini: Console.WriteLine ("Daerah ini adalah:" + Rectangle.CalculateArea (5, 4)); Kita bisa menambahkan metode lain untuk membantu kelas Rectangle, tapi mungkin Anda bertanya-tanya mengapa kita menyampaikan lebar dan tinggi untuk metode yang sebenarnya, daripada menyimpannya di dalam kelas dan kemudian menarik mereka dari sana bila diperlukan? Karena itu statis! Kita bisa menyimpan mereka, tetapi hanya satu set dimensi, karena hanya ada satu versi dari kelas statis. Hal ini sangat penting untuk memahami.

Sebaliknya, kita dapat membuat kelas non-statis, dan kemudian memiliki CalculateArea sebagai fungsi utilitas di kelas ini: public class Rectangle { swasta int lebar, tinggi;

publik Rectangle (int lebar, int tinggi) { this.width = lebar; this.height = tinggi; }

public void OutputArea () { Console.WriteLine this.height)); } ("output Area:" + Rectangle.CalculateArea (this.width,

public static int CalculateArea (int lebar, int tinggi) {

kembali tinggi lebar *; } } Seperti yang Anda lihat, kami telah membuat kelas non-statis. Kami juga telah menambahkan sebuah konstruktor, yang membutuhkan lebar dan tinggi dan memberikan ke instance. Kemudian kami telah menambahkan metode OutputArea, yang menggunakan metode statis untuk menghitung daerah. Ini adalah contoh yang bagus pencampuran anggota statis dengan non-statis anggota, di kelas non-statis.

Sebuah penggunaan umum dari kelas statis, meskipun disukai oleh beberapa orang, adalah utilitas / penolong kelas, di mana Anda mengumpulkan sekelompok metode yang berguna, yang tidak mungkin milik bersama, tetapi tidak benar-benar tampaknya cocok di tempat lain baik.

18.INHERITANCE Salah satu aspek kunci mutlak dari Pemrograman Berorientasi Objek (OOP), yang merupakan konsep bahwa C # adalah dibangun di atas, adalah warisan, kemampuan untuk membuat kelas yang mewarisi aspek-aspek tertentu dari kelas induk. Seluruh kerangka NET. Dibangun di atas konsep ini, dengan "segala sesuatu adalah obyek" sebagai akibat dari itu. Bahkan sejumlah sederhana adalah sebuah instance dari kelas, yang mewarisi dari kelas System.Object, meskipun NET membantu. Anda keluar sedikit, sehingga Anda dapat menetapkan nomor secara langsung, daripada harus membuat sebuah instance baru dari misalnya kelas integer.

Mata kuliah ini dapat sedikit sulit untuk dipahami, tapi kadang-kadang membantu dengan beberapa contoh, jadi mari kita mulai dengan yang sederhana dari mereka: masyarakat kelas Hewan { Sapa public void () { Console.WriteLine ("Halo, aku semacam binatang!"); } }

public class Dog: Hewan {

} Pertama, kita mendefinisikan kelas Hewan, dengan metode sederhana untuk output salam. Kemudian kita mendefinisikan kelas Anjing, dan dengan usus, kita katakan C # bahwa kelas Anjing harus mewarisi dari kelas Hewan. Hal yang indah tentang hal ini adalah bahwa hal itu masuk akal di dunia nyata juga - Anjing adalah, jelas, Animal. Mari kita coba menggunakan kelas: Hewan hewan Hewan = baru (); animal.Greet ();

Anjing Anjing Anjing = baru (); dog.Greet (); Jika Anda menjalankan contoh ini, Anda akan melihat bahwa meskipun kita belum mendefinisikan metode Menyapa () untuk kelas Anjing, masih tahu bagaimana menyambut kami, karena mewarisi metode dari kelas Hewan. Namun, ucapan ini agak anonim, jadi mari kita menyesuaikan ketika kita tahu mana binatang itu adalah: masyarakat kelas Hewan { Sapa kekosongan maya publik () { Console.WriteLine ("Halo, aku semacam binatang!"); } }

public class Dog: Hewan { public void menimpa Sapa () { Console.WriteLine ("Halo, saya seekor anjing!"); } } Selain metode ditambah pada kelas Anjing, Anda harus memperhatikan dua hal: saya telah menambahkan kata kunci virtual untuk metode pada kelas Hewan, dan pada kelas Anjing, saya menggunakan kata kunci menimpa. Dalam C #, Anda tidak diizinkan untuk menimpa anggota kelas kecuali itu ditandai sebagai virtual. Jika Anda ingin, Anda masih dapat mengakses metode warisan, bahkan ketika Anda mengabaikan hal itu, dengan menggunakan kata kunci dasar. public void menimpa Sapa () { base.Greet ();

Console.WriteLine ("Ya saya - anjing!"); } Metode ini bukan satu-satunya untuk mendapatkan warisan, sekalipun. Bahkan, hampir semua anggota kelas akan diwariskan, termasuk bidang dan properti. Hanya ingat aturan visibilty, seperti yang dibahas dalam bab sebelumnya.

Warisan ini tidak hanya dari satu kelas ke yang lain - Anda dapat memiliki seluruh hirarki kelas, yang mewarisi dari eachother. Sebagai contoh, kita bisa menciptakan sebuah kelas Puppy, yang mewarisi dari kelas Dog kami, yang pada gilirannya mewarisi dari kelas Hewan. Apa yang tidak dapat Anda lakukan dalam C #, adalah membiarkan satu kelas mewarisi dari kelas lain pada saat yang sama. Multiple inheritance, seperti disebut, tidak didukung oleh C #.

19.ABSTRACT CLASSES Kelas abstrak, ditandai dengan abstrak kata kunci dalam definisi kelas, biasanya digunakan untuk mendefinisikan kelas dasar dalam hirarki. Apa yang khusus tentang mereka, adalah bahwa Anda tidak dapat membuat sebuah instance dari mereka - jika Anda mencoba, Anda akan mendapatkan error kompilasi. Sebaliknya, Anda harus subclass mereka, sebagaimana diajarkan dalam bab tentang warisan, dan menciptakan sebuah instance dari subclass Anda. Jadi, ketika Anda perlu kelas abstrak? Itu benarbenar tergantung pada apa yang Anda lakukan. Untuk menjadi jujur, Anda bisa pergi jauh tanpa perlu kelas abstrak, tetapi mereka yang besar untuk hal-hal tertentu, seperti kerangka, yang mengapa Anda akan menemukan cukup banyak kelas abstrak dalam NET framework itu sendiri.. Aturan praktis yang baik adalah bahwa nama sebenarnya masuk akal benar-benar baik - kelas abstrak yang sangat sering, jika tidak selalu, digunakan untuk menggambarkan sesuatu yang abstrak, sesuatu yang lebih dari sebuah konsep dari hal yang nyata.

Dalam contoh ini, kita akan menciptakan kelas dasar untuk binatang berkaki empat dan kemudian membuat kelas Anjing, yang mewarisi dari itu, seperti ini:

namespace AbstractClasses { Program kelas { static void Main (string [] args) { Anjing Anjing Anjing = baru (); Console.WriteLine (dog.Describe ()); Console.ReadKey (); } }

abstract class FourLeggedAnimal {

String maya publik Jelaskan () { kembali "Tidak banyak yang diketahui mengenai hewan berkaki empat!"; } }

Anjing kelas: FourLeggedAnimal {

} }

Jika anda membandingkannya dengan contoh-contoh dalam bab tentang warisan, Anda tidak akan melihat perbedaan besar. Bahkan, kata kunci abstrak di depan definisi FourLeggedAnimal adalah perbedaan terbesar. Seperti yang Anda lihat, kita membuat sebuah instance baru dari kelas Anjing dan kemudian memanggil metode mewarisi Jelaskan () dari kelas FourLeggedAnimal. Sekarang coba menciptakan sebuah instance dari kelas FourLeggedAnimal gantinya:

FourLeggedAnimal someAnimal = baru FourLeggedAnimal ();

Anda akan mendapatkan error ini kompilator halus:

Tidak dapat membuat sebuah instance dari kelas abstrak atau antarmuka 'AbstractClasses.FourLeggedAnimal'

Sekarang, karena Anda dapat melihat, kita hanya mewarisi Jelaskan () metode, tetapi tidak sangat berguna dalam bentuk yang sekarang ini, untuk kelas Anjing kami. Mari kita menimpanya:

Anjing kelas: FourLeggedAnimal { public override string yang Jelaskan () { kembali "ini adalah hewan berkaki empat Anjing!"; } }

Dalam kasus ini, kita melakukan menimpa lengkap, namun dalam beberapa kasus, Anda mungkin ingin menggunakan perilaku dari kelas dasar di samping fungsi baru. Hal ini dapat dilakukan dengan menggunakan kata kunci dasar, yang mengacu pada kelas yang kita warisi dari:

abstract class FourLeggedAnimal { String maya publik Jelaskan () { kembali "Hewan ini memiliki empat kaki."; } }

Anjing kelas: FourLeggedAnimal { public override string yang Jelaskan () { Hasil base.Describe string = (); hasil + = "Bahkan, itu anjing!";

kembali hasil; } }

Sekarang jelas, Anda dapat membuat subclass lain dari kelas FourLeggedAnimal mungkin kucing atau singa? Dalam bab berikutnya, kita akan melakukan contoh yang lebih maju dan memperkenalkan metode abstrak juga. Baca terus.

20.MORE ABSTRACT CLASSES Dalam bab sebelumnya, kita telah melihat kelas abstrak. Dalam bab ini, kita akan memperluas sedikit contoh, dan melemparkan dalam beberapa metode abstrak juga. Metode abstrak hanya diperbolehkan dalam kelas abstrak. Definisi mereka akan terlihat seperti metode biasa, tetapi mereka tidak memiliki kode di dalamnya:

abstract class FourLeggedAnimal { String abstrak publik Jelaskan (); }

Jadi, mengapa anda ingin mendefinisikan metode kosong yang tidak apa-apa? Karena metode abstrak adalah kewajiban untuk implent bahwa metode yang sangat dalam semua subclass. Bahkan, itu diperiksa pada waktu kompilasi, untuk memastikan bahwa subclass Anda memiliki metode ini didefinisikan. Sekali lagi, ini adalah cara yang hebat untuk membuat basis kelas untuk sesuatu, sementara masih mempertahankan sejumlah kendali atas apa yang subclass harus mampu melakukannya. Dengan ini dalam pikiran, Anda selalu dapat memperlakukan subclass sebagai baseclass, setiap kali Anda perlu menggunakan metode didefinisikan sebagai metode abstrak pada baseclass tersebut. Sebagai contoh, pertimbangkan contoh berikut:

namespace AbstractClasses { Program kelas { static void Main (string [] args) { System.Collections.ArrayList animalList = baru System.Collections.ArrayList (); animalList.Add (baru Anjing ()); animalList.Add (Cat baru ()); foreach (hewan FourLeggedAnimal di animalList)

Console.WriteLine (animal.Describe ()); Console.ReadKey (); } }

abstract class FourLeggedAnimal { String abstrak publik Jelaskan (); }

Anjing kelas: FourLeggedAnimal {

public override string yang Jelaskan () { kembali "Aku seekor anjing!"; } }

Kelas Cat: FourLeggedAnimal { public override string yang Jelaskan () { kembali "Aku kucing!"; } }

Seperti yang Anda lihat, kita membuat sebuah ArrayList untuk mengandung hewan kami. Kami kemudian instantiate anjing baru dan seekor kucing baru dan menambahkannya ke daftar. Mereka dipakai sebagai Anjing dan Cat yang masingmasing, tetapi mereka juga dari FourLeggedAnimal jenis, dan karena compiler tahu bahwa subclass dari kelas yang berisi Jelaskan () metode, Anda benar-benar diperbolehkan untuk memanggil metode tersebut, tanpa mengetahui persis jenis hewan. Jadi dengan typecasting ke FourLeggedAnimal, yang adalah apa yang kita lakukan dalam loop foreach, kita mendapatkan akses ke anggota subclass. Ini dapat sangat berguna dalam banyak skenario.

21.INTERFACES Dalam bab-bab sebelumnya, kita telah melihat kelas abstrak. Interface seperti kelas abstrak dan mereka berbagi fakta bahwa tidak ada contoh dari mereka dapat dibuat. Namun, interface bahkan lebih konseptual dari kelas abstrak, karena tidak ada metode yang diizinkan tubuh sama sekali. Jadi antarmuka adalah jenis seperti kelas abstrak dengan apa-apa tetapi metode abstrak, dan karena tidak ada metode dengan kode yang sebenarnya, tidak ada kebutuhan untuk setiap bidang. Properti diperbolehkan meskipun, serta pengindeks dan acara. Anda dapat mempertimbangkan sebuah antarmuka sebagai sebuah kontrak - sebuah kelas yang mengimplementasikannya diperlukan untuk mengimplementasikan semua metode dan properti. Namun, perbedaan yang paling penting adalah bahwa sementara C # tidak memungkinkan multiple inheritance, dimana kelas mewarisi lebih dari kelas dasar tunggal, sebenarnya tidak memungkinkan untuk pelaksanaan beberapa interface!

Jadi, bagaimana semua ini terlihat dalam kode? Berikut adalah contoh yang cukup lengkap. Melihat-lihat, mungkin mencobanya sendiri, dan kemudian baca terus untuk penjelasan lengkap:

using System; menggunakan System.Collections.Generic;

namespace Antarmuka { Program kelas { static void Main (string [] args) { Daftar <Dog> anjing = Daftar <Dog> baru (); dogs.Add (Anjing yang baru ("Fido")); dogs.Add (Anjing yang baru ("Bob")); dogs.Add (Anjing yang baru ("Adam")); dogs.Sort ();

foreach (Anjing anjing pada anjing) Console.WriteLine (dog.Describe ()); Console.ReadKey (); } }

antarmuka IAnimal { Jelaskan String ();

String Nama { mendapatkan; ditetapkan; } }

Anjing kelas: IAnimal, IComparable { swasta String nama;

Anjing publik (string name) { this.Name = nama; }

Jelaskan string publik ()

{ kembali "Halo, saya seekor anjing dan nama saya adalah" + this.Name; }

public int compareTo (obj) { if (obj IAnimal) kembali this.Name.CompareTo ((obj sebagai IAnimal) Nama.); return 0; }

Nama String publik { mendapatkan {return;} himpunan {nama nilai =;} } } }

Mari kita mulai di tengah, di mana kita menyatakan antarmuka. Seperti yang Anda lihat, perbedaan hanya dari deklarasi kelas, adalah kata kunci yang digunakan - antarmuka bukan kelas. Juga, nama antarmuka diawali dengan I untuk Interface - ini hanyalah sebuah standar coding, dan bukan keharusan. Anda dapat memanggil antarmuka Anda apapun yang Anda inginkan, tapi karena mereka digunakan seperti kelas begitu banyak bahwa Anda mungkin memiliki waktu sulit mengatakan perbedaan di beberapa bagian dari kode Anda, awalan saya masuk akal cukup bagus.

Kemudian kita mendeklarasikan metode Jelaskan, dan setelah itu, properti Nama, yang memiliki baik mendapatkan dan mengatur kata kunci, membuat ini dibaca dan ditulisi properti. Anda juga akan melihat kurangnya pengubah akses (public, private, dll

dilindungi), dan itu karena mereka tidak diperbolehkan dalam interface - mereka semua publik secara default.

Berikutnya adalah kelas Anjing kita. Perhatikan bagaimana terlihat seperti mewarisi dari kelas lain, dengan usus antara nama kelas dan antarmuka kelas / sedang subclassed / dilaksanakan. Namun, dalam kasus ini, dua interface diimplementasikan untuk kelas yang sama, hanya dipisahkan dengan koma. Anda dapat mengimplementasikan antarmuka sebanyak yang Anda mau, tetapi dalam kasus ini kita hanya menerapkan dua - antarmuka IAnimal kita sendiri, dan antarmuka IComparable NET, yang adalah antarmuka bersama untuk kelas yang dapat diurutkan.. Sekarang seperti yang Anda lihat, kami telah menerapkan kedua metode dan properti dari antarmuka IAnimal, serta metode compareTo dari antarmuka IComparable.

Sekarang Anda mungkin berpikir: Jika kita harus melakukan semua pekerjaan diri kita, dengan menerapkan seluruh metode dan properti, mengapa repot-repot? Dan contoh yang sangat baik mengapa itu layak waktu Anda, diberikan di bagian atas contoh kita. Di sini, kita menambahkan sekelompok objek Anjing ke daftar, dan kemudian kita menyortir daftar. Dan bagaimana daftar tahu bagaimana untuk mengurutkan anjing? Karena kelas Anjing kami memiliki metode compareTo yang dapat memberitahu bagaimana membandingkan dua anjing. Dan bagaimana daftar tahu bahwa benda Anjing kita dapat melakukan hal itu, dan yang metode untuk panggilan untuk mendapatkan anjing dibandingkan? Karena kita mengatakan begitu, dengan mengimplementasikan interface yang menjanjikan metode compareTo! Ini adalah keindahan nyata dari interface.

DAFTAR PUSTAKA
http://csharp.net-tutorials.com