DIKTAT

PEMOGRAMAN BERORIENTASI OBJEK

oleh:

Tim Pengajar Pemograman Berorientasi Objek

PROGRAM STUDI SISTEM INFORMASI

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS JAMBI

1
 DAFTAR ISI

Daftar Isi.....................................................................................................................2
Rencana Pembelajaran Semester................................................................................3

Dasar Pemograman Java ...........................................................................................4

Kelas dan Objek.........................................................................................................15
Inheritance..................................................................................................................23
Overrloading Dan Overriding....................................................................................28
Polymorph..................................................................................................................32
Abstraction.................................................................................................................37
Encapsulation.............................................................................................................40
Interface......................................................................................................................43
Design Patterns...........................................................................................................47

2
 RENCANA PEMBELAJARAN SEMESTER

Capaian Pembelajaran :

Matakuliah Pemograman berorietasi objek merupakan matakuliah yang ditujukan agar

mahasiswa mampu memahami dan menerapkan konsep objek oriented dalam pemograman.
Bahasa yang digunakan dalam matakuliah ini adalah bahasa pemograman java.
Pertemuan
Materi Tujuan Pembelajaran
ke
Intro Materi Pemograman Mahasiswa dapat memahami secara garis besar materi
1 Berorientasi Objek apa saja yang akan dipelajari pada matakuliah
pemograman berorientasi objek
2 Dasar Pemograman Java Mahasiswa mampu memahami dan menggunakan
3 sintak-sintak dasar pada pemograman java

4
5
6 Kelas dan Objek Mahasiswa memahami dan mampu menerapkan
7 konsep kelas dan objek.

8 UTS
Inheritance Mahasiswa memahami konsep Inheritance dalam
9
Objek Oriented
Overloading dan Overriding Mahasiswa memahami tujuan dan manffat
10 Overloading dan Overriding pada pemograman
berorientasi objek
Polymorph Mahasiswa memahami konsep Polymorph dalam
11
Objek Oriented
Abstraction Mahasiswa memahami abstract class dan abstract
12
method dalam Objek Oriented Programming
Encapsulation Mahasiswa memahami konsep Encapsulation dalam
13
Objek Oriented
Interface Mahasiswa memahami kelas Interface dan
14
perbedaannya dengan class dan abstract
15 Design Patterns Mahasiswa memahami konsep dasar Design Pattern.
16 UAS

3
 BAB I

DASAR PEMOGRAMAN JAVA

Aplikasi-aplikasi berbasis java umumnya dikompilasi ke dalam p-code(bytecode) dan

dapat dijalankan pada berbagai Mesin Virtual Java (JVM). Java merupakan bahasa
pemrograman yang bersifat umum/non-spesifik (general purpose), dan secara khusus didisain
untuk memanfaatkan dependensi implementasi seminimal mungkin. Karena
fungsionalitasnya yang memungkinkan aplikasi java mampu berjalan di beberapa platform
sistem operasi yang berbeda, java dikenal pula dengan slogannya, "Tulis sekali, jalankan di
mana pun". Saat ini java merupakan bahasa pemrograman yang paling populer digunakan,
dan secara luas dimanfaatkan dalam pengembangan berbagai jenis perangkat lunak aplikasi
ataupun aplikasi.
Mesin virtual java atau lebih dikenal dalam bahasa Inggris Java Virtual Machine
atau disingkat JVM merupakan mesin virtualyang digunakan secara khusus mengeksekusi
berkas bytecode java. Menurut Sun Microsystems (sekarang merupakan bagian dari Oracle
Corporation), terdapat lebih dari 4,5 miliar lebih perangkat keras di dunia yang memiliki
mesin virtual java di dalamnya.

Gambar 1. Arsitektur Java Virtual Machine

Kelebihan java:
1. Multiplatform: dapat dijalankan di beberapa platform/sistem operasi komputer.

4
 2. OOP (Object Oriented Programming):semua aspek yang terdapat di Java adalah
Objek.
3. Perpustakaan Kelas yang lengkap: Java terkenal dengan kelengkapan library/
perpustakaan (kumpulan program yang disertakan dalam pemrograman java) yang
sangat memudahkan dalam penggunaan oleh para pemrogram untuk membangun
aplikasinya.
4. Bergaya C++: memiliki sintaks seperti bahasa pemrograman [C++] sehingga menarik
banyak pemrogram C++ untuk pindah ke Java.

1.1 Linkungan Kerja Java

Untuk menulis program JAVA digunakan editor. IDE (Integrated Development

Environment) yang telah ada untuk Java, antara lain: NetBeans yang disponsori Sun
Microsystems. Diperlukan penginstalan Java SDK dan Netbeans IDE 7.2.1.
1. Java SDK : adalah platform dasar Java yang diperlukan agar PC dapat mengeksekusi
kode-kode program yang menggunakan bahasa Java.
Java Development Kit (JDK) dapat didownload pada situs Java Sun Microsystem,
yaitu: http://java.sun.com. Instalasi dilakukan dengan mengklik installer jdk yang
akan mengekstrak file JDK membuat direktori yang diperlukan. Untuk versi jdk
dibawah 1.6 diperlukan setting variable path.

2. NetBeans : adalah aplikasi editor terpadu (IDE) yang menyediakan kontrolkontrol

visual dalam pemrograman desktop.

Gambar 1.2 Tampilan Netbean IDE

Aturan dasar program java

1. Case sensitive : penggunaan huruf besar dan kecil memiliki arti berbeda

5
 2. Kurung kurawal{} : symbol menandai awal dan akhir suatu blok program
3. Komentator : diawali tanda // atau tanda /*……*/  titik koma (;) : setiap pernyataan
diakhiri dengan symbol titk-koma

Hello World.java

