KONSEP DASAR PADA OOP (OBJECT ORIENTED PROGRAMMING)
1. Enkapsulasi ( Pembungkusan )
2. Inheritance ( Pewarisan )
3. Polymorphism ( Perbedaan Bentuk )
1. ENKAPSULASI (PEMBUNGKUSAN)
Enkapsulasi adalah suatu cara untuk meyembunyikan implementasi detail dari class untuk mencegah akses yang ilegal. Ada dua hal yang mendasar dari enkapsulasi yaitu information hiding dan interface to access data. Berikut sedikit penjesalan dari hal diatas. Information hiding adalah menyembunyikan informasi dari suatu class agar tidak bisa diakses dari luar class, caranya hanya dengan memberikan modifier private pada varibel yang ingin kita hiding. Selanjutnya mengenai interface to acces data, ialah cara kita untuk mengubah nilai pada suatu variabel yang telah dilakukan information hiding. Cara yang biasa dilakukan adalah melalui method, lewat method ini kita bisa merubah nilai suatu variabel yang telah mengalami information hiding.
Enkapsulasi tersebut terdiri dari tiga jenis yaitu public, protected, dan private.
1. Public
Merupakan kata kunci yang digunakan dalam java yang memungkinkan setiap variabel dan method yang di deklarasikan dalam class public dapat di akses oleh semua class yang sama, subclass atau non subclass yang sama di package yang sama, subclass dan non subclass di package yang berbeda.
2. Protected
Merupakan kata kunci yang di deklarasikan untuk memproteksi suatu class agar setiap variabel dan method yang dideklarasikan tidak dapat di akses oleh non subclass di dalam package yang sama. Dalam class protected, yang dapat mengakses variabel dan method nya adalah jika methodnya berada pada classnya sama, subclass dan non sub yang sama di package yang sama, dan subclass di package yang berbeda.
3. Private
Merupakan kata kunci yang dideklarasikan dalam suatu class agar setiap variabel dan method yang berada dalam class private ini hanya dapat diakses oleh class yang sama. Didalam bahasa pemgrograman java class yang bersifat private memproteksi agar semua variabel dan methodnya tidak dapat di akses oleh semua subclass dan non subclass di package yang sama, dan subclass dan non subclass di package yang berbeda.
Berikut ini sebuah program Java Tentang enkapsulasi yang terdiri dari 3 jenis diatas.
1. Berikut ini berupa class - class yang dibutuhkan pada program tersebut, Terdiri dari class main.java dan website.java.
2. Selanjutnya berikut ini script yang ada pada class main.java, disitu tertera beberapa script yang dibutuhkan untuk memanggil atau bisa dikatakan untuk outputnya, biasanya langkah ini dilakukan ketika setelah selesai membuat script intinya dahulu
3. Ini adalah script yang ada pada class website.java, ini merupakan class intinya, dimana kita mendeklarasikan string yang dibutuhkan , serta menentukan jenis enkapsulasi yang diperlukan, baik itu public, protected maupun private
4. Berikut ini outputnya dari package website tersebut, di outputnya tertera nama nic admin, nama aslinya , serta passwordnya.
Untuk catatan, ketika akan memanggil string maupun integer yang berjenis enkapsulasi
private, kita harus menuliskan pada script mainnya seperti ini.
System.out.println("Nama Asli Admin :"+data.getnama());
Agar bisa class main tersebut mengambil data pada class website.
Untuk yang protected, seperti yang dijabarkan diatas "yang dapat mengakses variabel dan method nya adalah jika methodnya berada pada classnya sama, dst".
2. INHERITANCE (PEWARISAN)
Konsep inheritance ini mengadopsi dunia riil dimana suatu entitas/obyek dapat mempunyai entitas/obyek turunan. Dengan konsep inheritance, sebuah class dapat mempunyai class turunan. Suatu class yang mempunyai class turunan dinamakan parent class atau base class. Sedangkan class turunan itu sendiri seringkali disebut subclass atau child class. Suatu subclass dapat mewarisi apa-apa yang dipunyai oleh parent class. Karena suatu subclass dapat mewarisi apa apa yang dipunyai oleh parent class-nya, maka member dari suatu subclass adalah terdiri dari apa-apa yang ia punyai dan juga apa-apa yang ia warisi dari class parent-nya. Kesimpulannya, boleh dikatakan bahwa suatu subclass adalah tidak lain hanya memperluas (extend) parent class-nya.
Dari hirarki diatas dapat dilihat bahwa, semakin kebawah, class akan semakin bersifat spesifik. Class mamalia memiliki seluruh sifat yang dimiliki oleh binatang, demikian halnya juga macan , kucing, Paus dan Monyet memiliki seluruh sifat yang diturunkan dari class mamalia. Dengan konsep ini, karakteristik yang dimiliki oleh class binatang cukup didefinisikan dalam class binatang saja. Class mamalia tidak perlu mendefinisikan ulang apa yang telah dimiliki oleh class binatang, karena sebagai class turunannya, ia akan mendapatkan karakteristik dari class binatang secara otomatis. Demikian juga dengan class macan, kucing, Paus dan monyet, hanya perlu mendefinisikan karakteristik yang spesifik dimiliki oleh class-nya masing-masing. Dengan memanfaatkan konsep pewarisan ini dalam pemrograman, maka hanya perlu mendefinisikan karakteristik yang lebih umum akan didapatkan dari class darimana ia diturunkan.
2.1. DEKLARASI PEWARISAN (INHERITANCE)
Deklarasi yang digunakan adalah dengan menambahkan kata kunci extends setelah deklarasi nama class, kemudian diikuti dengan nama parent class-nya. Kata kunci extends tersebut memberitahu kompiler Java bahwa kita ingin melakukan perluasan class.
public class B extends A { … }
Pada saat dikompilasi, Kompiler Java akan membacanya sebagai subclass dari class Object.
public class A extends Object { … }
2.2. KAPAN KITA MENERAPKAN INHERITANCE?
Kita baru perlu menerapkan inheritance pada saat kita jumpai ada suatu class yang dapat diperluas dari class lain.
Misal terdapat class Pegawai public class Pegawai { public String nama; public double gaji; }
Misal terdapat class Manager public class Manajer { public String nama; public double gaji;public String departemen; }
Dari 2 buah class diatas, kita lihat class Manajer mempunyai data member yang identik sama dengan class Pegawai, hanya saja ada tambahan data member departemen. Sebenarnya yang terjadi disana adalah class Manajer merupakan perluasan dari class Pegawai dengan tambahan data member departemen. Disini perlu memakai konsep inheritance, sehingga class Manajer dapat kita tuliskan seperti berikut :
public class Manajer extends Pegawai { public String departemen; }
2.3. KEUNTUNGAN INHERITANCE
1. Subclass menyediakan state/behaviour yang spesifik yang membedakannya dengan superclass, hal ini akan memungkinkan programmer Java untuk menggunakan ulang source code dari superclass yang telah ada.
2. Programmer Java dapat mendefinisikan superclass khusus yang bersifat generik, yang disebut abstract class, untuk mendefinisikan class dengan behaviour dan state secara umum.
2.4. ISTILAH INHERITANCE
1. Extends
Keyword ini harus kita tambahkan pada definisi class yang menjadi subclass.
2. Superclass
Superclass digunakan untuk menunjukkan hirarki class yang berarti class dasar dari subclass/class anak.
3. Subclass
Subclass adalah class anak atau turunan secara hirarki dari superclass.
4. Super
Keyword ini digunakan untuk memanggil konstruktor dari superclass atau menjadi variabel yang mengacu pada superclass.
5. Methode Overriding
Pendefinisian ulang method yang sama pada subclass. Dalam inheritance, method overriding berbeda dengan method overloading. Kalau method overriding adalah mendefinisikan kembali method yang sama, baik nama method maupun signature atau parameter yang diperlukan dalam subclass, kalau method overloading adalah mendefinisikan method yang memiliki nama yang sama, tetapi dengan signature yang berbeda dalam definisi class yang sama.
2.5. CONTOH PROGRAM INHERITANCE
Class Motor
public class Motor {
private String merek,jenis,warna;
public String getmerek(){
return merek;
}
public void setmerek(String merek){
this.merek=merek;
}
public String getjenis(){
return jenis;
}
public void setjenis(String jenis){
this.jenis=jenis;
}
public String getwarna(){
return warna;
}
public void setwarna(String warna){
this.warna=warna;
}
public void tampilkandata(){
System.out.println("Merek Motor : "+getmerek());
System.out.println("Jenis Motor : "+getjenis());
System.out.println("Warna Motor : "+getwarna());
}
public void inputdata(String m,String j,String w){
setmerek(m);
setjenis(j);
setwarna(w);
}
}
Class Honda
public class Honda extends Motor{
public void tampilkan(){
String bahanbakar="Premium";
Motor m=new Motor();
m.inputdata("Blade", "Bebek", "Hitam");
m.tampilkandata();
System.out.println("Jenis Bahan Bakar : "+bahanbakar);
}
}
Class Yamaha
public class Yamaha extends Motor{
public void tampilkan(){
String bahanbakar="Premium";
Motor m=new Motor();
m.inputdata("Mio", "Matic", "Putih");
m.tampilkandata();
System.out.println("Jenis Bahan Bakar : "+bahanbakar);
}
}
Class Main
public class Main {
public static void main(String[] args) {
System.out.println("HONDA");
Honda h=new Honda();
h.tampilkan();
System.out.println("\nYAMAHA");
Yamaha t=new Yamaha();
t.tampilkan();
}
}
Run pada Class Main maka output dari program diatas adalah sebagai berikut :
3. POLYMORFHISM (PERBEDAAN BENTUK)
Polymorphism merupakan salah satu konsep penting dalam object oriented programming (OOP) khususnya di bahasa pemrograman Java setelah enkapsulasi dan inheritance. Polymorphism berarti banyak bentuk. Ada beberapa definisi berbeda tentang polymorphism yang berkaitan dengan pemrograman berorientasi obyek. Sedangkan apa yang dimaksud dengan polymorphism sendiri, sebenarnya sulit untuk didefinisikan. Sejalan dengan contoh yang diberikan, Anda diharapkan dapat mengerti dan memahami konsep polymorphism itu sendiri.
Polymorphism sering dikaitkan dengan penggunaan lebih dari satu metode dengan nama sama. Penggunaan metoda dengan nama sama dapat diterapkan dengan method overloading dan method overriding. Peran polymorphism sebenarnya tidak terbatas hanya pada hal tersebut. Ada keterkaitan antara polymorphism dan inheritance (turunan).
Dalam konsep turunan, saat obyek dari subclass dikonstruksi, obyek dari superclass juga ikut dikonstruksi. Jadi setiap instance dari subclass adalah juga instance dari superclass. Apabila Anda mendeklarasikan metoda dengan parameter dari tipe superclass, Anda diperbolehkan untuk memberi argumen berupa obyek subclass yang merupakan turunan dari superclass tersebut.
Berikut ini adalah contoh program yang dapat memberikan gambaran terkait konsep polymorphism.
Class Hewan
public class Hewan{
String jenis;
String ciri;
public void suara(){
System.out.println("Suara Hewan");
}
public void berjalan(){
System.out.println("Cara berjalan hewan");
}
Class Elang
class Elang extends Hewan{
public void suara(){
System.out.println("Ieoookkkk");
}
public void berjalan(){
System.out.println("Terbang");
System.out.println("================================");
}
}
}
Class Lebah
class Lebah extends Hewan{
public void suara(){
System.out.println("Wungggg");
}
public void
berjalan(){
System.out.println("Terbang");
System.out.println("================================");
}
}
Class Paus
class Paus extends Hewan{
public void suara(){
System.out.println("Boooom");
}
public void berjalan(){
System.out.println("Berenang");
System.out.println("================================");
}
}
Class Singa
class Singa extends Hewan{
public void suara(){
System.out.println("WaouWaou");
}
public void berjalan(){
System.out.println("Berlari");
System.out.println("================================");
}
}
Class Main
public class Main {
public static void main(String [] asdasd){
Lebah HewanLebah = new Lebah();
Paus HewanPaus = new Paus();
Singa HewanSinga = new Singa();
Elang HewanElang = new Elang();
Hewan h;
System.out.println("Lebah");
h = HewanLebah;
h.suara();
h.berjalan();
System.out.println("Singa");
h = HewanSinga;
h.suara();
h.berjalan();
System.out.println("Elang");
h = HewanElang;
h.suara();
h.berjalan();
System.out.println("Paus");
h = HewanPaus;
h.suara();
h.berjalan();
}
}
Output dari program diatas adalah sebagai berikut :
