Information Hiding dan Encapsulation
Information Hiding adalah menyembunyikan
attribute suatu objek dari objek lain.
Encapsulation adalah menyembunyikan method
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.
// Contoh program Information Hiding dan Encapsulation
public class PersegiPanjang{
private double panjang; // attribute yg di hide
private double lebar; // attribute yg di hide
private double tinggi; // attribute yg di hide
public PersegiPanjang() {
panjang = 0;
lebar = 0;
}
private double luas(double p, double l) { // di encap
return p*l;
}
public void setPanjang(double panjang) {
this.panjang = panjang;
}
public void setLebar(double lebar) {
this.lebar = lebar;
}
public double getPanjang() {
return panjang;
}
public double getLebar() {
return lebar;
}
public double getLuas() {
return luas(panjang, lebar);
}
}
public class MainPersegiPanjang {
public static void main(String[] srgs) {
PersegiPanjang pp = new PersegiPanjang();
pp.setPanjang(10);
pp.setLebar(20);
System.out.println(”Panjang : ”+ pp.getPanjang());
System.out.println(”Lebar : ”+ pp.getLebar());
System.out.println(”Luas : ”+ pp.getLuas());
}
}
## Pewarisan (inheritance)
Semua class dalam Java, termasuk class yang membangun Java API, merupakan subclass dari superclass Object.
Contoh dari hierarki class :
Superclass
Adalah class yang letaknya di atas class tertentu di dalam hierarki.
Subclass
Adalah class yang letaknya di bawah class tertentu di dalam hierarki.
Pengaplikasian
— Untuk mengambil sebuah class, gunakan keyword extends.
— Untuk lebih jelasnya, mari buat class parent sederhana, misalkan kita mempunyai class parent bernama Person.
public class Person {
protected String name;
protected String address;
/**
* Default constructor
*/
public Person(){
System.out.println(“Inside Person:Constructor”);
name = “”; address = “”;
}
. . . .
}
— Sekarang, kita buat class lain bernama Student
— Karena murid juga termasuk orang, kita putuskan untuk meng-extend class Person, sehingga kita dapat mewariskan semua properti dan method yang telah ada di class Person.
— Untuk itu, kita bisa menulis :
public class Student extends Person {
public Student(){
System.out.println(“Inside Student:Constructor”);
}
. . . .
}
— Ketika sebuah object Student diinstansiasi, default constructor dari superclass Student dipanggil secara implisit untuk melakukan inisialisasi seperlunya.
— Setelah itu, pernyataan di dalam constructor subclass dijalankan.
— Untuk memperjelasnya, perhatikan kode dibawah ini:
public static void main( String[] args ){
Student anna = new Student();
}
— Dalam kode ini, kita membuat sebuah object dari class Student. Hasil dari program adalah:
Inside Person:Constructor
Inside Student:Constructor
Keyword “super”
— Sebuah subclass dapat juga memanggil secara eksplisit sebuah constructor superclass yang ada diatasnya.
— Dapat dilakukan dengan menggunakan pemanggilan constructor super.
— Pemanggilan constructor super didalam constructor subclass akan mengakibatkan eksekusi dalam constructor yang relevan dari superclass, berdasarkan passing argument-nya.
— Sebagai contoh, pada contoh sebelumnya yaitu class Person dan Student, kita tunjukkan sebuah contoh pemanggilan constructor super.
— Tuliskan kode berikut untuk class Student
public Student(){
super( “SomeName”, “SomeAddress” );
System.out.println(“Inside Student:Constructor”);
}
Beberapa hal untuk diingat ketika menggunakan pemanggilan constructor super :
◦ Pemanggilan super() HARUS DIJALANKAN SESUAI DENGAN STATEMENT PERTAMA DALAM SEBUAH CONSTRUCTOR.
◦ Pemanggilan super() hanya dapat digunakan di dalam definisi constructor.
◦ Hal ini menjelaskan bahwa constructor this() dan pemanggilan super() TIDAK DAPAT DIJALANKAN SECARA BERSAMAAN DI DALAM CONSTRUCTOR YANG SAMA.
Penggunaan lainnya dari super mengarah pada member dari superclass.
Sebagai contoh,
public Student() {
super.name = “somename”;
super.address = “some address”;
}
Meng-override method
— Jika sebuah subclass menginginkan implementasi yang berbeda terhadap method dari superclassnya, maka salah satu caranya dapat dilakukan dengan meng-override method bersangkutan.
— Sebuah subclass dapat meng-override method superclassnya dengan menyediakan sebuah implementasi baru untuk method tersebut.
berikut ini merupakan implementasi dari method getName didalam superclass Person
public class Person {
:
:
public String getName(){
System.out.println(“Parent: getName”);
return name;
}
}
Untuk meng-override method getName dari superclass Person, di dalam subclass Student, kita tulis :
public class Student extends Person{
:
:
public String getName(){
System.out.println(“Student: getName”);
return name;
}
:
}
— Sekarang, ketika kita memanggil method getName dari object subclass Student, method getName yang di-override akan dipanggil, dan hasilnya akan menjadi,
Student: getName
Class final
Final Class
◦ Class yang tidak bisa di-extends
◦ Untuk mendeklarasikan final class, kita tulis,
public final ClassName{
. . .
}
Contoh:
public final class Person {
. . .
}
## Polymorphism
Polymorphism
Kemampuan sebuah variabel reference untuk merubah behavior sesuai dengan apa yang dipunyai object.
polymorphism membuat objek-objek yang berasal dari subclass yang berbeda, diperlakukan sebagai objek-objek dari satu superclass. Hal ini terjadi ketika memilih method yang sesuai untuk diimplementasikan ke objek tertentu berdasarkan pada subclass yang memiliki method bersangkutan.
Untuk menjelaskan polymorphism, mari kita bahas sebuah contoh.
— Pada contoh sebelumnya, kita diberikan parent class yaitu Person dan subclassnya adalah Student, sekarang kita tambahkan subclass lainnya dari Person yaitu Employee
Dalam Java, kita dapat membuat referensi dari suatu superclass ke object dari subclassnya. Sebagai contoh,
public static main( String[] args ) {
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //titik referensi Person kepada // sebuah object Student
}
misalnya, kita memiliki sebuah method getName dalam superclass Person. Dan kita meng-override method ini di kedua subclass yaitu Student dan Employee
public class Student {
public String getName(){
System.out.println(“Student Name:” + name);
return name;
}
}
public class Employee {
public String getName(){
System.out.println(“Employee Name:” + name);
return name;
}
}
— Kembali ke method utama kita, ketika kita mencoba memanggil method getName dari referensi Person ref, method getName dari object Student akan dipanggil.
— Sekarang, jika kita memberi ref kepada object Employee, maka method getName juga akan dipanggil
public static main( String[] args ) {
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //titik referensi Person kepada object Student
//getName dari class Student dipanggil
String temp=ref.getName();
System.out.println( temp );
ref = employeeObject; //titik referensi Person kepada object Employee
//getName dari class Employee dipanggil
String temp = ref.getName();
System.out.println( temp );
}
— Contoh lain yang menggambarkan polymorphism adalah ketika kita mencoba untuk passing reference kepada method
— jika kita memiliki sebuah method static printInformation yang menerima referensi Person sebagai parameter
public static printInformation( Person p ){
. . . .
}
Sebenarnya kita dapat passing reference dari Employee dan Student kepada method printInformation selama kedua class tersebut merupakan subclass dari Person
public static main( String[] args )
{
Student studentObject = new Student();
Employee employeeObject = new Employee();
printInformation( studentObject );
printInformation( employeeObject );
}
Untuk posting selanjutnya.. kita akan bahas tentang casting object kalau gak salah hehehe. So, sabar dolo yoo.,… kapan-kapan aku posting.
c. Kelas tumbuhan
public class tumbuhan extends makhlukhidup{
tumbuhan (String nama){
super(nama,0,false);
}
public void bernafas(){
System.out.println(nama+”bernafas dg menghirup c02″);
}
public static void main (String [] args){
tumbuhan m=new tumbuhan (“Bayam”);
m.status();
m.bernafas();
}
}
Output:
B. Interface
Interface adalah suatu kelas yang berisi method-method tanpa implementasi, namun tanpa modifier abxtract, apabila suatu interface memiliki atribut, amka atributnya akan berlaku sebagai konstanta (static fianl).
Contoh program dari Interface class ini adalah:
a. Kelas pekerjaan
interface pekerjaan{
public void namapekerjaan();
public void gaji();
}
b. Kelas sasya
public class sasya extends manusia implements pekerjaan{
public sasya(){
super(“Sasya”);
}
//mengimplementasikan method milik interface
public void namapekerjaan(){
System.out.println(“Pekerjaan :Sekretaris”);
}
public void gaji(){
System.out.println (“Gaji : Rp. 3000000,-”);
}
public static void main (String[]args){
sasya s=new sasya();
s.status();
s.bernafas();
s.namapekerjaan();
s.gaji();
}
}
C. Inner Class
Inner class adalah kelas yang disisipkan di dalam kelas yang lain. Fungsi kelas sisipan ini adlah mendukung suatu proses yang akan dijalankan oleh kelas utamanya. Inner class bersifat tersarang terhadap kelas-kelas utamanya, seperti halnya blok penyeleksian (if, for) yang tersarang pad blok penyeleksian lainnya atau method yang tersarang pada method lainnya.
Contoh program dari Inner class ini adalah:
a. Kelas orang
class orang{
private int jumlkaki=2;
public void dengarbunyijantung(){
jantung j=new jantung();
j.bunyijantung();
}
public void tahannafas(){
System.out.println(“Jantung berhenti berdetak!”);
}
//inner class
class jantung{
public void bunyijantung(){
System.out.println(“deg..deg….deg…….”);
}
public void istirahat(){
System.out.println(“Silangkan ke ” +jumlkaki+”kaki.”);
tahannafas();
}
}
}
b. Kelas jantungmanusia
class jantungmanusia {
public static void main(String [] args){
orang o=new orang();
orang.jantung p=o.new jantung();
o.dengarbunyijantung();
p.istirahat();
}
}
Output:
