0

Dasar C#

Posted by jujur on 3:18 AM

Dasar C#

Daftar isi
  • Pendahuluan
  • Struktur dasar Program C#
  • Class
  • Class Member
  • Static Class Member
  • Konstanta dan readonly
  • Objek
  • Method
  • Constructor
  • Akses Modifier
  • Properties
  • Namespace dan using
  • Parameter Method
  • Method Overloading
  • Overload Constructor
  • Komposisi
  • Penggunaan referensi “this”
  • Inheritance (pewarisan)
  • Class Abstrak
  • Method abstrak
  • Method Virtual
  • Menyembunyikan method class induk dgn keyword “new”
  • Polymorphisme
  • Event dan delegate
  • Interface
  • Network programming
  • Database Programming
  • Array dan collection
Pendahuluan
Untuk memahami pemrograman  C#   kita wajib mengerti konsep dasar pemrograman berorientasi  Object(PBO). Konsep PBO pada C# pada dasarnya sama  dengan yg diterapkan pada  C++ ,VB.Net, JAVA, dll.
Sekilas gambaran tentang pemrograman berorientasi  Object(PBO)  sudah saya tulis pada artikel disini . Artikel tsb berisi penjelasan buat pembaca yg baru sama sekali yg ingin mengetahui apa itu pemrograman berorientasi objek.
Ada 3 jenis aplikasi C#  untuk  yang bisa kita buat
1. Aplikasi konsol
2. Aplikasi Visual
3. Aplikasi Class library.
4. Aplikasi WPF
Pelajaran dasar pemrograman C#  biasanya menggunakan aplikasi konsol supaya kita fokus kepada kode programnya saja.
Struktur dasar Program C#
Secara hirarki Program C# terdiri dari Namespace-> class-> method dan data
1
2
3
4
5
6
7
8
namespace
{
   class
    {
      data
      method
    }
}
Langsung saja kita lihat contoh program C#  paling sederhana  :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace test
{
  class Clscontoh
    {
 
      string  pesan =" halo apa kabar";       // data
 
      static void Main(string[] args)         // method
       {
       Console.WriteLine(pesan);
       }
 
   }     //penutup class
}        // penutup namespace scope
Penjelasan program 
Program C#  minimal harus terdiri dari 1 class dan 1 methode Main().
Contoh diatas terdiri dari 1  class   dgn nama Clscontoh  dan  ClsContoh mempunya 1   methode   Main().
Langkah-langkah  kompilasi / menjalankan program diatas :
1.  Ketik program diatas   pada  notepad  dan simpan  dengan nama ex1.cs  (nama terserah yg penting berextensi *.cs)
2.  Pada prompt dos ketik  c:>csc  ex1.cs
3.  Untuk menjalankanya ketik c:>ext1.exe
Program C#  terbentuk dari class  sedangkan program  C terdiri dari fungsi fungsi.
Untuk menyederhanakan program yg bersekala besar adalah dengan cara memecah program menjadi bagian/modul modul  yg lebih kecil, bentuk Modul tersebut diantaranya adalah class dan method. Sebuah aplikasi biasanya terbagi menjadi 3 modul atau layer yaitu user interface, proses dan koneksi database. Tiap tiap modul/layer mempunyai class nya masing masing. Class class tsb bisa menggunakan class yg sudah ada baik yg tersedia (di class library maupun yg dibuat oleh pengguna yg lain) atau kita sendiri yang membuatnya.
Class
Semua code dalam C# harus berada dalam class  dan tiap class terdiri dari  data  dan method .Method dan data disebut juga sebagai  member Class .  Data dalam class dimanipulasi melalui method . data disebut juga member variable atau instance variable.  instance variable dideklarasikan di luar method.
Class Member
Class  terdiri dari beberapa member/anggota antara lain
-Fields
-Constants
-Properties
-Methods
-Constructors
-Destructors
-Events
-Indexers
-Operators
-Nested Types
Setiap kelas tdk harus tersusun dari semua member class diatas, pada umumnya class yg akan kita pakai hanya terdiri dari constructor,property dan method.
Static Class Member
Static class member adalah member class yg diakses melalui class tdk melalui objek. jadi seolah oleh member static bersifat global di semua objek.  Jika  instance  variable  static  maka tiap objek mempunyai  instance variable yg sama.  Sebaliknya  pada  instance variable yg  bukan static maka tiap objek mempunyai salinan  (instance variable) masing masing.
Contoh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
namespace gamepesawat
{
    class peswatTempur
      {
       public string namaPilot;
       public static int TotalTertembak=0;
 
