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 :
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
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)
// 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 :
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 :
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:
class classInduk
{
public virtual methodA
{
//code program
}
}
class classAnak : classInduk
{
public override methodA
{
//code program
}
}
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 :
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 :
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
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
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();
Sumber : MSDN : C# Programming Guide
Tidak ada komentar:
Posting Komentar