public class HelloWorld {

public static void main(String[] args) {

// Prints "Hello, World" to the terminal window.
System.out.println("Hello, World");
}

1.2 Tipe Data dan Operator

Pada java tipe data dibagi kedalam 2 kategori:

Tipe data primitif : tipe data yang mempunyai nilai tertentu, bukan referensi kelas atau
objek.Dibagi menjadi 4 tipe data primitive.

Tipe data referensi : terbentuk dari tipe data sederhana dan tipe data referensi.

Operator
Operator digunakan untuk melakukan pengolahan data, melibatkan konstanta dan variabel
yang telah kita buat.

6
1.3 Percabangan dan Perulangan

if - else
Statement if akan menentukan sebuah blok kode mana yang akan di eksekusi jika ada
persyaratan yang bernilai true (benar).

Berikut ini cara penulisan statement if .

if(kondisi){
//Kode disini akan dieksekusi jika kondisi true
}

dimana, kondisi adalah sebuah penyataan logika (true atau false) pada variabel bertipe
boolean.

Contoh.

public class belajar_if_else {

public static void main (String[] args){
int nilai_MTK = 80;

if(nilai_MTK < 70){

/*
* Jika nilai/value pada variable nilai_MTK lebih dari 70
* Maka program akan menjalankan statement ini
*/
System.out.println("Selamat Wildan kamu lulus ujian Matematika");
}else {
/*
* Dan Jika nilai/value pada variable nilai_MTK kurang dari 70
* Maka program akan menjalankan statement ini
*/
System.out.println("Mohon maaf Wildan kamu tidak lulus");

7
 }
}
}

swicth – case

Ketika pernyataan switch ditemukan pada potongan kode program, java pertama kali
akan memeriksa switch_expression dan menuju ke case yang akan menyamakan nilai yang
dimiliki oleh switch_expression. Selanjutnya program akan mengeksekusi pernyataan pada
kode setelah case yang ditemukan sampai menemui pernyataan break. Jika tidak ditemui case
yang cocok, maka program akan mengeksekusi default. Bagian default adalah opsional.
Sebuah pernyataan switch bisa jadi tidak memiliki kode default. Ada 2 penggunaan keyword
break, untuk keluar dari kendali percabangan switch, untuk keluar dari kendali perulangan.
Dengan keyword ini berarti percabangan/perulangan akan diakhiri, kemudian eksekusi
dilanjutkan ke pernyataan setelah blok percabangan/perulangan tersebut. Tidak seperti
statement if, pada struktur switch statement dieksekusi tanpa memerlukan tanda kurung
kurawal ({}). Ketika sebuah case pada statement switch menemui kecocokan, semua
statement pada case tersebut akan dieksekusi. Untuk menghindari program mengeksekusi
statement pada case berikutnya, kita menggunakan statement break sebagai statement akhir.
Contoh swicth – case

public class contoh_switch_case {

public static void main (String[] args){
int noHari = 5;
switch (noHari){
case 1: System.out.println("Hari Senin"); break;
case 2: System.out.println("Hari Selasa"); break;
case 3: System.out.println("Hari Rabu"); break;
case 4: System.out.println("Hari Kamis"); break;
case 5: System.out.println("Hari Jumat"); break;
case 6: System.out.println("Hari Sabtu"); break;
case 7: System.out.println("Hari Minggu"); break;
default: System.out.println("No Hari Tidak ada yang sesuai");
}
}
}

While

Statemen perulangan (looping) adalah blok perintah yang akan mengulangulang statemen di
dalam blok perintah selama kondisi menghasilkan nilai true dan akan berhenti jika kondisi
bernilai false.

Syntax

while (kondisi) {
statement
counter

8
}

Contoh.

public class WhileConsole {

public static void main(String[] args) {
//inisialisasi variable
int i = 1;
//proses perulangan while
while(i <= 10){
System.out.println(i); //statement
i++; //counter
}
}
}

Do – while
Perulangan dengan bentuk do while adalah perulangan dengan membalikkan logika
perulangan dengan teknik while.Dalam perulangan do while, pernyataan dieksekusi dulu,
baru kemudian kondisi variabel kontrol perulangannya diperiksa apakah memenuhi syarat
atau tidak.

Syntax
do {
statement
counter
} while (kondisi)

9
Contoh.

public class WhileDoConsole {

public static void main(String[] args) {
//inisialisasi variable
int i = 1;
//proses perulangan do-while
do {
System.out.println(i); //statement
i++; //counter
} while (i <= 10);
}
}

For
Perulangan dengan teknik ini dikontrol oleh tiga bagian yang ada dalam tanda kurung
dan masing-masing bagian ini dipisahkan oleh titik-koma. Pada bagian pertama(inisialisasi
ekspresi), sebuah variabel akan di deklarasikan sebagai sebuah titik awal dari perulangan,
biasanya variable ini mempunyai tipe data integer atau float. Sementara pada bagian kedua
disinilah perulangan akan diperiksa apakah masih memenuhi syarat atau tidak, jika masih
memenuhi syarat maka statement dibawahnya akan di eksekusi. Sedangkan bagian ketiga
adalah bagian dimana jika bagian kedua masih memenuhi syarat maka nilai variabel akan
ditambahkan sesuai dengan syarat yang dituliskan. Bagian ketiga ini secara otomatis akan
tidak dibaca oleh program jika kondisi pada bagian kedua sudah tidak lagi memenuhi syarat,
dan perulangan pun menjadi terhenti.

Syntax

for (nilai_awal; kondisi; step){

statement;
}

10
Contoh

public class ForConsole {

public static void main(String[] args) {
//inisialisasi variable
int i;
//proses perulangan for
for (i=1; i<=10; i++){
System.out.println(i) //statement
}
}
}

Array

Dalam pendeklarasian variabel, kita sering menggunakan sebuah tipe data beserta
nama variabel atau identifier yang unik. Apabila kita ingin menggunakan variabel tersebut,
kita akan memanggil dengan nama identifier-nya. Sebagai contoh, kita memiliki tiga variabel
dengan tipe data int yang memiliki identifier berbeda untuk tiap variabel.
int number1;
int number2;
int number3;

number1 = 1;
number2 = 2;
number3 = 3;

Seperti yang dapat Anda perhatikan pada contoh diatas, kode tersebut akan sia-sia
karena harus menginisialisasi dan menggunakan setiap variabel padahal sebenarnya variabel-

11
variabel tersebut digunakan untuk tujuan yang sama. Pada bahasa pemrograman Java maupun
di bahasa pemrograman yang lain, terdapat sebuah kemampuan untuk menggunakan satu
variabel yang dapat menyimpan beberapa data dan memanipulasinya dengan lebih efektif.
Tipe variabel inilah yang disebut sebagai array.

Gambar 1.3 Contoh Array

Sebuah array akan menyimpan beberapa item data yang memiliki tipe data sama didalam
sebuah blok memori yang berdekatan yang kemudian dibagai menjadi beberapa ruang. Array
adalah sebuah variabel/sebuah lokasi tertentu yang memiliki satu nama sebagai identifier,
namun identifier ini dapat menyimpan lebih dari sebuah nilai.

Deklarasi array:

Array harus dideklarasikan seperti layaknya sebuah variabel. Pada saat mendeklarasikan
array, anda harus membuat sebuah daftar dari tipe data, yang diikuti oleh sepasang tanda
kurung [], lalu diikuti oleh nama identifier-nya. Sebagai contoh,

int []ages;

atau Anda dapat menempatkan sepasangtandakurung [] sesudah nama identifier. Sebagai

contoh,

int ages[];

Pengaksesan sebuah elemen array:

Untuk mengakses sebuah elemen dalam array, atau mengakses sebagian dari array, Anda
harus menggunakan sebuah angka atau yang disebut sebagai indeks atau subscript.

Pada saat memasukkan nilai ke dalam array, sebuah nomor indeks atau subscript telah
diberikan kepada tiap anggota array, sehingga program dan programmer dapat mengakses
setiap nilai pada array apabila dibutuhkan. Nilai indeks selalu dalam tipeinteger, dimulai dari
angkanol dan dilanjutkan ke angka berikutnya sampai akhir array. Sebagai catatan bahwa
indeks didalam array dimulai dari 0 sampai dengan (ukuranArray-1).

Sebagai contoh, pada array yang kita deklarasikan tadi, kita mempunyai,

//memberikan nilai 10 kepada elemen pertama array

ages[0] = 10;

//mencetak elemen array yang terakhir

12
 System.out.print(ages[99]);

Perlu diperhatikan bahwa sekali array dideklarasikan dan dikonstruksi, nilai yang disimpan
dalam setiap anggota array akan diinisialisasi sebagai nol. Oleh karena itu, apabila Anda
menggunakan tipe data seperti String, array tidak akan diinisalisasi menjadi string kosong “”.
Untuk itu Anda tetap harus membuat String array secara eksplisit.

Berikut ini adalah contoh kode untuk mencetak seluruh elemen didalam array. Dalam contoh
ini digunakanlah pernyataan for loop, sehingga kode kita menjadi lebih pendek.

public class ArraySample{

public static void main( String[] args ){
int[] ages = new int[100];
for( int i=0; i<100; i++ ){
System.out.print( ages[i] );
}
}
}

Panjang Array

Untuk mengetahui berapa banyak elemen didalam sebuah array, Anda dapat menggunakan
atribut length dari array. Atribut ini akan mengembalikan ukuran dari array itu sendiri.
Sebagai contoh,

arrayName.length

Pada contoh sebelumnya, kita dapat menuliskannya kembali seperti berikut ini,

public class ArraySample {

public static void main( String[] args ){
int[] ages = new int[100];
for( int i=0; i<ages.length; i++ ){
System.out.print( ages[i] );
}
}
}

Array Multidimensi:
Array multidimensi diimplementasikan sebagai array yang terl etak di dalam array. Array
multidimensi dideklarasikan dengan menambahkan jumlah tanda kurung setelah nama array.
Sebagai contoh,

// Elemen 512 x 128 dari integer array

int[][] twoD = new int[512][128];

// karakter array 8 x 16 x 24
char[][][] threeD = new char[8][16][24];

13
 // String array 4 baris x 2 kolom
String[][] dogs = {{ "terry", "brown" },
{ "Kristin", "white" },
{ "toby", "gray"},
{ "fido", "black"}
};

Untuk mengakses sebuah elemen didalam array multidimensi, sama saja dengan mengakses
array satu dimensi. Misalnya saja, untuk mengakses elemen pertama dari baris pertama
didalam array dogs, kita akan menulis,

System.out.print( dogs[0][0] );

Kode diatas akan mencetak String “terry” di layar.

14
 BAB II

KELAS DAN OBJEK

2.1 Objek dan kelas

Dalam dunia nyata , kita dapat menjumpai banyak objek di sekitar kita seperti, kucing,
anjing, manusia dan lain-lain. Setiap objek memiliki state dan behavior. Misalkan seekor
anjing, dengan state-nya adalah nama, makanan, warna, dan behavior-nya menggongong,
menggigit ekor, dan berlari. Jika membandingkan software objek dengan objek di dunia
nyata, mereka memiliki karakteristik yang sama. Objek pada software juga memiliki state dan
behavior. State pada objek software disimpan pada field dan behavior ditunjukkan melalui
method. Jadi pada pengembangan software, method dioperasikan pada internal state dari
sebuah objek dan komunikasi antar objek dapat dilakukan melalui method.
Class adalah struktur dasar dari OOP (Object Oriented Programming). Terdiri dari dua
tipe yaitu : field (attribute/property) dan method (behavior). Class digunakan untuk
mendeklarasikan sebuah variabel yang berupa objek atau dinamakan “referensi objek (object
reference)”.

1. Attribute
Berlaku sebagai data, didefinisikan oleh class,individu, berbeda satu dengan lainnya.
Menggambarkan tampilan, status, kualitas dari object.
Contoh :
class motorcycle
attribute-nya = color [red, green, silver]
style [cruiser, sport bike, standart]
make [Honda, BMW]

Didefinisikan dalam class dengan menggunakan variabel.

2. Behavior
Berlaku sebagai method (operasi). Menggambarkan bagaimana sebuah instance class
beroperasi misal bagaimana reaksi dari class jika diminta untuk melakukan sesuatu hal.
Contoh :
class motorcycle behavior-nya = start the engine
stop the engine
change gear.

Untuk menentukan behavior dari object harus membuat Methods.

Contoh

public class Dog {

String breed;
int age;
String color;

void barking() {

15
 }

void hungry() {
}

void sleeping() {
}
}

Konstruktor:

Salah satu hal yang penting dalam kelas adalah kontruktor. Setiap kelas memiliki contruktor.
Jika kita tidak secara langsung membuat sebuah kontruktor, compiler java secara otomatis
akan membuat contruktor. Setiap kali objek baru dibuat dari sebuah kelas, paling tidak satu
contruktor akan dieksekusi. Sarat utama dari sebuah konstruktor adalah harus memuliki nama
yang sama dengan nama kelas. Sebuah kelas dapat memiliki lebih dari satu kontruktor.

Contoh:

public class Puppy {

public Puppy() {
}

public Puppy(String name) {

// This constructor has one parameter, name.
}
}

Ketika sebuah objek dimbuat dari sebuah kelas, maka koden kontruktor akan langsung
dieksekusi.

Puppy mypuppy = new Puppy(“tommy”)

pada contoh diatas sebuah objek dibuat dari kelas Puppy dengan memasukkan parameter
yang dibutuhkan oleh kelas yakni parameter name dengan nilai tommy.

Mengakses Variabel dan method:

Variable dan method dapat diakses melalui objek yang telah dibuat melalui sebuah kelas.

/* First create an object */

ObjectReference = new Constructor();

/* Now call a variable as follows */

ObjectReference.variableName;

/* Now you can call a class method as follows */

ObjectReference.MethodName();

16
Contoh:

public class Puppy {

int puppyAge;

public Puppy(String name) {

// This constructor has one parameter, name.
System.out.println("Name chosen is :" + name );
}

public void setAge( int age ) {

puppyAge = age;
}

public int getAge( ) {

System.out.println("Puppy's age is :" + puppyAge );
return puppyAge;
}

public static void main(String []args) {

/* Object creation */
Puppy myPuppy = new Puppy( "tommy" );

/* Call class method to set puppy's age */

myPuppy.setAge( 2 );

/* Call another class method to get puppy's age */

myPuppy.getAge( );

/* You can access instance variable as follows as well */

System.out.println("Variable Value :" + myPuppy.puppyAge );
}
}

Output yang diberikan pada contoh diatas:

Name chosen is :tommy

Puppy's age is :2
Variable Value :2

2.2 Java Package

Secara sederhana Package meruapakns suatu cara yang digunakan untuk mengkategorikan
class dan interfaces. Ketika mengembangkan sebuah aplikasi pada Java, terdapat ratusan
class dan interface yang akan dibuat, dengan mengkategorikan class maka hal ini akan
membuat pengembangan aplikasi lebih gampang.

17
Statement Import: merupakan suatu cara yang digunakan untuk mengacu suatu lokasi,
sehingga compiler dapat menemukan class yang ingin digunakan. Sebagai contoh, baris kode
berikut akan memerintahkan compiler untuk men-load semua kelas yang tersedia pada
direktoru java_installation/java/io

import java.io.*;

2.3 Method

Method adalah fungsi atau prosedur yang dibuat oleh seorang programmer didalam
suatu Class. Dengan kata lain, method pada sebuah kelas hampir sama dengan fungsi atau
prosedur pada pemrograman prosedural. Pada sebuah method di dalam sebuah kelas juga
memiliki izin akses seperti halnya atribut pada kelas, izin akses itu antara lain private, public
dan protected yang memiliki arti sama pada izin akses atribut yang telah dibahas sebelumnya.
Sebuah kelas boleh memiliki lebih dari satu method dengan nama yang sama asalkan
memiliki parameter masukan yang berbeda sehingga kompiler atau interpreter dapat
mengenali method mana yang dipanggil. Hal ini dinamakan overloading.
Di dalam sebuah kelas, terdapat juga yang disebut sebagai method atau atribut statis
yang memiliki kata kunci static. Maksud dari statis di sini adalah method yang dapat diakses
secara berbagi dengan semua objek lain tanpa harus membuat objek yang memiliki method
statis tadi (tanpa proses new), tapi sebuah method statis mempunyai keterbatasan yaitu hanya
dapat mengakses atribut atau method lain di dalam kelas yang membungkusnya yang juga
bersifat statis. Method statis biasanya diimplementasikan untuk method main.
Didalam suatu class, behavior disimpan dalam bentuk Method. Method merupakan
serangkaian statemen / perintah (perintah = baris program) dalam suatu class yang
menghandle task tertentu. Method merupakan hal-hal yang bisa dilakukan oleh object dari
suatu class. Method didefinisikan pada class akan tetapi dipanggil melalui object.
Method memiliki peranan diantaranya :
a. merubah nilai atribut dari suatu object,
b. menerima informasi dari object lain, dan
c. mengirim informasi ke obyek lain untuk melakukan suatu task (cara obyek
berkomunikasi dengan obyek lain adalah dengan menggunakan method).

Sintak membuat sebuah method.

public static int methodName(int a, int b) {

// body
}

public static → modifier

int → return type

methodName → name of the method

a, b → formal parameters

int a, int b → list of parameters

18
Secara umum sintak method dapat digambarkan sebagai berikut.

modifier returnType nameOfMethod (Parameter List) {

// method body
}

modifier → tipe akses method (optional)

returnType → nilai return method

nameOfMethod → nama method

Parameter List → list parameter yang digunakan oleh method.

method body → Statemen dan kode yang akan dieksekusi ketika method di akses

2.4 Contoh Sederhana

Sebagai contoh studi kasus, kita akan membuat dua kelas, yakni kelas Employee dan
EmployeeTest. Kelas employee terdiri dari empat variabel, yakni name, age, designation dan
salary.

Employee.java
import java.io.*;
public class Employee {

String name;
int age;
String designation;
double salary;

// This is the constructor of the class Employee

public Employee(String name) {
this.name = name;
}

// Assign the age of the Employee to the variable age.

public void empAge(int empAge) {
age = empAge;
}

/* Assign the designation to the variable designation.*/

public void empDesignation(String empDesig) {
designation = empDesig;
}

19
 /* Assign the salary to the variable salary.*/
public void empSalary(double empSalary) {
salary = empSalary;
}

/* Print the Employee details */

public void printEmployee() {
System.out.println("Name:"+ name );
System.out.println("Age:" + age );
System.out.println("Designation:" + designation );
System.out.println("Salary:" + salary);
}
}

Pada Java proses dimulai pada main class, untuk menggunakan class Employee diatas
sebagai contoh, kita buat pada kelas terpisah dengan nama EmployeeTest.java yang memiliki
main kelas.

EmployeeTest.java

import java.io.*;
public class EmployeeTest {

public static void main(String args[]) {

/* Create two objects using constructor */
Employee empOne = new Employee("James Smith");
Employee empTwo = new Employee("Mary Anne");

// Invoking methods for each object created

empOne.empAge(26);
empOne.empDesignation("Senior Software Engineer");
empOne.empSalary(1000);
empOne.printEmployee();

empTwo.empAge(21);
empTwo.empDesignation("Software Engineer");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}

Maka Output yang dihasilkan ketika program dikompile

Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0

20
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

2.5 Inner Class

Java membolehkan menyisipkan suatu kelas ke dalam kelas lainnya. Kelas sisipan ini
disebut kelas Inner. Kelas Inner berguna untuk mendukung suatu proses yang akan dijalankan
oleh kelas luarnya. Beberapa ketentuan kelas Inner:
1. Kelas Luar yang mengandung kelas Inner, bila dikompilasi akan menghasilkan dua
file *.class, yaitu Luar.class dan Luar$Inner.class.
2. Kelas Inner boleh tidak diberi nama, yang disebut Anonymous Inner.
3. Kelas Inner dapat diberi modifier akses public, atau protected, atau default, ataupun
private.
4. Untuk mengakses referensi this dari kelas luar digunakan bentuk NamaKelasLuar.this.
5. Kelas Luar ikut bertanggung-jawab dalam instansiasi kelas Inner (yang non static).
6. Kalau objek kelas Luar adalah a, dan objek kelas Inner adalah b, maka sintaks yang
benar adalah :
Luar a = new Luar(); Luar.Inner b = a.new Inner();

Jika kelas Inner bersifat static, maka objek milik kelas Inner dapat dibuat
sendiri tanpa melalui kelas Luarnya, (Artinya kelas Inner tidak dapat
mengakses attribute ataupun method non static milik kelas Luarnya).

Inner Class adalah kelas yang disisipkan di dalam kelas yang lain. Fungsi kelas sisipan ini
adalah 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 pada blok penyeleksian lainnya atau method yang tersarang pada method
lainnya. Analogi Inner Class Inner Class dapat dianalogikan sebagi hubungan antara manusia
dan paru – paru. Setiap manusia pasti bernafas dengan menggunakan paru – paru. Dalam hal
ini berarti kinerja dari paru – paru turut mendukung/menetukan kinerja dari manusia. Dalam
bahasa pemrograman berorientasi objek manusia dapat dikatakan sebagai outer class dan paru
– paru sebagai inner class-nya.

Contoh Inner Class.

class Outer_Demo {
int num;

// inner class
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}

// Accessing he inner class from the method within

21
 void display_Inner() {
Inner_Demo inner = new Inner_Demo();
inner.print();
}
}

public class My_class {

public static void main(String args[]) {

// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();

// Accessing the display_Inner() method.

outer.display_Inner();
}
}

Output yang dihasilkan pada contoh diatas

This is an inner class.

22
 BAB III

INHERITANCE

3.1 Inheritance
Inheritance (Pewarisan) merupakan salah satu dari tiga konsep dasar OOP. 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 apaapa 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. 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.

Kita baru perlu menerapkan inheritance pada saat kita jumpai ada suatu class
yang dapat diperluas dari class lain.

Deklarasi Inheritance

public class B extends A {

…
}

extends merupakan keyword yang digunakan untuk mewariskan properties sebuah kelas.

class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}

