Powered By Blogger

Rabu, 23 Mei 2012

Konsep Object Oriented Programming bagian 2



2.Abstraction

Abstraction adalah suatu proses dimana kita melakukan design class dan menentukan data dan method yang akan di miliki oleh sebuah sebuah class. Method ini digunakan  untuk mengkomunikasikan data dalam class dengan lingkaran luar class ,misalnya untuk mengetahui  beberapa nilai jari-jari lingkaran saat ini kita menyediakan method khusus.pengaksesan data obyek secara langsung tidak diperbolehkan.
Contoh kode program :

Class lingkaran
{
Data: jari-jari
                Method: update jari-jari
                Informasi jari-jari
                Hitung luas
                Hitung keliling
}

3.    ENCAPSULATION
Kali ini saya akan membahas tentang Enkapsulasi/Pengkapsulan (Encapsulation) pada bahasa pemrograman Java. Java sendiri adalah salah satu bahasa pemrograman berbasis OOP (Object Oriented Programming). Dalam Pemrograman Berbasis Objek ini yang terdapat beberapa konsep yaitu Objek (object), Kelas (class), Abstraksi (Abstraction), Enkapsulasi/Pengkapsulan (Encapsulation), Polimorfisme, dan Inheritas.



3.1        Enkapsulasi/Pengkapsulan (Encapsulation)
Enkapsulasi adalah pembungkus, maksud pembungkus disini adalah untuk menjaga suatu proses program agar tidak dapat diakses secara sembarangan atau di intervensi oleh program lain. Konsep enkapsulasi sangat penting dilakukan untuk menjaga kebutuhan program agar dapat diakses sewaktu-waktu, sekaligus menjaga program tersebut Begitulah konsep kerja dari enkapsulasi, dia akan melindungi sebuah program dari akses ataupun intervensi dari program lain yang mempengaruhinya. Hal ini sangat menjaga keutuhan program yang telah dibuat dengan konsep dan rencana yang sudah ditentukan dari awal. Enkapsulasi menciptakan abstraksi untuk desain kelas. Jika Anda ingin melindungi beberapa anggota dari kelas dasar maka timbullah situasi enkapsulasi. Dalam konsep ini ada tiga kata kunci yang digunakan. Konsep hak akses ini biasa di sebut Access Modifier.
3.2        Access Modifier terdiri dari private, protected, dan public
Ø  Private memberikan hak akses hanya kepada anggota class tersebut untuk menggunakan dan/atau mengubah nilai dari property atau method tersebut.
Ø  Protected memberikan hak akses kepada anggota class nya dan anggota class hasil inheritance (penurunan sifat) dari class tersebut.
Ø  Public memberikan hak akses kepada property dan method agar dapat digunakan diluar class tersebut

Contoh Program :

class enkapsulasi{                                                          
            public String Nama;
            public String NPM;
            public String Kelas;
            private int nilaiku;
            public void setNilai (int nilai){
                        nilaiku=nilai;
            }
            public int getNilai(){
                        return nilaiku;
            }
}
class coba{
            public static void main(String [] args){
                        enkapsulasi Biodata = new enkapsulasi();
                        Biodata.Nama = "Derendra";
                        Biodata.NPM = "51410814";
                        Biodata.Kelas = "2IA08";
                        Biodata.setNilai(90);
                        System.out.println("Nama  = "+ Biodata.Nama);
                        System.out.println("NPM   = "+ Biodata.NPM);
                        System.out.println("Kelas = "+ Biodata.Kelas);
                        System.out.println("Nilai = "+ Biodata.getNilai());
            }
}
Logika Program :

Pada kelas enkapsulasi deklarasikan variabel Nama, NPM dan Kelas yang bertipe String ke dalam Access Modifier Public. Sedangkan untuk nilaiku yang bertipe data integer dipakai Access Modifier Private. Lalu seting variabel nilaiku dengan perintah setNilai (int nilai) dengan tambahan variabel nilai untuk memasukkan angka nilai yang akan diberikan, dan terakhir ambil harga nilai tersebut dengan perintah getNilai() yang akan otomatis menjadi nilai dari variabel nilaiku dengan perintah return nilaiku;Lalu buat method dari kelas enkapsulasi tersebut untuk menampilkan data yang telah dimasukkan.




Output:
Nama = Derendra
Kelas = 2IA08
NPM = 51410814
Nilai = 90