       pulic int tembakmusuh()
           {
              TotalTertembak++;
              return TotalTertembak;
           }
 
        }
 
      Class  gamestart()
      {
 
           static void Main(string[] args)     // method Main
           {
             //membuat objek pesawatTempurF16 dan F22
 
              pesawatTempur F16 = new pesawatTempur();
              pesawatTempur F22 = new pesawatTempur();
 
              F16.namaPilot = "fatih";
              F16.tembak();
 
              F16.namaPilot= "dede";
              F16.tembak();
// mengakses statik variable totalTertembak dgn nama class pesawattempur bukan nama objek
           system.console.writeln("total tertembak={0}" pesawatTempur.TotalTertembak)
            }
      }
}
Dari contoh diatas kita bisa melihat bahwa static instance variable TotalTertembak adalah hanya ada 1 dan mempunyai nilai sama disemua objek dan cara mengaksesnya melalui nama class.  jika kita mencoba mengakses dgn  referensi objek  spt  F16.totalTertembak akan menyebabkan error saat dikompilasi.
Konstanta dan Readonly
Member class berupa konstanta di inisialisasi hanya sekali yaitu saat program dicompile. konstanta secara implisit adalah static member yaitu hanya ada satu nilai pada semua objek.
Member class berupa readonly inisialisasinya bisa beberapa kali pada programya yaitu tiap objek dibuat. Readonly di inisialisasi lewat constructor.
contoh
1
2
3
4
5
6
7
8
9
10
public class lingkaran
{
    public const double pi=3.14;
    public readonly double diameter;
 
     public lingkaran(double setdiameter)
     {
       diameter = setdiameter;
      }
}
Saat program dicompile nilai pi diinisialisasi yaitu tetap 3.14  selama program berjalan, sedangkan untuk nilai diameter setiap objek dibuat nilai readonly bisa diinisiaisasi.
Objek
Setelah class dibuat maka yg digunakan dalam program adalah objek dari class. cara membuat objek dari class (instance) adalah sbb:
class objek = new class.
misal nya kita buat class kalkulator dan sebuah method jumlah(int a, int b) dlm class tsb dan objek yg kita buat adalah casio
kalkulator casio = new kalkulator
untuk penggunaan objek casio tsb dgn cara :
hasil = casio.jumlah(2,3)
contoh konkritnya ada di bagian bawah artikel.
Method
Method   mirip   seperti fungsi , yaitu  potongan kode yg melaksanakan tugas tertentu  ,  method mempunyai  format sbb:
akses modifier-return_type-nama_method (parameter)
{
badan method
}
contoh method :
public int jumlah(int bil1, int bil2)
{
return bil1 + bil2;
}
contoh method tanpa return value :
public void tampilkanhasil(int hasil)
{
System.Console.WriteLine(“hasil operasi = {0}”, hasil);
}
Ringkasan hal hal yang terkait dgn method:
– methode terdiri dari header dan body method
– method bisa memiliki return value bisa juga tidak (ditandai dgn void)
– method bisa memiliki 1 atau lebih parameter
– method bisa memiliki parameter objek dan array.
– variable yg dideklarasikan di dlm method bersifat lokal hanya bisa diakses di dlm method saja. jika didalam method ada nama variable yg sama dgn instance variable, maka yg berlaku adalah variable lokal.
– untuk mengakses instance variable yg mempunyai nama yg sama dgn lokal variable gunakan this.nama_instance_variable
– method dlm class yg sama dipanggil dgn menuliskan nama method dan menuliskan argument untuk tiap parameternya. type argument harus sesuai dgn type parameter pada deklarasi method.
– memanggil method pd class yg berbeda menggukana statemen objekreferensi.namaMethod
– method bisa digunakan berulang ulang didalam program
– diusahakan membuat method sesederhana mungkin  dgn satu tugas spesifik.
– diusahakan nama method sesui tugas yg dikerjakan oleh method.
– didalam method tdk boleh ada deklarasi method lain.
– didalam method bisa memanggil method lain
Constructor
Constructor adalah method yg dijalankan setiap kali objek dibuat. Method ini mempunyai ciri ciri:
-nama method sama dgn nama class.
-tidak mempunyai return type.
-akses modifiernya “public”
Salah satu kegunaan constructor adalah untuk inisialisasi kondisi awal objek. Jika kita tdk membuat constructor maka secara otomatis C# akan membuatkan secara default tapi constructor tsb tdk melaksanakan apapaun .
contoh constructor:
1
2
3
4
5
6
7
8
class termometer
}
   public termometer() // constructor
   {
 
   }
 
}
Akses Modifier
Akses  modifier  mendefinisikan ruang lingkup pengaksesan  member class  .  Dari mana saja method dan instance variable bisa diakses , bisa diatur melalui  akses  modifier ini. Ada 4  akses modifier tapi untuk tahap awal kita akan membicarakan 2 lebih dahulu yaitu :
1. Public ,  member class  bisa diakses dari semua bagian program .
2. Private , member class hanya bisa diakses dari dlm class
Untuk default akses modifier member class  adalah  private. Sebaiknya data dlm sebuah class tdk bisa diakses langsung dari luar class tapi melalui method. sedangkan method biasanya dibuat public  sehingga bisa dipangggil dari luar class, sedangkan method yg private digunakan hanya dlm class itu sendiri(dipanggil/digunakan oleh method dlm kelas yg sama) sehingga private method disebut “helper method” .
Untuk memanggil method di dlm class yg sama cukup dengan menulis nama method beserta argument tiap parameternya. Sedangkan untuk memanggil method yg mempunyai akses public dari class yg berbeda harus menggunakan format nama_referensi_objek.nama_method.
aksesmodifier
contoh program C# yg terdiri dari 2 class
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
 