Contoh:
Misalkan terdapat kelas pegawai

public class Pegawai {

public String nama;
public double gaji;
}

dan juga terdapat kelas manager

23
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;
}

3.2 keyword super

Keyword super mirip seperi keyword this. Keyword super digunakan dengan skenario
sebagai berikut:

1. Untuk membedakan antara anggota dari superclass dari anggota subclass, jika mereka
memiliki nama yang sama
2. Digunakan untuk memanggil contruktor superclass dari subclass

Jika class mewariskan properties dari class yang lain, dan jika member superclass memiliki
nama yang sama dengan subclass, untuk membedakan variabel keduanya bisa menggunakan
keyword super seperti dibawah ini.

super.variable
super.method();

contoh:

class Super_class {
int num = 20;

// display method of superclass

public void display() {
System.out.println("This is the display method of superclass");
}
}

public class Sub_class extends Super_class {

int num = 10;

// display method of sub class

public void display() {
System.out.println("This is the display method of subclass");

24
 }

public void my_method() {

// Instantiating subclass
Sub_class sub = new Sub_class();

// Invoking the display() method of sub class

sub.display();

// Invoking the display() method of superclass

super.display();

// printing the value of variable num of subclass

System.out.println("value of the variable named num in sub class:"+ sub.num);

// printing the value of variable num of superclass

System.out.println("value of the variable named num in super class:"+ super.num);
}

public static void main(String args[]) {

Sub_class obj = new Sub_class();
obj.my_method();
}
}