1.7    Inheritance/Pewarisan
Inheritance adalah konsep pemrograman berorientasi object yang memungkinkan membuat hubungan di mana ada class yang mewarisi semua attribute dan method dari class lain. Class baru yang lebih spesifik disebut subclass atau class turunan, sedangkan class yang diturunkan disebut superclass. Untuk menguji suatu kasus disebut inheritance atau tidak, dapat menggunakan kata kunci “IS A”. (Namun, pengujian ini hanya berlaku searah (dari subclass ke superclass))
Contoh :

Mamalia: (berdaun teling, beranak, menyusui). Contohnya: Anjing, kucing, marmut
Pengujiaannya: marmut IS A mamalia.
Kendaraan (mempunyai kemudi) contohnya: mobil, motor, pesawat terbang
Pengujiannya: motor IS A kendaraan

Praktek 1 (Extends)

Untuk membuat class turunan, digunakan keyword extends. Strukturnya seperti dibawah ini:
public class [nama SubClass] extends [nama SuperClass]{}

Contoh: public class Kamus extends Buku{}

Saat ini, kita akan mencoba membuat program yang menerapkan prinsip inheritance

1. Program yang menjadi subClass dengan menggunakan kata kunci extends.

class B extends A {
int z;
void getJumlah(){
System.out.println(“jumlah:”+ (x+y+z));
}
}
3. Buatlah class testernya

class InheritanceTest{
public static void main(String [] args)
{
A ortu = new A();
B anak = new B();
System.out.println(“superclass”);
ortu.x=10;
ortu.y=20;
ortu.getNilai();
System.out.println(“sub Class”);
anak.x=5;
anak.y=4;
anak.getNilai();
anak.z=50;
anak.getJumlah();
}
}

Dari kode program diatas, kita dapat melihat bahwa bahwa method getNilai() muncul pada class B. Padahal kita tidak melihat adanya method getNilai() di class B. Hal ini membuktikan bahwa terdapat proses inheritance dari class A ke class B. Hubungan ini bersifat generalization dimana ClassChild mempunyai semua sifat dari ClassParent. Oleh karena itu, pada ClassChild cukup ditambahkan bagian yang memang merupakan spesifik milik classChild. Dari program sederhana ini pula, kita mendapatkan keuntungan dari inheritance. Kita tidak perlu menambah atribut x dan y ataupun method getHasil() pada class B. Kita hanya cukup menggunakan apa yang sudah ada di class A , atau dengan kata lain,kita telah menerapkan prinsip “reuse of code”. Perlu diketahui: Java tidak mengizinkan pewarisan berganda. Misalkan class aku diturunkan dari class ayah dan class ibu. Pewarisan berganda ini bisa dilakukan di C++.

Praktek 2 (Hak Akses)

Pada program diatas, setiap atribut yang digunakan bertipe default. Dengan kata lain, atribut pada program diatas tidak terenkapsulasi sehingga dengan mudah kita dapat mengisi nilai x dan y tanpa mengakses method apapun dari luar class A maupun B. Pada pertemuan sebelumnya, kita diajarkan untuk melakukan enkapsulasi dengan menggunakan hak akses yang bertipe private. Sekarang, ubahlah program diatas menjadi seperti dibawah ini:

class B extends A {
private int z;
public void getJumlah(){
System.out.println(“jumlah:”+ (x+y+z));
}
public void setZ(int z){
this.z = z;
}
}
class A {
private int x;
private int y;
public void setX(int x){
this.x = x;
}
public void setY(int y){
this.y = y;
}
public void getNilai(){
System.out.println(“nilai x:”+ x +” nilai y:” + y);
}
class InheritanceTest{
public static void main(String [] args)
{
A ortu = new A();
B anak = new B();
System.out.println(“superclass”);
ortu.setX(10);
ortu.setY(20);
ortu.getNilai();
System.out.println(“sub Class”);
anak.setX(5);
anak.setY(4);
anak.getNilai();
anak.setz(50);
anak.getJumlah();
}
}

Compile program!