class classpertama
{
 
  static void Main(string[] args)
   {
    Console.WriteLine(" Apa kabar1? ")
    classkedua objek1 = new classkedua();
    objek1.tampil();
    Console.WriteLine("data class ke 2 ");
    Console.WriteLine(objek1.usia);
 
    Console.readline()  // supaya console tdk langsung menutup
 
   }
}
 
class  classkedua
{
 
  public int usia =10;
 
   public void tampil()      // akses modifier method ini diset public , supaya bisa diakses dari luar class ini.
    {
     Console.WriteLine("Apa kabar2? ");
    }
 
}
Jika sebuah program C# terdiri banyak class ,eksekusi program akan di mulai pada class yang memiliki methode Main().  Class yg memiliki method main disebut sebagai entry point.
Pada class kedua,  method tampil() akses modifiernya ‘public’  supaya method ini bisa dipangggil dari luar class kelaskedua.
Properties
Pada class kedua contoh diatas, akses modifier data adalah public :
public int usia = 10;
Keadaan ini tidak baik sebab data bisa dirubah dgn mudah dari luar class . misalnya program kita sudah besar dan kompleks bisa terjadi ada baris program yg merubah data tanpa sengaja. Untuk mencegah hal ini maka diatasi dgn cara data(instance variable usia) dibuat menjadi private dan membuat properties yg bertugas mengakses data secara aman.
Anggota class private tidak dapat diakses langsung dari luar class. Akses ke data private harus dikontrol secara hati-hati dengan method dlm class yg sama .
Untuk memungkinkan class lain untuk membaca nilai data private , class dapat mendefinisikan properties yang memungkinkan kode klien untuk mengakses data private ini dengan aman . Propertinya berisi method accessor yang menangani rincian memodifikasi dan menbaca data.
Definisi properti dapat berisi accessor get , accessor set atau keduanya .
– accessor get memungkinkan klien untuk membaca nilai data private ;
– accessor set memungkinkan klien untuk mengubah nilai tersebut.
Properties tampaknya akan melanggar gagasan data private . Namun, accessor set dapat memberikan kemampuan data validasi (seperti pemeriksaan range data yg valid ) untuk memastikan bahwa nilai yg di set benar . Sebuah accessor set juga dapat menerjemahkan antara format data yang digunakan dalam  antarmuka.
Demikian pula, accessor get tidak perlu mengekspos data dalam format aslinya, lebih tepatnya accessor get dapat mengedit data dan membatasi pandangan klien dari data tersebut.
berikut ini contoh property Umur memanipulasi instance variable usia
1
2
3
4
5
6
7
8
9
10
11
12
13
public int Umur
 {
 get
 {
 return usia;
 }
 
 set
 {
 usia = ( ( value >= 17 && value < 55 ) ? value : 0 );
 }
 
 } //
&nbsp;
contoh program lengkapnya:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using System;
 
class classpertama
{
 
  static void Main(string[] args)
   {
    Console.WriteLine(" Apa kabar1? ")
    classkedua objek1 = new classkedua();
    objek1.tampil();
    Console.WriteLine("data class ke 2 ");
    Console.WriteLine(objek.Umur);
  //menset nilai instance variable usia melalui property Umur
     objek1.Umur = 35;
   //tambahkan baris kode berikut supaya ,console tdk close:
    Console.ReadLine();
     }
}
 
class classkedua
{
 