Output yang diberikan adalah sebagai berikut.

This is the display method of subclass

This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

keyword super juga digunakan untuk memanggil konstruktor superclass. Untuk

memanggil dan memasukkan parameter kontruktor pada superclass dapat dilakukan seperti
sintak dibawah ini.

super(values);

Contoh:

class Superclass {
int age;

Superclass(int age) {
this.age = age;
}

25
 public void getAge() {
System.out.println("The value of the variable named age in super class is: " +age);
}
}

public class Subclass extends Superclass {

Subclass(int age) {
super(age);
}

public static void main(String argd[]) {

Subclass s = new Subclass(24);
s.getAge();
}
}

Output yang dihasilkan.

The value of the variable named age in super class is: 24

3.3 Hubungan IS – A dan HAS -A

Is – a meruapakan suatu cara yang digunakan untuk menyatakan: suatu objek merupakan
salah satu tipe dari objek lain. Berikut contoh, bagaimana keyword extends digunakan untuk
melakukan pewarisan tersebut.

public class Animal {

}

public class Mammal extends Animal {

}

public class Reptile extends Animal {

}

public class Dog extends Mammal {

}

Berdasarkan contoh kode di atas, maka pernyataan dibawah ini benar,

Animal merupakan superclass dari class Mamal

Animal merupakan superclass dari class Reptile
Mamal dan Reptile merupakan superclass dari class Animal
Dog merupakan subclass dari class Mammal dan Animal.