                        Seperti yang telah kita bahas kemarin, terdapat 5 jenis hak akses. Error tersebut terjadi karena kita mendefinisikan atribut x dan y sebagai private. Ingat, private hanya bisa diakses di classnya. Tetapi tidak di class lain, bahkan di class turunannya sendiri. Coba ganti hak akses dari atribut2 A dan B menjadi protected. Kemudian compile program yang Anda buat tadi. Catatan: Agar tetap menjaga konsistensi enkapsulasi, maka akses terhadap super class dari sub class pada bagian attribute-nya tidak terlepas dari access control protected. Hal ini digunakan untuk menjaga agar attribute hanya dapat diakses oleh class yang menjadi turunannya saja.
Praktek 3

1. Sebuah class lagi yang mewarisi class B, misalkan class C:

class C extends B {
protected int w;
public void setW( int w){
this.w = w;
}
public void getW(){
System.out.println(“nilai w :”+ w);
}
}

2. Ubah class InheritanceTest menjadi seperti dibawah ini:

class InheritanceTest{
public static void main(String [] args)
{
A ortu = new A();
B anak = new B();
C cucu = new C();
System.out.println(“superclass”);
ortu.setX(10);
ortu.setY(20);
ortu.getNilai();
System.out.println(“sub Class”);
anak.setX(5);
anak.setY(4);
anak.getNilai();
anak.setz(50);
anak.getJumlah();
System.out.println(“sub Class2”);
cucu.setX(5);
cucu.setY(4);
cucu.getNilai();
cucu.setz(50);
cucu.getJumlah();
cucu.setW();
cucu.getW();
}
}
Praktek 4 (Super)

Jika keyword this digunakan untuk membedakan variabel local dengan atribut suatu objek, maka untuk membedakan atribut superclass dengan atribut subclass digunakan keyword super.

Contoh program

class Bentuk {
protected int p,l;
}
class Persegi extends Bentuk {
protected int p,l;
public void setSuperP(int p){
super.p = p;
}
public void setSuperL(int l){
super.l = l;
}
public void setP(int p){
this.p = p;
}
public void setL(int l){
this.l = l;
}
public void getLuas(){
System.out.println("Luas super:"+(super.l*super.p));
System.out.println("Luas:"+ (this.l*this.p));
}
}
class PersegiTest {
public static void main(String[] args){
Persegi kotak=new Persegi();
kotak.setSuperP(5);
kotak.setSuperL(10);
kotak.setP(3);
kotak.setL(13);
kotak.getLuas();
}
}
Catatan :
Keyword super digunakan untuk merefer ke superclass dari class yang bersangkutan.  Terlihat di output bahwa luas super dengan luas subclassnya berbeda.
Praktek 5 (super constructor)

Untuk pengaksesan constructor method dari super class, digunakan bentuk sebagai berikut :

super (argumen1, argumen2, …) ;
contoh  program
class A{
A(){
System.out.println("konstruktor A dieksekusi");
}
}
class B extends A{
B(){
System.out.println("konstruktor B dieksekusi");
}
}
class C extends B{
C(){
System.out.println("konstruktor C dieksekusi");
}
}
class ConstructorTest{
public static void main(String[] args){
C coba=new C();
}
}

Compile ulang class A, B dan C serta ConstructorTest.

Dari percobaan diatas, ada beberapa hal yang perlu diingat dalam penggunaan super constructor, yaitu :
1. Sebenarnya, java menambahkan pemanggilan super secara default ketika kita tidak             memanggil constructor super di subclassnya tetapi, jika pada superclass tidak    terdapat constrructor default atau constructor yang tidak menggunakan parameter, maka kita harus melakukan pemanggilan salahasatu constructor pada subclassnya,    sesuai dengan constructor yang ada pada superclassnya.
2. Pemanggilan super() harus terletak pada pernyataan baris pertama dalam sebuah                 constructor.
3. Pemanggilan super() hanya bisa dilakukan pada constructor.
4. Hal ini mengimplikasikan bahwa this() dan super() yang dipanggil tidak dapat        dinyatakan dalam constructor yang sama.

Praktek 6 (overriding method)

Buatlah class

class A{
public void show(){
System.out.println("Method show milik class A dipanggil");
}
}
class B extends A{
public void show(){
System.out.println("Method show milik class B dipanggil");
}
}
class OverridingTest{
public static void main(String[] args){
B coba = new B();
coba.show();
}
}

Compile ketiga program diatas.

method mana yang dipanggil oleh class B?
Dalam program tersebut terdapat 2 method dengan nama yang sama walaupun dalam class yang berbeda. Contoh program tersebut merupakan aplikasi dari Overriding. Ketika dalam suatu subclass, kita mendefinisikan method yang sama dengan superclassnya, maka, method dalam subclass tersebut dikatakan meng-override superclassnya. Sehingga, method yang dipanggil bukan lagi method milik superclass, tetapi miliknya sendiri (subclass)
Lalu, bagaimana cara memanggil method superclassnya?
Ubah code class B menjadi seperti berikut:

class B extends A {
public void show(){
super.show();
System.out.println("Method show milik class B dipanggil");
}
}

Praktek 7 (Final)

Contoh program  class 

class Lingkaran{
final public double PI = 3.14;
protected double r;
public void setR( double r){
this.r=r;
}
public void getLuas(){
System.out.println("Luas Lingkaran="+(this.PI*r*r));
}
}
class LingkaranTest{
public static void main(String[] args){
Lingkaran bunder=new Lingkaran();
bunder.PI=4;
bunder.setR(10);
bunder.getLuas();
}
}

Compile kedua program.

Final keyword, adalah penentu akses yang dapat diterapkan pada instance variable atau pada method, di mana akan menjadikan : Suatu instance variable, akan dibuat menjadi konstanta. Suatu method, akan dibuat menjadi tidak dapat di-override pada sublassnya.
Jadi, final keyword dalam hal ini dapat digunakan untuk memberikan batasan  lebih (selain akses control) terhadap pengaksesan attribute maupun method suatu class terhadap class turunannya.

1.8    Polymorphism
Polymorphism adalah suatu cara membuat objek-objek yang berasal dari subclass yang berbeda, agar diperlakukan sebagai objek-objek dari satu  superclass. dimana obyek yang berbeda memberikan tanggapan/respon terhadap pesan yang sama sesuai dengan sifat masing-masing obyek. Polymorphism  juga dapat disamakan dengan Method Overloading, dimana di dalam sebuah class terdapat beberapa method dengan nama sama.
Kondisi yang harus dipenuhi supaya polimorphism dapat diimplementasikan adalah :
·      Method yang dipanggil harus melalui variabel dari basis class atau superclass.
·      Method yang dipanggil harus juga menjadi method dari basis class.
·      Signature method harus sama baik pada superclass maupun subclass.
·      Method access attribute pada subclass tidak boleh lebih terbatas dari basis class.

Berikut ini gambar dari coding Polymorphism pada Main.java

Berikut ini merupakan coding Polymorphism  pada class CetakDataTipe


1.9    Abstract class
Abstract class dalam java digunakan untuk mendeklarasikan karakteristik umum dari subclass. Abstract class tidak bisa diinstansiasi sama halnya dengan kelas interface. abstract class hanya bisa digunakan sebagai super class, tapi juga bisa diturunkan dari class abstract lainnya. Untuk mendeklarasikan sebuah abstract class digunakan keyword abstract, [abstract] class [class_name] Sebuah abstract class pada dasarnya tidak hauh beda dengan class lainnya, yakni juga berisi method yang menggambarkan carakteristik dari kelas abstract tersebut, bedanya yakni sebuah abstract class bisa berisi method tanpa diimplementasikan artinya sebuah method tanpa body, methid seperti ini disebut method abstract. untuk pendeklarasiannya digunakan keyword abstract: [abstract] modifier class [class_name] berikut contoh program yang menggunakan class abstract

abstract class Shape {
public String color;
 //constractor default, constraktor yang tidak memiliki argumen dan isi
public Shape() {
}
 //sama halnya dengan kelas biasa abstract class juga bisa berisi method
 //seperti yang ada pada kelas biasa
public void setColor(String c)
{ color = c; }
public String getColor(){
 return color;
}
//sebuah abstract method yang tidak memiliki body
//method ini akan diinisialisasi nantinya pada subclass yang mewarisi kelass abstract Shape ini //semua abstract method yang ada pada class abstract harus diimplementasikan
//semua oleh subclass
abstract public double area();
}
//keyword extends adalah keyword yang digunakan oleh subclass
//ketika melakukan pewarisan terhada super class
public class Point extends Shape {
static int x, y;
public Point(){
x = 0;
y = 0;
}
public double area() {
return 0;
}
public double perimeter() {
return 0;
}
public static void print() {
System.out.println("point: " + x + "," + y);
}
public static void main(String args[]) {
Point p = new Point();
p.print(); }
}

Output
point: 0, 0














1.10 Konsep Interface
Interface adalah kumpulan method yang hanya memuat deklarasi dan struktur method tanpa detail implementasinya. Sebuah interface bukan merupakan class dan kelas hanya bisa mengimplementasi interface, jadi interface bukan merupakan super class yang memiliki class turunan. Berikut merupakan cara mengimplementasikan interface :


Dalam pemrogaraman OOP, untuk mengimplementasi interface harus menggunakan keyword implements. Berikut merupakan cara mengimplementasikan interface kedalam pemrograman java :


Diposting oleh di

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)