  private int usia =10;
 
public int Umur
 {
 get
 {
 return usia;
 }
 
 set
 {
 usia = ( ( value >= 17 && value < 55 ) ? value : 0 );
 }
 
 } //
   public void tampil()      // akses modifier method ini diset public , supaya bisa diakses dari luar class ini.
    {
     Console.WriteLine("Apa kabar2? ");
    }
 
}
Namespace dan using
Namespace adalah kata kunci yang digunakan untuk mengorganisasikan class class. Pengorganisasian class class pada namespace mirip direktory direktory yg penyimpan file,
1
2
3
4
5
6
7
8
9
10
Namespace  nama_namespace
{
   Class  class1
    {
    }
 
   Class class2
    {
    }
}
class library yg sudah disediakan juga disimpan dlm namespace , untuk menggunakan class yg ada di class library kita harus menyertakan namespace nya dgn perintah “using” contoh:
using  System   :  menyertakan class class utama kedalam program .
Berikut ini  beberapa namespace  yg sudah  tersedia di framework class library (FCL)   :
-System.Data  : Berisi class  yang membentuk ADO NET, digunakan untuk database. akses dan manipulasi.
-System.Drawing : Berisi class yang digunakan untuk menggambar dan grafis.
-System.IO : Berisi class untuk input dan output data, seperti   pada akses  file.
– dan masih banyak lagi..
Aktualnya  framework class library pada C# adalah file file berektensi  *.dll
Namespace Bercabang/berjenjang
Seperti halnya direktory, namespace juga bisa bercabang/berjenjang contoh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespaceA1
 {
 
  namespaceB
   {
     class1
      {
      }
    }
 
    namespaceC
   {
     class2
      {
      }
    }
 
  }
Untuk mengakses/menggunakan class1 dengan cara
using namespaceA.namespaceB
Parameter Method
Di dalam C# ada 3  jenis parameter yaitu   parameter nilai, parameter referensi  dan parameter output.  berikut ini contoh perbedaan parameter nilai   dan parameter referensi:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace testParameter
{
class Program
{
// var1 sbg parameter nilai, var2 sebagai parameter referensi
public static void jumlah(int var1, ref int var2)
{
var1 = var1 + 5;
     var2 = var2 + 5;
}
    static void Main(string[] args)
{
int var1 = 10;
int var2 = 10;
     jumlah(var1, ref var2);
     Console.WriteLine("Nilai var1 = {0}", var1);
    Console.WriteLine("Nilai var2 = {0}", var2);
   }
}
}
Jika program di atas dijalankan akan menghasilkan output sbb:
Nilai var1=10
Nilai var2=15
Kita melihat dari hasil tsb : setelah method  jumlah() dijalankan,    parameter nilai  tdk merubah variabel di luar method sedangkan parameter referensi merubah nilai  variable diluar method.
Contoh C# class calculator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace kalkulator
{
 
  class class_pertama
     {
 
       static void Main(string[] args)
       {
           int hasiljumlah=0;
           int bil1 = 30;i
           int bil2 = 5;
 
//===membuat objek casiocalc ===================
               classkalkulator casiocalc = new classkalkulatorku("casio");
               hasiljumlah = casiocalc.jumlah(bil1 , bil2);
               casiocalc.tampilkanhasil(hasiljumlah);
 
//===membuat objek polytroncalc ================
         classkalkulator polytroncalc = new classkalkulatorku("polytron");
          hasiljumlah = polytroncalc.jumlah(bil1, bil2);
          polytroncalc.tampilkanhasil(hasiljumlah);
 
          System.Console.ReadLine(); // supaya console tdklangsung close
          }
 
         }
 
     class classkalkulatorku
      {
 
        public classkalkulator(string merk) // constructor
          {
          System.Console.WriteLine("=====object dibuat============");
          System.Console.WriteLine("buatan " + merk);
          }
 
       public int jumlah(int bil1, int bil2)
        {
        return bil1 + bil2;
        }
 
        public int kurang(int bil1, int bil2)
        {
        return bil1 - bil2;
        }
 
         public void tampilkanhasil(int hasil)
         {
        System.Console.WriteLine("hasil operasi = {0}", hasil);
 
         }
     }
 
}  // penutup  namespace

Method Overloading
Method overloading adalah method dgn nama yang sama tetapi mempunyai parameter yang berbeda. contoh
1
2
3
4
5
6
7
8
9
10
11
public int hitung luaspersegipanjang(int panjang, int lebar)
{
int luas = panjang * lebar;
return luas
}
 