Maka dengan menggunakan hubungan IS- A, maka kita dapat menyatakan bahwa.

Mamal IS-A Animal

26
Reptile IS-A Animal
Dog IS-A Mamal
dan Juga : Dog IS-A Animal

Selain hubungan IS -A dalam menerapkan Inheritance pada java, HAS – A juga dapat
menjelaskan hubungan dalam inheritance yang didasarkan pada penggunaan. Hubungan ini
menjelaskan apakah suatu kelas tertentu MEMILIKI sesuatu hal tertentu dari superclassnya.
Hubungan ini dapat membantu mengurangi duplikasi kode dan bugs.

Contoh:

public class Vehicle{}

public class Speed{}

public class Van extends Vehicle {

private Speed sp;
}

3.4 Tipe dari Inheritance

Penting untuk diingat java tidak mendukung multiple inheritance.

27
 BAB IV

OVERRLOADING DAN OVERRIDING

4.1 Overloading pada Contructor

Suatu class boleh memiliki lebih dari satu contruktor. Contruktor yang terdiri dari dua
atau lebih disebut dengan overloading contructor. Overloading contructor termasuk salah satu
dari ciri program OOP yaitu polimorfisme. Polimorfisme berarti berbeda-beda bentuk. Syarat
pada overloading constructor adalah signature dari constructor-constructor tersebut tidak
sama. Signature adalah informasi yang membedakan method seperti nama method, jumlah
parameter, tipe data, dan tipe kembalian (return type).

Berikut contoh overloading contructor

class Titik3D{
double x;
double y;
double z;

Titik3D(double ax){
x = ax;
y = 1;
z = 1;
}

Titik3D(double ax, double ay){

x = ax;
y = ay;
z = 1;
}

Titik3D(double ax, double ay, double az){

x = ax;
y = ay;
z = az;
}
}

class ContohTitik3D{
public static void main(String args[]){
Titik3D p = new Titik3D(1,1);
System.out.println(“p.x = “+p.x);
System.out.println(“p.y = “+p.y);
System.out.println(“p.z = “+p.z);

Titik3D p = new Titik3D(1.1, 3.4);

System.out.println(“p.x = “+p.x);

28
 System.out.println(“p.y = “+p.y);
System.out.println(“p.z = “+p.z);

Titik3D p = new Titik3D(1.1, 3.4,-2.8);

System.out.println(“p.x = “+p.x);
System.out.println(“p.y = “+p.y);
System.out.println(“p.z = “+p.z);

}
}

4.2 Overloading

Overloading adalah suatu keadaan dimana beberapa method memiliki nama yang
sama tetapi fungsionalitasnya berbeda. Contoh:
- titik(x,y);
- titik (x,y,z)
Ciri-ciri Overloading:

- Nama method harus sama

- Daftar parmeter harus berbeda
- Return type boleh sama, boleh berbeda

Contoh overloading pada method

import java.awt.Point;

