Encapsulation
Encapsulation
merupakan cara membungkus data dan method yang menyusun kelas dan
menyembunyikannya dari dunia luar. Jika kita telah melakukan information hiding
terhadap suatu attribut pada suatu class, lalu bagaimana cara melakukan
perubahan terhadap attribut yang kita sembunyikan tersebut, caranya adalah
dengan membuat suatu interface berupa method untuk menginisialisasi atau
merubah nilai dari suatu attribut tersebut.
Berikut
ini keuntungan dari prinsip encapsulation :
- Bersifat
independen. Suatu modul yang terenkapsulasi dengan baik akan bersifat
independen dari yang lain. Sehingga dapat digunakan pada bagian manapun
dari program.
- Bersifat
transparan. Jika Anda melakukan modifikasi pada suatu modul, maka
perubahan tersebut akan dirasakan oleh semua bagian yang menggunakan modul
tersebut.
- Menghindari dari
efek yang diluar perencanaan. Modul yang terenkapsulasi dengan baik hanya
akan berinteraksi dengan bagian program melalui variable input dan output
yang telah didefinisikan sebelumnya. Sehingga dapat mengurangi kemungkinan
bug.
Kesimpulan
:
Tujuan
encapsulation adalah untuk menyembunyikan atau memproteksi suatu proses dari
kemungkinan interfensi atau penyalahgunaan dari luar system dan sekaligus
menyederhanakan system itu sendir
Information Hiding
Information Hiding adalah menyembunyikan attribute dan method
suatu objek dari objek lain. Encapsulation adalah menyembunyikan atribute suatu
objek dari objek lain. Attribute maupun method disembunyikan dengan cara
memberikan modifier private.
Method dalam kelas yang sama, yang memberikan nilai pada
attribute private disebut method setter, sedangkan method masih dalam kelas yang sama, yang mengambil
nilai dari attribute private disebut getter.
Inheritance
Inheritance
dalam java Salah satu bagian penting dalam object oriented programming adalah
inheritance / pewarisan. Inheritance adalah proses pewarisan data dan method
dari suatu class kepada class yang lain. Secara default inheritance bersifat
menyeluruh sehingga semua data dan method diturunkan kepada class yang baru.
Kelas yang mewariskan disebut dengan super class sedangkan class turunan
disebut dengan sub class.
Keuntungan
dari inheritance
•
Bersifat reusable. Bayangkan bila anda perlu membuat beberapa class yang
mempunyai sifat dasar dan basis class yang sama, dan pada masing masing class
tersebut ditambahkan data dan method yang unique. Tanpa inheritance anda harus
menyalin semua data dan method dari suatu class.
•
Kemudahan dalam me-manage kelas yang memiliki data dan method yang sama. Jika
anda ingin melakukan modifikasi suatu data atau method pada semua sub class
anda tidak perlu melakukan perubahan pada masing masing sub class. Modifikasi
cukup dilakukan pada super class.
Dalam
inheritance dikenal dengan istilah overriding. Overidding adalah kemampuan sub
class untuk melakukan modifikasi data dan method dari super class. Sebelum anda
melakukan overidding terhadap method atau data dari class induk, Harus memperhatikan
aksesibelitas dari data dan method dari super class.[ overidding hanya bisa
dilakukan untuk data dan method yang memiliki modifier default, public dan
protected.]
Note.
- Untuk melakukan
inheritance digunakan keyword extends
- Dalam java hanya
mendukung single inheritance
- data dengan
modifier private tidak diwariskan ke sub class
- constructor
super class tidak diwariskan ke sub class
Semua attribute dan method dari suatu kelas super dapat
diwariskan ke subkelas. Dalam hirarki kelas, jika kelas C merupakan turunan
kelas B, dan kelas B merupakan turunan kelas A, maka otomatis attribute dan
method kelas A juga diwariskan kelas C.
Bentuk pewarisan :
[modifier] class namaSubKelas extend
namaKelasSuper {
// classBody
}
Manfaat Pewarisan
Tanpa inheritance, maka semua attribute dan method yang pernah
dibuat dan bituhkan kelas lain, harus ditulis ulang seluruhnya. Dengan
inheritance, seorang programmer ingin memodifikasi suatu attribute atau method
yang dimanfaatkan subkelas, maka dilakukan modifikasi attribute dan
method tersebut pada kelas supernya.
Catatan :
Kalau method cetak() di kelas Employee dan kelas Manager ada,
maka yang
dijalankan adalah method milik kelas Manager. Prioritasnya
adalah kelas Manager
kemudian kelas Employee.
Polymorphism
Setelah inheritance, hal yang
penting bagi object oriented programming adalah polymorphism. Secara leksikal
polymorphism merupakan sesuatu yang mempunyai banyak bentuk. Dalam pemrograman
polymorphism merupakan dapat diartikan suatu modul yang mempunyai nama sama,
tapi memiliki behavior yang berbeda sehingga listing code implementasinya
berbeda. Dan dalam bahasa yang lain adalah kemampuan dari reference untuk
mengubah sifat sesuai dengan object yang dijadiin acuan. Polymorphism menyediakan
menyediakan multiobject dari sub class yang berbeda diperlakukan sebagai object
tunggal dari super class.
Latihan Praktikum :
public class SuperClass{
public
SuperClass() {
System.out.println("Ini
konstruktor milik SuperClass");
}
public
void methodSuperClass() {
System.out.println("Ini
method milik SuperClass");
}
}
public class SubClass extends
SuperClass {
public
SubClass() {
super();
}
public
void methodSubClass() {
super.methodSuperClass();
}
}
public class DemoInheritance{
public
static void main(String[] args) {
SubClass
sc = new SubClass();
sc.methodSubClass();
}
}
Outputnya :
public class Persegi {
private
double panjang;
private
double lebar;
private
double tinggi;
public
Persegi() {
panjang
= 0;
lebar
= 0;
}
private
double luas(double p, double l) {
return
p*l;
}
public
void setPanjang(double panjang1) {
this.panjang
= panjang1;
}
public
void setLebar(double lebar1) {
this.lebar
= lebar1;
}
public
double getPanjang() {
return
panjang;
}
public
double getLebar() {
return
lebar;
}
public
double getLuas() {
return
luas(panjang, lebar);
}
}
public class MainPersegi {
public
static void main(String[] args) {
Persegi
pg = new Persegi();
pg.setPanjang(10);
pg.setLebar(20);
System.out.println("Panjang
: "+pg.getPanjang());
System.out.println("Lebar
: "+pg.getLebar());
System.out.println("Luas
: "+pg.getLuas());
}
}
Outputnya adalah :
abstract class Karyawan {
int
gaji;
Karyawan()
{
gaji
= 1000000;
}
int
getGaji() {
return
gaji;
}
abstract
void naikGaji();
}
class Manager extends Karyawan {
Manager()
{
gaji
+= 2000000;
}
void
naikGaji() { gaji+=3000000; }
}
class Receptionist extends
Karyawan {
Receptionist()
{
gaji
+= 1000000;
}
void
naikGaji() { gaji+=3000000; }
}
class Polymorphisme {
public
static void main(String[] args) {
Karyawan
K[] = new Karyawan [3];
K[0]
= new Manager();
K[1]
= new Receptionist();
K[2]
= new Manager();
for
(int i=0;i<3;i++)
System.out.println("Gaji
karyawan "+i+" adalah"+K[i].getGaji());
for
(int i=0;i<3;i++)
K[i].naikGaji();
for
(int i=0;i<3;i++)
System.out.println("Gaji
sekarang "+i+" adalah"+K[i].getGaji());
}
}
Outputnya adalah :