public double hitung luaspersegipanjang(double panjang, double lebar)
{
double luas = panjang * lebar;
return luas
}
pada contoh diatas kedua method mempunyai nama yg sama yaitu luaspersegipanjang akan tetapi keduanya mempunyai parameter yg berbeda , method pertama parameternya berupa bilangan integer method kedua parameternya bilangan double. C# akan secara otomatis menyesuaikan method mana yg dipakai berdasar nilai parameter yg diberikaan.
Overload Constructor
Seperti method, constructor juga bisa di overload artinya setia objek dijalankan akan ada consructor yg dijalankan sesui jumlah, type atau urutan argument yg diberikan untuk parameter constructornya.
contoh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class serialkomunikasi
  {
     public serialkomunikasi( int baudrate)
      {
      }
     public serialkomunikasi(int baudrate, int data )
      {
      }
  }
 
class penggunaanSerial
{
   static void Main(string[] args)
{
   seserialkomunikasi Com1 = new serialkomunikasi(9600);
// atau
   serialkomunikasi Com1 = new serialkomunikasi(9600,8);
}
Komposisi
Komposisi adalah member class yg berupa Objek Referensi dari class Lain
Pada situasi tertentu membuat referensi obyek yang sudah ada lebih mudah daripada menulis ulang kode objek untuk class baru dalam proyek-proyek baru.
Penggunaan referensi ke obyek dari sebuah class yang sudah ada sebagai anggota objek baru ini disebut komposisi.
Salah satu bentuk reusable dlm perangkat lunak adalah komposisi, di mana member class memiliki referensi ke objek dari class lainnya.
contoh
1
2
3
4
5
6
7
8
9
10
11
class test
{
 
  private int x =100;          /
  private casio   kalkulator;  //  casio adalah objek class kalkulator
 
  public test ()   //constructor
  {
  }
 
}
Penggunaan referensi “this”
Setiap objek dapat mengakses referensi ke dirinya sendiri, yang disebut referensi this. Referensi this dapat merujuk secara implisit ke variable instance, properties dan method dari sebuah objek.
Keyword this umumnya digunakan di dalam methods, di mana this adalah referensi ke objek yang sedang digunakan oleh method tsb.
Contoh this
1
2
3
4
5
6
7
8
9
10
11
12
class contohsaja
{
private int  dataku =10;
 
public int tambahkan()
   {
   int dataku = 33;   // variable lokal
   this.dataku++;     // instance variable dataku + 1 = 10 +1
 
   }
 
}
this.dataku mengacu ke instace variable (private int dataku =10 , bukan lokal variable int dataku =33 ).
Inheritance  (pewarisan)
Kita bisa membuat class baru dengan cara menurunkan(inherit) class yg sudah ada. Jadi kita tidak perlu repot membuat class baru dari nol . Sebagai contoh kita ingin membuat class kalkulator Statistik yg mempunyai method hitung rata rata. Kita tak perlu membuat class kalkulator statistik baru dari awal ,kita bisa membuat class  turunan dari class  kalkulator yg sudah ada.
Member Class turunan dapat mengakses member class  public  dan protected dari class induk. Member class protected dari class induk dapat diakses oleh class turunan
Method dari class induk dapat ditulis kembali (redefined) di kelas turunannya dalam bentuk :
– Abstract method pada class abstract (class induk yg berisi abstrak method)
– Virtual method pada non class abstract.
method yg ditulis kembali di dahului oleh keyword “override”
Objek dari classInduk adalah bukan objek classTurunan, objek classTurunan adalah objek classInduk. misal class induk : mobil  class turunan : toyota,honda,hyundai  ,toyota (sudah pasti) adalah mobil tapi mobil adalah bukan toyota.
kalau sebuah class tdk tertulis class induk maka sebenarnya class tersebut adalah turunan dari class “object” . Class object adalah class induk dari semua class yg ada di C#, termasuk class yg kita buat sendiri.
classturunan
Contoh Penerapan class induk – class turunan pada aplikasi kalkulator
..
inheritance

Berikut ini contoh Diagram   Class induk kalkulatorSederhana dan 2 buah Class turunannya.
classinheritence
Class turunan mewarisi data dan method dari Class induk , melihat pada contoh diatas  kedua Class turunan tdk perlu lagi membuat method jumlah() dan method kurang()  karena  Class turunan mewarisi keduanya.
Cara Class induk mewarisi Class turunannya:
NamaClass_Turunan : namaClass_Induk
Constructor class induk dan class turunan
Saat objek class turunan dibuat maka constructor class induk dijalankan lebih dahulu baru setelah itu constructor objek turunan dijalankan. Kalau class induk juga berinduk (diturunkan dari) ke class lain,maka class lain tsb yg pertama kali dijalankan begitu seterusnya. Constructor yg pertama kali dijalankan adalah constroctor class object karena kelas tsb adalah kelas induk dari semua class.
contoh :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class kakek
{
   public kakek()   //secara implisit memanggil constructor "object"
   {
   }
 public kakek()   //constructor
   {
   console.writeln(" konstruktor kakek");
   }
}
 
class bapak : kakek
{
    public bapak()  // secara implisit memanggil construktor kakek
     {
     }
 public bapak()   //constructor
   {
   console.writeln(" konstruktor bapak");
   }
}
 
class anak : bapak
{
  public anak()  // secara implisit memanggil constructor bapak
  {
  }
 public anak()   //constructor
   {
   console.writeln(" konstruktor anak");
   }
}
 
class test
{
  anak anak1  = new anak()   // buat objek anak1 dari class anak.
}
Ketika objek anak1 dibuat maka konstruktor kakek yg pertama dijalankan lalu kontruktor bapak lalu konstroktor anak
Constructor dgn parameter
Untuk menjalankan constructor class induk yg mempunyai parameter kita dapat menuliskan dgn:
constructorTurunan(parameter) : base(parameter)
contoh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
namespace inheritance
{
   public class koordinat
    {
      protected int X, Y;
 