public class Segiempat{

int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;

public void buatSegiempat(int x1, int y1, int x2, int y2){
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
public void buatSegiempat(Point topLeft, Point bottomRight){
x1 = topLeft.x;
y1 = topLeft.y;
x2 = bottomRight.x;
y2 = bottomRight.y;
}

public void buatSegiempat(Point topLeft, int w, int h){

29
 x1 = topLeft.x;
y1 = topLeft.y;
x2 = (x1 + w);
y2 = (y1 + h);
}

void cetakSegiempat(){
System.out.print(“Segiempat: <”+x1+”, “+ y1);
System.out.println(“, “ + x2+”,”+y2+”>”);
}

public static void main(String[] arguments){

Segiempat rect = new Segiempat();
System.out.println(“Buat segiempat dengan koordinat(25,25) dan (50,50)”);
rect.buatSegiempat(25,25,50,50);
rect.cetakSegiempat();

System.out.println();
System.out.println(“Buat segiempat dengan point (10,10) dan point (20,20):”);
rect.buatSegiempat(new Point(10,10), new Point(20,20));
rect.cetakSegiempat();

System.out.println();
System.out.println(“Buat segiempat dengan 1 point (10,10),
koordinat(50,50)”);
rect.buatSegiempat(new Point(10,10), 50,50);
rect.cetakSegiempat();

}
}

4.3 Overriding

Overriding menyatakan suatu keadaaan dimana method pada subclass menolak

method pada parent class-nya.

Ciri dari overriding:

- Nama method harus sama

- Daftar parameter harus sama
- Return type harus sama

Contoh overriding

class Parent{
public void Info(){
System.out.println(“ini class parent”);
}

30
 class Child extends Parent{
public void Info(){
System.out.println(“ini class child”);
}
}
}

Method yang terkena Override (overriden method) tidak boleh mempunyai modifier yang
lebih luas aksesnya daripada mehod yang meng-override (overriding method).

Contoh lain

class Animal {
public void move() {
System.out.println("Animals can move");
}
}

class Dog extends Animal {

public void move() {
System.out.println("Dogs can walk and run");
}
}

public class TestDog {

public static void main(String args[]) {

Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object

a.move(); // runs the method in Animal class

b.move(); // runs the method in Dog class
}
}

Output yang diberikan

Animals can move

Dogs can walk and run

31
 BAB V

POLIMORPISM

Polymorphism (polimorfisme) adalah kemampuan untuk mempunyai beberapa bentuk class

yang berbeda. Polimorfisme ini terjadi pada saat suatu obyek bertipe parent class, akan tetapi
pemanggilan constructornya melalui subclass. Misalnya deklarasi pernyataan berikut ini:

Employee employee=new Manager();

dimana Manager() adalah kontruktor pada class Manager yang merupakan subclass dari class
Employee.

Virtual Method Invocation (VMI) bisa terjadi jika terjadi polimorfisme dan
overriding. Pada saat obyek yang sudah dibuat tersebut memanggil overridden method pada
parent class, kompiler Java akan melakukan invocation (pemanggilan) terhadap overriding
method pada subclass, dimana yang seharusnya dipanggil adalah overridden method. Berikut
contoh terjadinya VMI:

class Parent {
int x = 5;
public void Info() {
System.out.println(“Ini class Parent”);
}
}

class Child extends Parent {

int x = 10;
public void Info() {
System.out.println(“Ini class Child”);
}
}

public class Tes {

public static void main(String args[]){
Parent tes=new Child();
System.out.println(“Nilai x = “ + tes.x);
tes.Info();
}
}

Output yang diberikan.

Nilai x = 5
Ini class Child

Polymorphic arguments adalah tipe suatu parameter yang menerima suatu nilai yang
bertipe subclass-nya. Berikut contoh dari polymorphics arguments:

32
 class Pegawai {
…
}

class Manajer extends Pegawai {

…
}

public class Tes {

public static void Proses(Pegawai peg) {
…
}
public static void main(String args[]) {
Manajer man = new Manajer();
Proses(man);
}
}

Pernyataan instanceof sangat berguna untuk mengetahui tipe asal dari suatu
polymorphic arguments. Untuk lebih jelasnya, misalnya dari contoh program sebelumnya,
kita sedikit membuat modifikasi pada class Tes dan ditambah sebuah class baru Kurir, seperti
yang tampak dibawah ini:

…
class Kurir extends Pegawai {
…
}

public class Tes {

public static void Proses(Pegawai peg) {
if (peg instanceof Manajer) {
…lakukan tugas-tugas manajer…
} else if (peg instanceof Kurir) {
…lakukan tugas-tugas kurir…
} else {
…lakukan tugas-tugas lainnya…
}
}
public static void main(String args[]) {
Manajer man = new Manajer();
Kurir kur = new Kurir();
Proses(man);
Proses(kur);
}
}

33
Seringkali pemakaian instanceof diikuti dengan casting object dari tipe parameter ke tipe
asal. Misalkan saja program kita sebelumnya. Pada saat kita sudah melakukan instanceof dari
tipe Manajer, kita dapat melakukan casting object ke tipe asalnya, yaitu Manajer. Caranya
adalah seperti berikut:

…
if (peg instanceof Manajer) {
Manajer man = (Manajer) peg;
…lakukan tugas-tugas manajer…
}
…

Tujuan dari Polymorph adalah:

1. Agar komunikasi antar obyek satu dengan lainnya dapat terjadi secara dinamis,
dimana “message”/permintaan yang disampaikan dari satu obyek ke obyek lain bisa
berbeda-beda tanggapannya dengan obyek lainnya.
2. Diimplementasikan dalam respon yang berbeda-beda, melalui pewarisan dan
implementasi interface.
3. Digunakan juga untuk standarisasi

Kemampuan obyek-obyek yang berbeda untuk memberi respon terhadap permintaan yang
sama, sesuai dengan cara masing-masing obyek.
1. Polymorfisme melalui inheritance (extends)
2. Polymorfisme melalui interface (implements)

dan dapat diterapkan dengan beberapa cara, yakni

1. Overriding Method
2. Overloading Method

Berikut beberapa karakteristik objek dalam menerapkan prinsip polymorph

1. Object dinamis suatu class induk dapat berperilaku seperti class turunan.
2. Ketika object menunjuk class induk, object berperilaku seperti class induk.
3. Ketika object menunjuk class turunan, object tersebut berperilaku seperti class
turunan

34
A contoh = new B()

• Maka obyek contoh sebenarnya bertipe class A namun berperilaku secara class B
• Atribut dan method pada obyek contoh akan mengikuti class A, bukan class B

Review: Overriding

1. Subclass yang berusaha memodifikasi tingkah laku yang diwarisi dari superclass.
2. Tujuan: subclass memiliki tingkah laku yang lebih spesifik.
3. Dilakukan dengan cara mendeklarasikan kembali method milik parent class di
subclass.

Contoh Overriding

class Animal {

35
 public String bersuara() {
return "Suara binatang";
}
}

class Dog extends Binatang {

public String bersuara() {
return "Guk guk";
}
}

Review – Overloading

Aturan overloading:
1. Nama method harus sama
2. Daftar parameter harus berbeda
3. Return type boleh sama, juga boleh berbeda

Hal yang penting untuk diketahui dalam konsep polimorphism adalah:

1. Berhubungan dengan standarisasi
2. Pada hubungan pewarisan, class anak dan induk adalah sejenis
3. Sifat “sejenis” dengan induknya itulah yang dapat digunakan untuk membuat kelas
“umum” yang dapat menggunakan kelas yang bertipe induk namun bertingkah laku
sesuai dengan kelas anaknya

36
 BAB VI

ABSTRACTION

Abstrak merupakan bentuk khusus dari inheritance atau pewarisan yang

memungkinkan adanya keharusan untuk menuliskan kembali method dari class induk. Class
yang memiliki sifat tersebut disebut Kelas Abstrak atau Abstract Class. Kelas Abstrak
memiliki abstract method (berupa prosedur dan fungsi), yang harus dituliskan kembali oleh
class yang meng-extends abstract class tersebut. Kelas abstrak memiliki sifat tidak dapat
diinstansiasi dan digunakan hanya untuk diturunkan ke dalam bentuk kelas konkret atau kelas
abstrak berikutnya. Dalam class diagram, abstract class dan abstract method dituliskan
menggunakan huruf miring. Untuk pengkodean, kelas abstrak dideklarasikan menggunakan
keyword abstract. Setiap abstract method tidak memiliki body method, sehingga pada
pendeklarasian diakhiri titik koma (;), bukan kurung kerawal buka-tutup ({}).
Abstract class adalah class yang mempunyai setidaknya satu abstract method. Abstract
method adalah method yang tidak memiliki body (hanya deklarasi method) memiliki body
(hanya deklarasi method). Abstract class tidak bisa dibuat objeknya. Obyek hanya bisa dibuat
dari non-abstract class (concrete class). Konsekuensinya suatu abstract class haruslah
Konsekuensinya, suatu abstract class haruslah diturunkan dimana pada subclass tersebut
berisi implementasi dari abstract method yang di superclassnya.

Bila subclass yang diturunkan dari abstract class tidak mengimplementasikan isi
semua method abstrak parent class, maka subclass tersebut harus tetap dideklarasikan
abstract. Dan deklarasi method abstract pada subclass tersebut boleh tidak dituliskan kembali.

Kegunaan Class Abstract:

1. Class Abstract berisi beberapa method dan beberapa method abstract. Class Abstract
berisi sebagian implementasi, dan subclass yang melengkapi implementasinya.
Dengan kata lain Class Abstract memiliki beberapa kesamaan (Bagian yang
diimplementasikan oleh subclass) dan memiliki perbedaan (method yang dimiliki
sendiri oleh class abstract )
2. Deklarasikan method abstract, jika ada satu atau lebih subclass yang diharapkan
mempunyai fungsionalitas yang sama tapi implementasi berbeda.
3. Gunakan class abstract untuk mendefinisikan behavior secara umum sebagai
superclass, sedangkan subclass menyediakan implementasi detail.

37
 4. Jika class abstract semua method merupakan method abstract, sebaiknya class abstract
tersebut diganti menjadi Interface.

Bentuk umum:

public abstract class NamaKelasAbstrak{

/*deklarasi atribut dan konstanta*/

public abstract void namaProsedurAbstrak();

public abstract int namaFungsiAbstrak();
public abstract String namaFungsiAbstrakDua();

/* kode lainnya*/
}

Misalnya kita ingin membuat superclass yang mempunyai method tertentu yang berisi
implementasi, dan juga beberapa method yang akan di-overridden oleh subclasses nya.
Sebagai contoh, kita akan membuat superclass bernama LivingThing. class ini mempunyai
method tertentu seperti breath, eat, sleep, dan walk. Akan tetapi, ada beberapa method di
dalam superclass yang sifatnya tidak dapat digeneralisasi. Kita ambil contoh, method walk.
Tidak semua kehidupan berjalan(walk) dalam cara yang sama. Ambil manusia sebagai misal,
kita manusia berjalan dengan dua kaki, dimana kehidupan lainnya seperti anjing berjalan
dengan empat kaki. Akan tetapi, beberapa ciri umum dalam kehidupan sudah biasa, itulah
kenapa kita inginkan membuat superclass umum dalam hal ini.

Kita dapat membuat superclass yang mempunyai beberapa method dengan

implementasi sedangkan yang lain tidak. Class jenis ini yang disebut dengan class abstract.
Sebuah class abstract adalah class yang tidak dapat di-instantiate. Seringkali muncul di atas
hirarki class pemrograman berbasis object, dan mendefinisikan keseluruhan aksi yang
mungkin pada object dari seluruh subclasses dalam class. Method ini dalam class abstract
yang tidak mempunyai implementasi dinamakan method abstract. Untuk membuat method
abstract, tinggal menulis deklarasi method tanpa tubuh class dan digunakan menggunakan
kata kunci abstract. Contohnya,

public abstract void someMethod();

38
Sekarang mari membuat contoh class abstract.

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-overridden oleh subclasses
*/
public abstract void walk();
}

Ketika class meng-extend class abstract LivingThing, dibutuhkan untuk override method
abstract walk(), atau lainnya, juga subclass akan menjadi class abstract, oleh karena itu tidak
dapat di-instantiate. Contohnya,

