Upload
kiele
View
84
Download
7
Embed Size (px)
DESCRIPTION
Encapsulation, Inheritance, polymorphism, dan interface. Tujuan. Pada akhir pembahasan, peserta diharapkan mampu untuk : Memahami konsep OOP: Encapsulation, Inheritance & Polymorphism Mendeskripsikan Access Modifier Mendeskripsikan superclass dan subclass - PowerPoint PPT Presentation
Citation preview
Pengenalan Pemrograman 1
Versi 2.0
Encapsulation, Encapsulation, Inheritance, Inheritance,
polymorphism, dan polymorphism, dan interfaceinterface
Tujuan
Pada akhir pembahasan, peserta diharapkan mampu untuk :◦Memahami konsep OOP: Encapsulation,
Inheritance & Polymorphism◦Mendeskripsikan Access Modifier◦Mendeskripsikan superclass dan subclass◦Melakukan override method dari superclass◦Membuat final method dan final class◦Polymorphism (abstract class, interface)
EncapsulationPembungkusan variabel dan method
dalam sebuah objek dalam bagian yang terlindungi.
● Enkapsulasi dapat diartikan sebagai bungkusan ( wrapper ) pelindung program dan data yang sedang diolah.
● Pembungkus ini mendefinisikan perilaku dan melindungi program dan data yang sedang diolah agar tidak diakses sembarangan oleh program lain.
Access Modifier
Modifier berfungsi untuk mengatur level hubungan antar class (class access level)
Access modifier
Ada 4 tipe access modifier dalam Java:
− public− private− protected− Default / no specifier
Default merupakan default access modifier, yang tidak menggunakan keyword
public, private, dan protected merupakan access modifier tipe akses, yang secara eksplisit harus ditulis.
Hak akses Default
Akses Default
− Hanya class-class dalam package yang sama yang memiliki akses ke class variable dan method
− Tidak ada keyword bagi modifier default
contoh
public class StudentRecord {//akses default ke instance variableint name;
//akses default ke methodString getName(){return name;
}}
Hak akses public
Akses public
Anggota class dapat diakses dari dalam maupun dari luar class.
Object apapun yang berinteraksi dengan class, memiliki akses ke anggota class yang ber-modifier public
Keyword : public
contoh
public class StudentRecord {//akses default ke instance variablepublic int name;
//akses default ke methodpublic String getName(){return name;
}}
Hak akses protected
Akses protected
Anggota class hanya dapat diakses oleh method dalam class dan subclass dari class
Keyword : protected
contoh
public class StudentRecord {//akses default ke instance variableprotected int name;
//akses default ke methodprotected String getName(){return name;
}}
Hak akses private
Akses private
Anggota class hanya dapat diakses oleh class yang mereka definisikan di dalamnya
Keyword : private
contoh
public class StudentRecord {//akses default ke instance variableprivate int name;
//akses default ke methodprivate String getName(){return name;
}}
Pewarisan (inheritance)
Semua class dalam Java, termasuk class yang membangun Java API, merupakan subclass dari superclass Object.
Contoh dari hierarki class :
Pewarisan (inheritance)
Superclass class yang letaknya di atas class tertentu di dalam hierarki.
Subclass class yang letaknya di bawah class tertentu di dalam hierarki.
Pewarisan (inheritance)
Keuntungan penggunaan Inheritance dalam OOP : Reusability
◦ Ketika behavior(method) dideklarasikan dalam superclass, behavior tersebut otomatis diwariskan ke seluruh subclass
◦ Jadi, Anda dapat meng-enkode method hanya sekali dan method tersebut dapat digunakan oleh seluruh subclass
◦ Sebuah subclass hanya perlu mengimplementasikan perbedaan antara dirinya sendiri dan parent-nya
Pewarisan (inheritance)
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 = "";
}. . . .
}
Pewarisan (inheritance)
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”); }. . . .
}
Pewarisan (inheritance)
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.
Pewarisan (inheritance)
Untuk memperjelasnya, perhatikan kode dibawah ini,
Dalam kode ini, kita membuat sebuah object dari class Student. Hasil dari program adalah:
public static void main( String[] args ){ Student anna = new Student();
}
Inside Person:Constructor Inside Student:Constructor
Pewarisan (inheritance)
Flowchart program ditampilkan dibawah ini :
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.
Keyword “super”
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");}
Keyword “super”
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.
Keyword “super”
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.
contoh
berikut ini merupakan implementasi dari method getName didalam superclass Person
public class Person { : : public String getName(){
System.out.println("Parent: getName"); return name;
} }
contoh
Untuk meng-override method getName dari superclass Person, di dalam subclass Student, kita tulis :
Sekarang, ketika kita memanggil method getName dari object subclass Student, method getName yang di-override akan dipanggil, dan hasilnya akan menjadi,
public class Student extends Person{: : public String getName(){
System.out.println("Student: getName"); return name;
} :
}
Student: getName
Class final
Final Class◦ Class yang tidak bisa di-extends◦ Untuk mendeklarasikan final class, kita tulis,
public final ClassName{. . . }
Contoh:
Contoh lain dari final class adalah class wrapper dan String.
public final class Person { . . .
}
Class dan method final
Method Final◦ Method yang tidak bisa di-override◦ Untuk mendeklarasikan final method, kita tulis,
public final [returnType] [methodName]([parameters]){
. . .}
method static secara otomatis merupakan method final.
contoh
public final String getName(){ return name; }
Polymorphism
PolymorphismKemampuan 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.
Polymorphism
Pada contoh sebelumnya, kita diberikan parent class yaitu Person dan subclassnya adalah Student, sekarang kita tambahkan subclass lainnya dari Person yaitu Employee
Berikut adalah hirarki class nya.
Polymorphism
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}
Polymorphism
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;
} }
Polymorphism
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
Polymorphism
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 );
}
Polymorphism
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 ){. . . .
}
Polymorphism
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 );}
Casting Object
Instance dari class juga dapat di-casting menjadi instance dari class lain, dengan satu batasan :: ◦ Class asal dan tujuan harus direlasikan dalam inheritance,
salah satu class harus berupa subclass dari class lain.
Casting object digunakan untuk mengkonversi nilai primitif menuju tipe yang lebih besar, beberapa object tidak perlu mengalami casting secara explisit.
Casting Object
Gunakan sintaks berikut untuk casting object,
(classname)object
classname - nama class tujuan object - reference untuk object asal
Contoh Casting Object
Berikut ini merupakan contoh proses casting sebuah instance dari class VicePresident ke instance dari class Employee.
VicePresident merupakan subclass dari class Employee dengan beberapa informasi tambahan.
Employee emp = new Employee(); VicePresident veep = new VicePresident(); emp = veep;
// casting explisit veep = (VicePresident)emp;
Abstract Class
Abstract class ◦Sebuah class yang tidak bisa diinstansiasi
◦Sering muncul pada puncak hierarki class object-oriented programming(OOP), mendefinisikan segala type action/tindakan yang mungkin dengan object semua subclass dari class
Abstract Class
Method abstract◦Method di dalam abstract class tidak
mempunyai implementasi◦Untuk membuat abstract method, tulis saja
deklarasi method tanpa body dan gunakan keyword abstract
Sebagai contoh,public abstract void someMethod();
Contoh Abstract Class
public abstract class LivingThing { public void breath(){
System.out.println("Living Thing breathing..."); }
public void eat(){ System.out.println("Living Thing eating...");
}
/** * abstract method walk * Kita ingin method ini di-overrride oleh subclass dari * LivingThing */ public abstract void walk();
}
Abstract class
Ketika sebuah class meng-extends abstract class LivingThing, diwajibkan meng-override abstract method walk(), jika tidak, subclass tersebut juga akan menjadi abstract class, dan oleh karena itu tidak bisa diinstansiasi
Sebagai contoh,
public class Human extends LivingThing {
public void walk(){ System.out.println("Human walks...");
}
}
Petunjuk penulisan program
Menggunakan abstract class untuk mendefinisi jenis-jenis yang luas dari behavior yang ada di puncak hirarki class object-oriented programming, dan menggunakan subclassnya untuk menyediakan detail implementasi dari abstract class.
interface
interface
Interface ◦ Adalah semacam blok spesial yang hanya berisi tanda tangan
method (dan mungkin konstan).◦ Menggambarkan tandatangan dari seperangkat method, tanpa
body◦ Menggambarkan cara standard dan publik penetapan behavior
class◦ Mengijinkan class,dengan mengabaikan lokasi mereka di dalam
hirarki class untuk menerapkan behavior. ◦ CATATAN: Interface memperlihatkan polymorphism juga, sejak
program diperbolehkan memanggil sebuah method interface, dan versi yang sesuai dari method tersebut akan dieksekusi tergantung pada jenis object yang dilewatkan kepada pemanggilan method interface
Mengapa menggunakan interface?
Untuk memiliki class yang tidak berhubungan yang mengimplementasikan method yang sama.◦ Contoh:
Class Line dan MyInteger◦Tidak berhubungan◦Keduanya mengimplementasikan method
perbandingan isGreater isLess isEqual
Mengapa menggunakan interface?
Untuk mengungkapkan sebuah interface pemrograman object tanpa pernyataan classnya
Untuk model multi inheritance yang mengijinkan sebuah class untuk memiliki lebih dari satu superclass.
Membuat interface
Untuk membuat sebuah interface, kita tulis:
public interface [InterfaceName] { //beberapa method tanpa body}
Membuat interface
● Sebagai contoh, mari buat sebuah interface yang mendefinisikan hubungan antara dua object sesuai dengan pesanan dari object.public interface Relation
{
public boolean isGreater( Object a, Object b);
public boolean isLess( Object a, Object b);
public boolean isEqual( Object a, Object b);
}
Membuat interface● Untuk menggunakan interface, kita gunakan keyword implements● Sebagai contoh,
/**
* Class ini menjelaskan segment garis
*/
public class Line implements Relation {
private double x1;
private double x2;
private double y1;
private double y2;
public Line(double x1, double x2, double y1, double y2){
this.x1 = x1;
this.x2 = x2;
this.y1 = y1;
this.y2 = y2;
}
Membuat interfacepublic double getLength(){
double length = Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)* (y2-y1));
return length;}
public boolean isGreater( Object a, Object b){double aLen = ((Line)a).getLength();double bLen = ((Line)b).getLength();return (aLen > bLen);
}
public boolean isLess( Object a, Object b){double aLen = ((Line)a).getLength();double bLen = ((Line)b).getLength();return (aLen < bLen);
}
public boolean isEqual( Object a, Object b){double aLen = ((Line)a).getLength();double bLen = ((Line)b).getLength();return (aLen == bLen);
}}
Membuat interface
● Ketika class Anda mencoba untuk mengimplementasikan sebuah interface, pastikan selalu bahwa Anda mengimplementasikan semua method dari interface tersebut, jika tidak, Anda akan mendapatkan kesalahan ini.
Line.java:4: Line is not abstract and does not override abstract method isGreater(java.lang.Object,java.lang.Object) in Relation
public class Line implements Relation
^
1 error
Interface vs. Abstract Class
Semua interface method tidak memiliki body Beberapa Abstract class memiliki method dengan
implementasi Sebuah interface hanya dapat didefinisikan constant Sebuah abstract class tampak seperti class biasa yang
dapat mendeklarasikan variabel. Interface tidak memiliki hubungan inheritance secara
langsung dengan setiap class tertentu, mereka didefinisikan secara independen.
Abstract class dapat di-subclass-kan
Interface vs. Class
Persamaan:◦ Interface dan class adalah sama-sama sebuah type◦ Hal ini berarti bahwa interface dapat digunakan di tempat dimana
sebuah class dapat digunakan◦ Sebagai contoh:
PersonInterface pi = new Person();Person pc = new Person();
Perbedaan:◦ Anda tidak dapat membuat instance dari sebuah interface◦ Sebagai contoh:
PersonInterface pi = new PersonInterface(); //ERROR!
Interface vs. Class● Persamaan:
Interface dan class, keduanya dapat mendefinisikan method
● Perbedaan: Interface tidak memiliki segala implementasi dari method
Meng-extends Class vs. Implementasi interface
● Sebuah class hanya bisa meng-EXTENDS SATU superclass, tetapi juga bisa meng-IMPLEMENTASIKAN BANYAK interface
● Sebagai contoh:
public class Person implements PersonInterface, LivingThing, WhateverInterface {
//beberapa kode disini}
Meng-extends Class vs. Implementasi interface
Contoh lain:
public class ComputerScienceStudent extends Student implements PersonInterface,
LivingThing {
//Beberapa kode disini}
Inheritance antar interface
Interface bukanlah bagian dari hirarki class, bagaimanapun juga interface dapat memiliki hubungan inheritance antar mereka sendiri
Sebagai contoh:
public interface PersonInterface {. . .
}
public interface StudentInterface extends PersonInterface {. . .
}
Kesimpulan
Inheritance (superclass, subclass)Menggunakan keyword super untuk
mengakses field dan constructor dari superclass
Meng-override MethodFinal Method dan Final ClassPolymorphism (Abstract Class, interface)