       public koordinat()
     {
     // implicit call to Object constructor occurs here
      Console.WriteLine("constructor1 point, empty");
      }
 
 // constructor  dgn parameter
 public point( int xValue, int yValue )
  {
    X = xValue; // use property X
    Y = yValue; // use property Y
    Console.WriteLine("constructor2 point, set X dan Y");
   }
 
// return string representation of koordinat
 public override string ToString()
   {
    return "[" + X + ", " + Y + "]";
    }
 
    }//end of class koordinat
 
//================================================
// kelas lingkaran mempunyai base class koordinat
//=============================================
class lingkaran: koordinat
 {
        private double jari_jari;
 
  // default constructor
     publiclingkaran()
     {
    // implicit call to koordinat constructor occurs here
     Console.WriteLine("constructor1 lingkaran, empty");
      }
 
    // constructor
   public lingkaran( int nilaiX, int nilaiY, double nilaiR ) : base( nilaiX, nilaiY )
     {
      jari_jari = nilaiR;
       Console.WriteLine("constructor2 lingkaran, set jari jari");
      }
 
      // property
      public double Jari_Jari
      {
           get
           {
            return jari_jari;
            }
 
           set
            {
           jari_jari = value;
            }
 
       }
 
       public override string ToString()
       {
 
         return "koordinat x,y = " + base.ToString() +  ";jari-jari lingkaran = " + Jari_Jari;
        }
 
    } //  end of class
//=================================
 
// class test
 