public class Human extends LivingThing

{
public void walk(){
System.out.println("Human walks...");
}
}

Jika class Human tidak dapat overridde method walk, kita akan menemui pesan error berikut
ini,

39
 BAB VII

ENCAPTULATION

Encapsulation yang terkadang disebut juga dengan information hiding pada dasarnya
adalah kombinasi antara data dan method pada sebuah class yang ditujukan untuk
menyembunyikan detail dari user (pengakses class) terhadap suatu object. Jika kita ambil
contoh, maaf, yang agak sedikit vulgar tentang bagaimana orang lain “mengakses data” milik
kita. Anggaplah orang ingin tahu apakah kita mempunyai penyakit panu yang merupakan
suatu “data” pada diri kita. Sudah barang tentu, secara umum, kita tidak akan mengijinkan
orang lain melihat langsung kulit kita karena itu adalah bagian “pribadi”. Akan tetapi orang
lain dapat mengetahuinya menggunakan “metode” penyampaian yang kita berikan: “Saya
tidak panuan”. Jadi ada bagian “publik” dan juga ada bagian “pribadi”.

Di dalam OOP, encapsulation dapat dilakukan dengan terlebih dahulu memahami

access modifier yang mendefiniskan bagaimana suatu data atau method dapat diakses. Ada
empat macam access modifier pada OOP, yaitu:
- Private : hanya diakses class itu sendiri
- Public : dapat diakses dari manapun
- Protected : hanya dapat diakses dari package (satu folder) dan subclass
- Default : tanpa modifier, hanya bisa diakses dari package dan class itu sendiri.

Dengan menggunakan encapsulation kita dapat membatasi akses langsung suatu class atau
program kecuali melalui suatu method yang sudah diberikan.

Perhatikan class Mahasiswa dan class MahasiswaTest berikut ini. Perhatikan pula cara
deklarasi atribut dan methodmethod yang terdapat dalam class Mahasiswa.

Contoh:

Public class Mahasiswa{

//deklarasi private attribute
private String nama;
private String nim;
private String alamat;
public Mahasiswa() {}

//Constructor dengan dua input parameter

public Mahasiswa(String nama, String nim) {
this.nama = nama;
this.nim = nim;
}
//Constructor dengan tiga input parameter
public Mahasiswa(String nama, String nim, String alamat) {
this.nama = nama;
this.nim = nim;
this.alamat = alamat;
}

40
 //mengakses atribut alamat
public String getAlamat() {
return alamat;
}
//mengakses atribut nama
public String getNama() {
return nama;
}
//mengakses attribut nim
public String getNim() {
return nim;
}
//mengisi atribut alamat
public void setAlamat(String alamat) {
this.alamat = alamat;
}
}

class MahasiswaTest{
public static void main(String[] args){
Mahasiswa objMhs;
String localNama, localNim;
objMhs=new Mahasiswa("Andriani","123456");
objMhs.setAlamat("Watugong 212 Malang");
localNama=objMhs.getNama();
localNim=objMhs.getNim();
}
}

Bukankah lebih sederhana jika pada class Mahasiswa kita deklarasikan data nama,
nim, dan alamat dengan acces modifier public daripada harus membuat method-method
khusus untuk mengaksesnya. Demikian pula cara penggunaannya class MahasiswaTest,
mengambil dan mengubah isi data akan lebih sederhana.

class Mahasiswa{
//deklarasi private attribute
public String nama;
public String nim;
public String alamat;
}
class MahasiswaTest{
public static void main(String[] args){
Mahasiswa objMhs;
String localNama, localNim;
objMhs=new Mahasiswa("Andriani","123456");

objMhs.alamat="Watugong 212 Malang";

localNama=objMhs.nama;

41
 localNim=objMhs.nim;
}
}

Saat membuat object objMhs yang bisa dianggap sebagai proses “membuat seorang
mahasiswa”, maka data nama dan nim tidak boleh diubah selama mahasiswa tersebut ada
sehingga kita harus membuat data nama dan nim sebagai data read only. Jika data-data ini
dibuat tidak readonly yang dapat memberikan peluang akses penuh, maka kemungkinan akan
terdapat masalah tersendiri. Dengan demikian kita perlu melindungi data nama dan nim dari
perubahan-perubahan dari luar class, sehingga perlu diberikan modifier private. Kita akan
buktikan pada kasuskasus berikutnya.

Method getNama, getNim, dan getAlamat disebut sebagi accesor method karena
method tersebut memberikan kembalian nilai data yang sederhana. Sedangkan setAlamat
disebut sebagai mutator method karena digunakan untuk memberikan suatu nilai yang
sederhana. Langkah-langkah di atas selanjutnya dapat kita gunakan untuk menerapkan sifat
encapsulation atau information hiding. Jadi pada dasarnya encapsulation dapat kita lakukan
dengan :

- Mendeklarasikan data atau attribut dengan modifier private

- Memberikan accessor method (getter) untuk mengakses data
- Memberikan mutator method (setter) untuk memberikan nilai ke suatu data.

42
 BAB VIII
INTERFACE

Interface adalah jenis khusus dari blok yang hanya berisi method signature(atau
constant ). Interface mendefinisikan sebuah(signature) dari sebuah kumpulan method tanpa
tubuh. Interface mendefinisikan sebuah cara standar dan umum dalam menetapkan sifat-sifat
dari class-class. Mereka menyediakan class-class, tanpa memperhatikan lokasinya dalam
hirarki class, untuk mengimplementasikan sifat-sifat yang umum. Dengan catatan bahwa
interface-interface juga menunjukkan polimorfisme, dikarenakan program dapat memanggil
method interface dan versi yang tepat dari method yang akan dieksekusi tergantung dari tipe
object yang melewati pemanggil method interface.
Kita akan menggunakan interface jika kita ingin class yang tidak berhubungan
mengimplementasikan method yang sama. Melalui interface-interface, kita dapat menangkap
kemiripan diantara class yang tidak berhubungan tanpa membuatnya seolaholah class yang
berhubungan.

Misalkan class Line dimana berisi method yang menghitung panjang dari garis dan
membandingkan object Line ke object dari class yang sama. Sekarang, misalkan kita punya
class yang lain yaitu MyInteger dimana berisi method yang membandingkan object
MyInteger ke object dari class yang sama. Seperti yang kita lihat disini, kedua class-class
mempunyai method yang mirip dimana membandingkan mereka dari object lain dalam tipe
yang sama, tetapi mereka tidak berhubungan sama sekali. Supaya dapat menjalankan cara
untuk memastikan bahwa dua class-class ini mengimplementasikan beberapa method dengan
tanda yang sama, kita dapat menggunakan sebuah interface untuk hal ini. Kita dapat
membuat sebuah class interface, katakanlah interface Relation dimana mempunyai deklarasi
method pembanding. Relasi interface dapat dideklarasikan sebagai,

public interface Relation{

public boolean isGreater( Object a, Object b);
public boolean isLess( Object a, Object b);
public boolean isEqual( Object a, Object b);
}

Alasan lain dalam menggunakan interface pemrograman object adalah untuk

menyatakan sebuah interface pemrograman object tanpa menyatakan classnya. Seperti yang
dapat kita lihat nanti dalam bagian Interface vs class, kita dapat benar-benar menggunakan
interface sebagai tipe data. Pada akhirnya, kita perlu menggunakan interface untuk pewarisan
model jamak dimana menyediakan class untuk mempunyai lebih dari satu superclass.
Pewarisan jamak tidak ditunjukkan di Java, tetapi ditunjukkan di bahasa berorientasi object
lain seperti C++.

Interface vs. Class Abstract:

