Posting ini adalah lanjutan dari posting saya yang sebelumnya tentang :
Topik yang akan dibahas:
- Abstract Class
- Sealed Class
- Class Object
- Interface
- Delegates dan Event
Abstract Class
Setiap tipe Window pasti mempunyai bentuk tampilan yang berbeda misal combobox, listbox, button, dll. Berarti setiap class turunan dari Window harus mempunyai method DrawWindow() nya sendiri yang berbeda satu sama lain. Untuk memastikan bahwa setiap class turunan Control harus mempunyai method DrawWindow() maka anda harus mendefinisikan class tersebut sebagai abstract class dan memiliki method abstract yang belum diimplementasikan.
Abstract method tidak mempunyai implementation, abstract method hanya semacam kontrak yang harus dipenuhi. Semua class yang diturunkan dari class yang mempunyai abstract method harus mengimplementasikan method tersebut.
Class yang didefinisikan sebagai abstract class tidak dapat dibuat instan class / objek, class yang didefinisikan abstract hanya dapat digunakan dengan cara diturunkan.
1: public abstract class Control { 2: private int top;
3: private int left;
4:
5: protected int Top { 6: get { return this.top;} 7: set { this.top = value;} 8: }
9: protected int Left { 10: get {return this.left;} 11: set {this.left = value;} 12: }
13: public Control(int top, int left) { 14: Top = top;
15: Left = left;
16: }
17: //abstract method harus diimplementasikan
18: public abstract void DrawWindow();
19: }
20:
21: public class ListBox : Control { 22: private string listBoxContent;
23: public ListBox(int top, int left, string contents)
24: : base(top, left) { 25: this.listBoxContent = contents;
26: }
27:
28: public override void DrawWindow() { 29: Console.WriteLine("Position :({0},{1})", Top, Left); 30: Console.WriteLine("Menuliskan string pada listbox: {0}", 31: listBoxContent);
32: }
33:
34: }
35:
36: public class Button : Control { 37: public Button(int top, int left) : base(top, left) { } 38: public override void DrawWindow() { 39: Console.WriteLine("Menggambar button pada ({0},{1})", Top, Left); 40: }
41: }
42: class LatAbstract { 43: static void Main(string[] args) { 44: Control[] winArray = new Control[3];
45: winArray[0] = new ListBox(5, 10, "Pada ListBox");
46: winArray[1] = new Button(5, 6);
47: for (int i = 0; i < 2; i++) { 48: winArray.DrawWindow();
49: }
50: }
51: }
Tapi untuk kasus diatas abstract masih mempunyai keterbatasan, jika anda ingin membuat class DropDownList yang hendak diturunkan dari class ListBox, maka anda tidak dapat memaksakan method DrawWindow() harus ada di class tersebut.
Sealed Class
Jika anda ingin membuat class yang tidak dapat diturunkan lagi maka anda dapat menambahkan keyword ‘sealed’.
Object Root dari semua class
Semua class dari semua type diturunkan dari satu class untama yaitu class object. Meskipun tidak dituliskan secara eksplisit namun pada dasarnya semua class diturunkan dari class object.
Beberapa method yang ada pada class object adalah: Equals(), GetHashCode(), GetType(), ToString(), Finalize(), MemberwiseClone(), ReferenceEquals().
Method dari class yang ada diatas dapat dioverride oleh semua class karena pada dasarnya semua class diturunkan dari class object.
1: public class Cat { 2: private int weight;
3: public Cat(int weight) { 4: this.weight = weight;
5: }
6:
7: public override string ToString() { 8: return weight.ToString();
9: }
10: }
11: class LatObject { 12: static void Main(string[] args) { 13: Cat catty = new Cat(60);
14: Console.WriteLine("Berat si catty : " + catty); 15: }
16: }
Boxing dan Unboxing Types
Boxing dan Unboxing adalah suatu proses ketika suatu tipe data value (seperti int) di konversikan menjadi tipe reference / object. Istilah boxing berarti diubah menjadi object dan unboxing berarti dikembalikan lagi ke tipe data value.
Proses boxing dilakukan secara implisit jadi compiler otomatis akan melakukannya ketika kita mengisi nilai bertipe value kedalam variabel bertipe object.
1: int myIntegerValue = 5;
2: object myObject = myIntegerValue; // cast to an object
3: myObject.ToString();
Tidak seperti boxing, proses unboxing harus eksplisit. Ketika proses unbox kita harus tahu tipe data apa yang kita ingin konversikan dari tipe objek-nya.
1: int myInt = 123;
2: //proses boxing (dilakukan secara otomatis)
3: object objInt = myInt;
4: Console.WriteLine("Nilai ObjInt : {0}",objInt.ToString()); 5:
6: //proses unboxing (harus dilakukan secara eksplisit)
7: myInt = (int)objInt;
8: Console.WriteLine("Nilai myInt : {0}", myInt.ToString());
Menghindari Boxing dan unboxing dengan Generic
Proses boxing dan unboxing mempengaruhi performa program, karena semua harus di boxing kedalam tipe object (misal: dalam penggunaan ArrayList). Pada C# 2.0 keatas sudah mendukung generic sehingga proses boxing dan unboxing dapat dihindari.
Interfaces
Jika anda ingin mendefinisikan tipe baru tetapi tidak ingin mengimplementasikan isinya secara langsung maka anda dapat menggunakan interfaces.
Pada dasarnya interface adalah sebuah kontrak, ketika anda mendesign interface seolah-olah anda mengatakan “jika anda ingin menggunakan class ini maka anda harus mengimplementasikan method, property yang sudah disediakan”. Class yang menggunakan interface tersebut setuju dengan kontrak dan mengimplementasikan requirement yang ditentukan.
Dibandingkan dengan abstract class, abstract class hanya bisa digunakan di class paling atas ‘top-hierarchy’ sedangkan interface dapat digunakan di setiap class yang diinginkan (setiap class dapat mengimplementasikan lebih dari satu interface).
Perbedaan Interface dan Abstract Class
Programmer sering merasa bingung dalam mebedakan Interface dan Abstract Class. Beberapa perbedaannya adalah:
- Cara penggunaan Abstract Class adalah diturunkan, sedangkan cara penggunaan Interface adalah diimplementasikan.
- Pada C# lambang untuk menurunkan class dan menggunakan interfaces sama-sama menggunakan tanda “:” (titik dua). Tetapi untuk membedakan biasanya nama interface diawali dengan huruf I di depan misal: IEnumerable, IDisposable, dll.
- Sebuah class hanya dapat diturunkan dari satu abstract class tapi dapat menggunakan lebih dari satu interfaces.
- Method dan member variable pada abstract class boleh sudah ada isinya, sedangkan pada interfaces semua belum ada implementasinya.
- Pada Abstract Class semua method / member variable yang abstract harus diimplementasikan di class turunannya.
- Pada Interface semua member variable dan method harus diimplementasikan di class yang menggunakan interface tersebut.
- Access Modifier pada method dan member variable di Interface secara implisit adalah public.
1: interface IStorable { 2: void Read();
3: void Write();
4: int Status { get; set; } 5: }
6:
7: public class Document : IStorable { 8: private int status = 0;
9:
10: public Document(string s) { 11: Console.WriteLine("Create : {0}", s); 12: }
13:
14: public void Read() { 15: Console.WriteLine("Mengimplementasikan method Read dari IStorable"); 16: }
17:
18: public void Write() { 19: Console.WriteLine("Mengimplementasikan method Write dari IStorable"); 20: }
21:
22: public int Status { 23: get { return this.status; } 24: set { this.status = value; } 25: }
26: }
27:
28: class LatSimpleInterface { 29: static void Main(string[] args) { 30: Document doc = new Document("New Document"); 31: doc.Read();
32: doc.Write();
33: doc.Status = 1;
34: Console.WriteLine("Document status : {0}", doc.Status); 35: }
36: }
Mengimplementasikan lebih dari satu Interface
Pada C# sebuah class hanya dapat diturunkan dari sebuah class saja, tidak seperti bahasa C++ yang mendukung multipe inheritance. Tetapi untuk interface anda dapat menggunakan lebih dari satu interface dalam sebuah class.
Misal saja untuk class dokumen diatas dapat disimpan dan dapat juga dikompres datanya, maka anda dapat menambahkan interface Icompressible kedalam class tersebut.
Interface juga dapat dikombinasikan, anda bisa menambahkan inteface kedalam interface lain, misal:
1: interface ICompessible { 2: void Compress();
3: void Decompress();
4: }
5: interface ILoggedCompresible : ICompessible { 6: void LogSavedBytes();
7: }
Ketika anda menggunakan interface IloggedCompresible maka anda harus mengimplementasikan method Compress(), Decompress(), dan LogSavedBytes().
1: interface IStorable { 2: void Read();
3: void Write(object obj);
4: int Status { get; set; } 5: }
6:
7: interface ICompressible { 8: void Compress();
9: void Decompress();
10: }
11:
12: interface ILoggedCompressible : ICompressible { 13: void LogSavedBytes();
14: }
15:
16: interface IStorableCompressible : IStorable, ILoggedCompressible{ 17: void LogOriginalSize();
18: }
19:
20: interface IEncryptable { 21: void Encrypt();
22: void Decrypt();
23: }
24:
25: public class Document : IStorableCompressible, IEncryptable { 26: private int status = 0;
27:
28: public Document(string s) { 29: Console.WriteLine("Creating Document: {0}", s); 30: }
31:
32: public void LogOriginalSize() { 33: Console.WriteLine("Mengimplementasikan method LogOriginalSize"); 34: }
35:
36: public void Read() { 37: Console.WriteLine("Mengimplementasikan method Read"); 38: }
39:
40: public void Write(object obj) { 41: Console.WriteLine("Mengimplementasikan method Write"); 42: }
43:
44: public int Status { 45: get { return status; } 46: set { this.status = value; } 47: }
48:
49: public void LogSavedBytes() { 50: Console.WriteLine("Mengimplementasikan method LogSavedBytes"); 51: }
52:
53: public void Compress() { 54: Console.WriteLine("Mengimplementasikan method Compress"); 55: }
56:
57: public void Decompress() { 58: Console.WriteLine("Mengimplementasikan method Decompress"); 59: }
60:
61: public void Encrypt() { 62: Console.WriteLine("Mengimplementasilan method Encrypt"); 63: }
64:
65: public void Decrypt() { 66: Console.WriteLine("Mengimplementasikan method Decrypt"); 67: }
68: }
69:
70: class LatMultipleInterface { 71: static void Main(string[] args) { 72: Document doc = new Document("New Document"); 73: doc.Read();
74: doc.Compress();
75: doc.LogSavedBytes();
76: doc.LogOriginalSize();
77: doc.Encrypt();
78: doc.Decrypt();
79: doc.Decompress();
80: doc.Status = 1;
81: Console.WriteLine("Status {0}", doc.Status); 82: }
83: }
Delegates dan Event
Mungkin anda pernah menjumpai situasi dimana anda ingin mengeksekusi suatu action tetapi anda belum tahu pasti isi dari detail methodnya atau bahkan tidak tahu objectnya. Misal method untuk menghandle button press (ketika object button tersebut ditekan). Anda harus membayangkan bahwa pembuat komponen button, textbox, listbox bukanlah programmer yang menggunakan object tersebut. Pembuat button hanya tahu bahwa button tersebut mempunyai event click (ketika diklik) tapi pembuat buton tidak tahu apa yang terjadi ketika button tersebut diklik (hanya diketahui oleh programmer yang menggunakan button tersebut).
Untuk mengatasi masalah diatas pembuat button sudah menyediakan event misal click, mouse_mive, dll. jika programmer hendak menggunakannya maka dapat mengaksesnya menggunakan delegates. Delegates adalah semacam kontrak yang harus dipenuhi ketika hendak menggunakan method tertentu (mirip dengan interfaces).
1: delegate void StringProcesssor(string input);
2: class Person { 3: private string name;
4:
5: public Person(string name) { 6: this.name = name;
7: }
8:
9: public void Say(string message) { 10: Console.WriteLine("{0} says : {1}", name, message); 11: }
12: }
13:
14: class Background { 15: public static void Note(string note) { 16: Console.WriteLine("({0}) ", note); 17: }
18: }
19:
20: class LatSimpleDelegates { 21: static void Main(string[] args) { 22: Person rick = new Person("Erick"); 23: Person jhon = new Person("Jhon"); 24: StringProcesssor jonsVoice, rickVoice, background;
25: rickVoice = new StringProcesssor(rick.Say);
26: jonsVoice = new StringProcesssor(jhon.Say);
27: background = new StringProcesssor(Background.Note);
28:
29: rickVoice("Hello Jhon !!"); 30: jonsVoice("Hello rick !!"); 31: background("Suara ramai lalu lintas"); 32: }
33: }