 class ProgramTest
    {
        static void Main(string[] args)
        {
 
            //=========================
            lingkaran lingkaran1 = new lingkaran(3,4,5);
 
            Console.WriteLine(lingkaran.ToString());
 
            Console.ReadLine();
        }//end of main
    } //end off class ProgramTest
 
} //end of namespace
Perhatikan cara constructor class turunan menyertakan constructor base class yg berparameter (digunakan untuk inisialisasi objek class turunan dan objek class induk)
1
2
3
4
5
6
// constructor
public lingkaran( int nilaiX, int nilaiY, double nilaiR ) : base( nilaiX, nilaiY )
{
jari_jari = nilaiR;
Console.WriteLine("constructor2 lingkaran, set jari jari");
}
Class Abstrak
Class Abstrak adalah class yg digunakan sebagai Class induk dan methodnya tidak ada implemantasinya hanya berupa deklarasi saja . Implementasi dari class abstrak dilakukan pada class turunannya. Class turunan wajib meng-implementasi semua method abstrak dari class induk. Class abstrak di dahului keyword “abstract”
contoh class abstrak :
1
2
3
4
5
6
public abstract class  mobil   // mobil adalah class abstrak
{
      public abstract starterMesin(); // method abstract krn tdk ada implentasi
      public abstract tekanPedalGas();
      public abstract tekanPedalRem();
}
Method abstrak
Method abstrak hanya ada di dalam class abstrak, penulisan method ini  di dahului dgn keyword “abstract”. Method abstrak tidak mempunyai implementasi hanya deklarasi saja.
contoh  Class dan method abstrak :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace contohClassAbstak
{
 
  public abstract class kalkulatorInduk
   {
    public abstract int jumlah(int x, int y);
     publik abstract int kurang(int x, int y);
    }
 
   public class statistikKalkulator : kalkulatorInduk // kalkulatorInduk sbg class induk
   {
     public override int jumlah(int x, int y)
     {
     return x + y;
     }
 
     public override int jumlah(int x, int y)
    {
    return x - y;
    }
  } // penutup class
 
} //penutupn namespace

Method Virtual
berbeda dgn method abstract, method virtual adalah method dari class induk yg ditulis kembali dari pada class turunan dan pada class induk method tsb juga punya implementasinya .
Contoh:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class classInduk
{
     public virtual methodA
     {
        //code program
     }
 
}
 
class classAnak : classInduk
{
      public override methodA
      {
        //code program
      }
}
contohoverride
Menyembunyikan method  class induk dgn keyword  “new”
jika kita ingin membuat method baru di kelas turunan yg sama dgn method dikelas induk dan kita ingin method yg dikelas induk  disembunyikan  kita tambahkan keyword new dimethod kelas turunan.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
 
class induk
{
    public void methodInduk()
    {
    Console.WriteLine(" method induk");
    }
}
 
class anak : induk
{
   public new void methodInduk() // method ini menyembunyikan methodinduk dari base class.
    {
    console.WriteLine("method anak");
    }
}
 
class Program
{
    static void Main()
    {
    anak objekref = new anak();
    objekref.MethodInduk();
    }
}
Output
method anak
Array
Array digunakan untuk menyimpan sejumlah data dgn type yg sama. contoh
array yg terdiri 1 baris data atau disebut array 1 dimensi
5 buah data dgn type integer: [10,20,4,5,6]
3 buah data string : ["mangga", "jambu" "rambutan"]
Array yg terdiri dari baris dan kolom disebut array 2 dimensi
contoh array 3 baris 3 kolom
{ 1, 4, 5}
{ 2, 5, 3}
{ 3, 6, 2}
Sintax untuk membuat array 1 dimensi
Type [] namaArray = new namaArray[jumlah data]
contoh : int [] dataku = new dataku[5]
Untuk membaca atau menulis data ke dalam elemen array menggunakan
namaArray[indek] , indek dimulai dari 0
misal data yg akan kita tulis ke array dataku adalah {10,20,4,5,6}
dataku[0]=10;
dataku[1]=20;
dataku[2]=4;
dataku[3]=5;
dataku[4]=6;
kode program untuk membaca data dari element array ke 2
var1 = dataku[2];
maka var1 akan bernilai 4
kode program membuat array dan sekaligus mengisi dengan data :
int [] dataku = new dataku[5] {10,20,4,5,6};
selain itu type data array juga bisa ditentukan oleh data yg disimpan :
contoh : var datamu = new[] {2.3, 4.3, 3.5};
oleh compiler type data datamu diset desimal
Mengakses array dataku dgn for loop
int [] dataku = new dataku[5] {10,20,4,5,6};
for(int i =0; i < dataku.length; i++)
int jumlahTotal = jumlahTotal + dataku[i];
Mengakses array dataku dengan foreach
sintax : foreach ( type namaelemen in namaArray)
{
statement
}
contoh :
foreach ( int data in dataku)
{
int jumlahTotal = jumlahTotal + data;
}
Array dua dimensi
sintax membuat array 2 dimensi :
type[ , ] namaArray = new type [jumlah baris,jumlah kolom]
contoh : int[ , ] dataku = new int[3,3];
Untuk membaca atau menulis data ke dalam elemen array dua dimensi menggunakan
namaArray[indek baris, indek kolom] , indek dimulai dari 0
contoh misalnya data sebuah matrix sbb:
1 2 3
4 5 6
7 8 9
kode program menyimpan data matrix diatas kedalam array dua dimensi :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
dataku[0,0] = 1; // baris 0 kolom 0
dataku[0,1] = 2;
dataku[0,2] = 3;
 
dataku[1,0] = 4; // baris 1 kolom 0
dataku[1,1] = 5;
dataku[1,2] = 6;
 
dataku[2,0] = 7; //baris 2 kolom 0
dataku[2,1] = 8;
dataku[2,2] = 9;
 
// atau dengan kode program yg lebih lebih simple :
int[,] dataku = { {1,2,3},
                  {4,5,6},
                  {6,7,8},
                 };
 
 
// Mengakses array dua dimensi dataku[3,3] dengan for loop
 
for (int baris = 0; baris < dataku.GetLength(0); baris++)
{
     for ( int kolom = 0; kolom < dataku.GetLenght(1); kolom++)
       {
        int jumlahTotal =  jumlahTotal + dataku[baris,kolom];
       }
}
 
// Mengakses array dua dimensi dataku[3,3] dengan foreach
 
foreach (int i in dataku)
  {
    System.Console.Write("Output: {0} ", i);
  }
// Output: 1 2 3 4 5 6 7 8 9
Method bisa memiliki return value dan parameter berupa array 1 dimensi.
contoh :
1
2
3
4
5
urutkanArray(int [] dataku)
{
   Array.sort(dataku);     
   return dataku;
}
Untuk mengurutkan element array dataku program diatas menggunakan method sort member dari class statis Array. selain method sort, class Array juga memiliki member copy, binarysearch dll.
Collection
Collection hampir sama dengan array, bedanya collection mempunyai jumlah elemen data yg tidak tetap (mutable). Sehingga collection lebih fleksible dibanding array.
Collection adalah class yg tersimpan pada namespace system.collection.generic. Ada 4 jenis class collection yaitu :
1. List<T>
2. SortedList<K,V>
3. Queue<T> (antrian)
4. Stack<T>
contoh penggunaan Class List
// membuat sebuah objek collection dari class List
List<int> dataku = new List<int>
//mengisi elemen objek collection dataku
dataku.Add(2);
dataku.Add(4);
dataku.Add(7);
//Mengakses elemen objek list dataku sama spt array
for(i=0; i<dataku.Count; i++)
int jumlahTotal += jumlahTotal + dataku[i];
ArrayList
Ada class yg mirip class List<T> yaitu Class ArrayList. ArrayList berada pada namespace System.Collections.ArrayList.
contoh penggunaan class arrayList
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections;
public class SamplesArrayList
{
 public static void Main()  {
 
      // Creates and initializes a new ArrayList.
      ArrayList listbuah = new ArrayList();
      listbuah.Add("mangga");
      listbuah.Add("rambutan");
      listbuah.Add("jeruk");
 
      // Displays the properties and values of the ArrayList.
      Console.WriteLine( "daftar list buah" );
      Console.WriteLine( "    jumlah:    {0}", listbuah.Count );
      Console.WriteLine( "    Capacity : {0}", listbuah.Capacity );
      Console.Write( "    isi list buah:" );
      PrintValues( listbuah );
   }
 