Perbedaan utama antara sebuah interface dan sebuah class abstract: method interface
tidak punya tubuh, sebuah interface hanya dapat mendefinisikan konstanta dan interface tidak
langsung mewariskan hubungan dengan class istimewa lainnya, mereka didefinisikan secara
independent.

Interface vs. Class:

43
 Satu ciri umum dari sebuah interface dan class adalah pada tipe mereka berdua. Ini
artinya bahwa sebuah interface dapat digunakan dalam tempat-tempat dimana sebuah class
dapat digunakan. Sebagai contoh, diberikan class Person dan interface PersonInterface,
berikut deklarasi yang benar:
PersonInterface pi = new Person();
Person pc = new Person();
Bagaimanapun, Anda tidak dapat membuat instance dari sebuah interface. Contohnya:

PersonInterface pi = new PersonInterface(); //COMPILE //ERROR!!!

Membuat Interface:

Untuk membuat interface, kita tulis,

public interface [InterfaceName]{

//beberapa method tanpa isi
}

Sebagai contoh, mari kita membuat sebuah interface yang mendefinisikan hubungan antara
dua object menurut urutan asli 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);
}

Sekarang, penggunaan interface, kita gunakan kata kunci implements. Contohnya,

/**
* Class ini mendefinisikan segmen 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;
}
public double getLength(){
double length = Math.sqrt((x2-x1)*(x2-x1) +
(y2-y1)* (y2-y1));
return length;
}

44
 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);
}
}

Ketika class Anda mencoba mengimplementasikan sebuah interface, selalu pastikan bahwa
Anda mengimplementasikan semua method dari interface, jika tidak, Anda akan menemukan
kesalahan.

Hubungan dari Interface ke Class:

Seperti yang telah kita lihat dalam bagian sebelumnya, class dapat mengimplementasikan
sebuah interface selama kode implementasi untuk semua method yang didefinisikan dalam
interface tersedia. Hal lain yang perlu dicatat tentang hubungan antara interface ke class-class
yaitu, class hanya dapat mengEXTEND SATU superclass, tetapi dapat
mengIMPLEMENTASIkan BANYAK interface. Sebuah contoh dari sebuah class yang
mengimplementasikan interface adalah,

public class Person implements PersonInterface, LivingThing, WhateverInterface {

//beberapa kode di sini
}

Contoh lain dari class yang meng-extend satu superclass dan mengimplementasikan sebuah
interface adalah,

public class ComputerScienceStudent extends Student implements PersonInterface,

LivingThing {
//beberapa kode di sini
}

Catatan bahwa sebuah interface bukan bagian dari hirarki pewarisan class. Class yang tidak
berhubungan dapat mengimplementasikan interface yang sama.

45
Pewarisan Antar Interface:

Interface bukan bagian dari hirarki class. Bagaimanapun, interface dapat mempunyai
hubungan pewarisan antara mereka sendiri. Contohnya, misal kita punya dua interface
StudentInterface dan PersonInterface. Jika StudentInterface meng-extend PersonInterface,
maka ia akan mewariskan semua deklarasi method dalam PersonInterface.

public interface PersonInterface {

...
}
public interface StudentInterface extends PersonInterface {
...
}

46
 BAB IX

INTRO DESIGN PATTERN

Design pattern merupakan best practice yang digunakan oleh pengembang perangkat
lunak yang telah berpengalaman dalam melakukan pengembangan perangkat lunak dengan
menerapkan konsep objek oriented. Design pattern merupakan solusi untuk masalah-masalah
umum yang dihadapi oleh pengembang perangkat lunak selama mengembangkan perangkat
lunak. Ada beberapa design pattern yang biasa digunakan beberapa diantaranya seperti
berikut ini.

Tipe-tipe pattern:

Creational patterns:
Menginisialisasi dan mengkonfigurasi kelas dan objek. Beberapa diantaranya:

1. Abstract Factory: Unit yang digunakan untuk membangun obyek terkait.

2. Builder: Unit yang digunakan untuk membangun obyek yang kompleks secara
bertahap.
3. Factory Method: Metode dalam suatu kelas turunan untuk menciptakan asosiasi.
4. Prototype: Unit yang digunakan untuk mengkloning instances dari prototipe.
5. Singleton:Unit yang digunakan untuk instance yang tunggal.

Structural patterns:
Memisahkan interface dan implementasi kelas dan objek.Susunan jumlah kelas atau
objek.

1. Adapter: Translator yang beradaptasi terhadap suatu server interface untuk suatu
client.
2. Bridge: Abstraksi yang digunakan untuk mengikat menjadi satu dari banyak
implementasi yang dibuat.
3. Composite: Struktur untuk membangun agregasi rekursif.
4. Decorator: Dekorator memperluas suatu obyek secara terbuka.
5. Facade: Menyederhanakan interface untuk subsistem.
6. Flyweight: Banyak objek kecil/spesifik yang di-share secara efisien.
7. Proxy: Satu objek yang mendekati objek lain

Behavioral patterns:

Interaksi dinamis antara kumpulan semua kelas dan objek. Bagaimana Pattern
mendistribusikan tanggung jawab/ tugasnya masing-masing.
1. Chain of Responsibility: Me-request yang didelegasikan kepada penyedia layanan
yang menjadi tugas dan tanggung jawabnya.
2. Command: Me-request objek first-class.
3. Iterator: Menggabungkan elemen-elemen yang diakses secara skuensial.
4. Interpreter:Language interpreter for a small grammar (kompiler skala kecil).
5. Mediator: Mengkoordinasi interaksi antar asosiasi yang ada.
6. Memento: Gambaran melakukan captures dan restores keadaan suatu objek secara

47
 7. private.
8. Observer: Ketergantungan untuk update secara otomatis ketika seorang programmer
melakukan perubahan pada kodenya.
9. State: Obyek yang perilakunya tergantung pada keadaannya.
10. Strategy: Abstraksi untuk memilih salah satu dari sekian banyak algoritma.
11. Template Method: Algoritma dengan beberapa langkah yang telah disediakan oleh
suatu
12. kelas turunan.
Visitor: Operasi yang diterapkan pada elemen-elemen dari struktur objek yang heterogen/
sangat beragam

Berikut salah satu contoh dari design patterns

Factory Pattern
Merupakan salah satu design pola yang sering digunakan pada java. Berikut contoh
dari factory pattern.

48
Tahap 1: Buat sebuah interface

Shape.java

public interface Shape {

void draw();
}

Tahap 2: Buat kelas yang mengimplementasikan interface yang sama

Rectangle.java

public class Rectangle implements Shape {

@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}

Square.java

public class Square implements Shape {

@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}

Circle.java

49
public class Circle implements Shape {

@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}

Tahap 3: Buat sebuah Factory untuk menghasilkan kelas berdasarkan informasi yang
diberikan

ShapeFactory.java

public class ShapeFactory {

//use getShape method to get object of type shape

public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();

} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();

} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}

return null;
}
}

Tahap 4: Gunakan Factory untuk mendapatkan objek dari class dengan memasukkan
informasi yang dibutukan seperti tipe.

FactoryPatternDemo.java

public class FactoryPatternDemo {

public static void main(String[] args) {

ShapeFactory shapeFactory = new ShapeFactory();

//get an object of Circle and call its draw method.

Shape shape1 = shapeFactory.getShape("CIRCLE");

50
 //call draw method of Circle
shape1.draw();

//get an object of Rectangle and call its draw method.

Shape shape2 = shapeFactory.getShape("RECTANGLE");

//call draw method of Rectangle

shape2.draw();

//get an object of Square and call its draw method.

Shape shape3 = shapeFactory.getShape("SQUARE");

//call draw method of circle

shape3.draw();
}
}

51