Object Orientied Programming

Standar

Object Orientied Programming adalah
sebuah konsep programming yang menjadikan semua code/script di jadikan menjadi
sebuah object. Sebelum kita mengetahui beberapa konsep OOP yang di ajarkan pada
umumnya, kita harus mengetahui terlebih dahulu beberapa istilah di seperti object. Object
adalah Sebuah instance (perwujudan nyata) dari suatu kelas tertentu. Dibawah ini adalah
beberapa konsep yang di anut OOP :
a. Encapsulation adalah proses pembungkusan sebuah object kedalam sebuah kelas.
b. Inherintance adalah proses pewarisan keturanan sifat dari kelas induk (Super Class)
kepada anak kelas nya (Sub Class).
c. Polymorphism adalah proses pengubahan bentuk sebuah object menjadi berbagai
bentuk. Pengubahan bentuk tersebut menggunakan konsep overriding dan inheritance

1.Encapsulation
Encapsulation adalah konsep pembungkusan sebuah object kedalam sebuah kelas
(Class). Dibawah ini contoh encapsulation :
public class SegiEmpat {
int panjang;
int lebar;
string warna;
//Constructor//
public SegiEmpat(string w, int p, int l)
{
panjang = p; lebar = l; warna = w;
}
//properties//
public setWarna (string w)
{
warna = w;
}
}
SegiEmpat sPink = new SegiEmpat(“pink”, 20,10); // instance of class SegiEmpat
Didalam sebuah class terdapat beberapa bagian yaitu :
a. Constructor adalah sebuah fungsi yang nama sesuai dengan nama Class
tersebut. Bila kita tidak membuat constructor, maka secara otomatis Visual
Studio akan membuat Default Constructor yang tidak mengembalikan nilai
apapun. Constructor akan di buat atau di jalankan pada saat kita melakukan
instansi sebuah objek.
b. Attribute adalah merupakan bagian dari sebuah class. Di dalam attribute
terdiri dari variable, function, properties.
c. Access Modifiers digunakan untuk menentukan hak akses dari class dan
method, adapun access modifier yang ada pada C# sebagai berikut:
a) public adalah salah satu access modifier yang ada di dalam bahasa
pemograman yang menggunakan konsep OOP. Access modifier public
berarti sebuah class tersebut dapat digunakan di mana aja termasuk
contain yang ada di dalam sebuah class itu
b) private adalah salah satu access modifier yang hanya bisa di akses pada
kelas tersebut.
c) internal adalah salah satu access modifier yang memiliki sifat seperti
access modifier private namun internal hanya dapat diakses pada file yang
di assembly yang sama.
d) protected adalah salah satu access modifier yang hanya bisa di akses pada
kelas tersebut dan kelas turunan nya.
2.Inheritance
Inherintance adalah konsep OOP yang di mana kelas anak (SubClass) menurunkan
sifat dari kelas induk nya (SuperClass). Didalam bahasa pemogramman C#
inherintance di lambangkan dengan symbol “ : “. Di bawah ini adalah contoh dari
implementasi inherintance :
using System;
// declare the MotorVehicle class (the base class)
class MotorVehicle
{
// declare the fields
public string make;
public string model;
// define a constructor
public MotorVehicle(string make, string model)
{
this.make = make;
this.model = model;
}
// define a method
public void Start()
{
Console.WriteLine(model + ” started”);
}
}
// declare the Car class (derived from the MotorVehicle base class)
class Car : MotorVehicle
{
// declare an additional field
public bool convertible;
// define a constructor
public Car(string make, string model, bool convertible) :
base(make, model) // calls the base class constructor
{
this.convertible = convertible;
}
}
// declare the Motorcycle class (derived from the MotorVehicle base class)
class Motorcycle : MotorVehicle
{
// declare an additional field
public bool sidecar;
// define a constructor
public Motorcycle(string make, string model, bool sidecar) :
base(make, model) // calls the base class constructor
{
this.sidecar = sidecar;
}
// define an additional method
public void PullWheelie()
{
Console.WriteLine(model + ” pulling a wheelie!”);
}
}
public class Example7_1
{
public static void Main()
{
// declare a Car object, display the object’s fields, and call the
// Start() method
Car myCar = new Car(“Toyota”, “MR2”, true);
Console.WriteLine(“myCar.make = ” + myCar.make);
Console.WriteLine(“myCar.model = ” + myCar.model);
Console.WriteLine(“myCar.convertible = ” + myCar.convertible);
myCar.Start();
// declare a Motorcycle object, display the object’s fields, and call the
// Start() method
Motorcycle myMotorcycle = new Motorcycle(“Harley-Davidson”, “VRod”,
false);
Console.WriteLine(“myMotorcycle.make = ” + myMotorcycle.make);
Console.WriteLine(“myMotorcycle.model = ” + myMotorcycle.model);
Console.WriteLine(“myMotorcycle.sidecar = ” + myMotorcycle.sidecar);
myMotorcycle.Start();
myMotorcycle.PullWheelie();
}
}
3.3 Polymorphism
Polymorphism adalah kemampuan untuk mengubah banyak bentuk yang berbeda.
Didalam konsep polymorphism menggunakan keyword virtual dan menggunakam
konsep Overriding. Overriding adalah Subclass yang berusaha memodifikasi tingkah
laku yang diwarisi dari superclass. Overloading adalah beberapa fungsi/operator yang
di deklarasikan atau di definisikan didalam sebuah kelas yang sama. Overloading
dibagi menjadi dua yaitu : operator overloading dan method/fungsi overloading
a. Operator Overloading
Operator Overloading adalah pendeklarisan atau pendefinisian operator dalam
sebuah class secara bersamaan. Operator Overloading menggunakan keyword
‘operator’ kemudian di ikuti operator yang akan dioverloading. Contoh dari
Operator Overloading di gambarkan di bawah ini :
using System;
class Matrix
{
public const int DimSize = 3;
private double[,] m_matrix = new double[DimSize,
DimSize];
// allow callers to initialize
public double this[int x, int y]
{
get { return m_matrix[x, y]; }
set { m_matrix[x, y] = value; }
}
// let user add matrices
public static Matrix operator +(Matrix mat1, Matrix mat2)
{
Matrix newMatrix = new Matrix();
for (int x=0; x < DimSize; x++)
for (int y=0; y < DimSize; y++)
newMatrix[x, y] = mat1[x, y] +
mat2[x, y];
return newMatrix;
}
}
class MatrixTest
{
// used in the InitMatrix method.
public static Random m_rand = new Random();
// test Matrix
static void Main()
{
Matrix mat1 = new Matrix();
Matrix mat2 = new Matrix();
// init matrices with random values
InitMatrix(mat1);
InitMatrix(mat2);
print out matrices
Console.WriteLine("Matrix 1: ");
PrintMatrix(mat1);
Console.WriteLine("Matrix 2: ");
PrintMatrix(mat2);
// perform operation and print out results
Matrix mat3 = mat1 + mat2;
Console.WriteLine();
Console.WriteLine("Matrix 1 + Matrix 2 = ");
PrintMatrix(mat3);
Console.ReadLine();
}
// initialize matrix with random values
public static void InitMatrix(Matrix mat)
{
for (int x=0; x < Matrix.DimSize; x++)
for (int y=0; y < Matrix.DimSize; y++)
mat[x, y] = m_rand.NextDouble();
}
// print matrix to console
public static void PrintMatrix(Matrix mat)
{
Console.WriteLine();
for (int x=0; x < Matrix.DimSize; x++)
{
Console.Write("[ ");
for (int y=0; y < Matrix.DimSize; y++)
{
// format the output
Console.Write("{0,8:#.000000}",
mat[x, y]);
if ((y+1 % 2) < 3)
Console.Write(", ");
}
Console.WriteLine(" ]");
}
Console.WriteLine();
}
}
b. Overloading Methods
Overloading methods adalah beberapa fungsi/operator yang di deklarasikan atau
di definisikan didalam sebuah kelas yang sama. Dibawah ini adalah contoh
pemakaian overloading methods :
// declare the Swapper class
class Swapper
{
// this Swap() method swaps two int parameters
public void Swap(ref int x, ref int y)
{
int temp = x;
x = y;
y = temp;
}
// this Swap() method swaps two float parameters
public void Swap(ref float x, ref float y)
{
float temp = x;
x = y;
y = temp;
}
}
public class Example5_9
{
public static void Main()
{
// create a Swapper object
Swapper mySwapper = new Swapper();
// declare two int variables
int intValue1 = 2;
int intValue2 = 5;
System.Console.WriteLine("initial intValue1 = " + intValue1 +
", intValue2 = " + intValue2);
// swap the two float variables
// (uses the Swap() method that accepts int parameters)
mySwapper.Swap(ref intValue1, ref intValue2);
// display the final values
System.Console.WriteLine("final intValue1 = " + intValue1 +
", intValue2 = " + intValue2);
// declare two float variables
float floatValue1 = 2f;
float floatValue2 = 5f;
System.Console.WriteLine("initial floatValue1 = " + floatValue1 +
", floatValue2 = " + floatValue2);
// swap the two float variables
// (uses the Swap() method that accepts float parameters)
mySwapper.Swap(ref floatValue1, ref floatValue2);
// display the final values
System.Console.WriteLine("final floatValue1 = " + floatValue1 +
", floatValue2 = " + floatValue2);
mySwapper.Swap(ref floatValue1, ref floatValue2);
}
}
c. Overriding Methods
Overriding methods adalah Subclass yang berusaha memodifikasi tingkah laku
yang diwarisi dari superclass. Di bawah ini adalah contoh Overriding methods :
using System;
public class MotorVehicle {
public string make;
public string model;
public MotorVehicle(string make, string model) {
this.make = make;
this.model = model;
}
public virtual void Accelerate() {
Console.WriteLine(model + " accelerating");
}
}
public class Product : MotorVehicle {
public Product(string make, string model) :
base(make, model) {
}
public override void Accelerate() {
Console.WriteLine("Pushing gas pedal of " + model);
base.Accelerate();
}
}
public class Motorcycle : MotorVehicle {
public Motorcycle(string make, string model) :
base(make, model) {
// do nothing
}
public override void Accelerate() {
Console.WriteLine("Twisting throttle of " + model);
base.Accelerate();
}
}
class MainClass {
public static void Main() {
Product myProduct = new Product("Toyota", "MR2");
myProduct.Accelerate();
Motorcycle myMotorcycle =
new Motorcycle("Harley-Davidson", "V-Rod");
myMotorcycle.Accelerate();
}
}

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s