   public static void PrintValues( IEnumerable list ) 
       {
         foreach ( Object buah in list )
         Console.Write( "   {0}", buah );
         Console.WriteLine();
      }
}
Interface
interface konstruksinya mirip dengan class abstrak tetapi dengan tidak ada kode implementasi. Artinya, sebuah interface hanya terdiri dari deklarasi tanpa implementasi.
  Sebuah interface dapat digunakan di mana saja dalam desain class sebagai instance variabel atau parameter dalam method.
  Sebuah interface adalah sebuah “kontrak definisi” artinya setiap class yang mengimplementasikan interface harus menerapkan semua definisi metode yang diberikan dalam interface .
  Sebuah interface mengatakan apa yang user harus dilakukan, bukan bagaimana melakukannya.
  Sebuah interface mendefinisikan karakteristik perilaku dan menempatkan perilaku dlm yang classes independen dari hirarki class.
  Ketika class membuat kontrak dengan menerapkan interface, class dikatakan mengimplementasikan interface atau mewarisi/inherit dari interface.
penulisan interface
interface Inama-interface
{
definisi member interface
}
nama interface didahului dgn huruf i cuma sebagai penanda sebuah interface saja tapi tdk wajib ada.
penulisan class yg mengimplementasikan interface
class namaclass : Inama-interface
contoh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
 
namespace Contohinterface1
{
    class Program
    {
        static void Main(string[] args)
        {
            IremoteControl remoteProductChina = new RCsedan();
            remoteProductChina.maju();
            remoteProductChina.mundur();
            Console.ReadLine();
        }
    }
 
//========================================
//          interface
//=========================================
    interface IremoteControl
    {
        void maju();
        void mundur();
    }
//==========================================
 
    class RCsedan : IremoteControl
    {
        public void maju()
         {
             System.Console.WriteLine("sedan maju");
          }
 
        public void mundur()
        {
            System.Console.WriteLine("sedan mundur");
        }
    }// end of class RCsedan
  
}
class RCsedan mengimplementasikan interface IremoteControl jadi class RCsedan harus mengimplementasikan semua method interface IremoteControl yaitu maju() dan mundur();
referensi : MSDN : C# Programming Guide

0 Comments

Post a Comment

Subscribe to: Post Comments (Atom)

Copyright Jujur Soaloon Sitangang Lipan All rights reserved. Theme by Sitanggang. | Bloggerized by Soalparna.