KESIMPULAN

BAB 9-14

Disusun Oleh:

Nama : Sulthan Fajar Al Faysha

NIM : 2022903430082

Kelas : TRKJ 1.C

Jurusan : Teknologi Informasi dan Komputer

Program Studi : Teknologi Rekayasa Komputer Jaringan

Dosen Pembimbing : Indrawati, S.ST, M.T

JURUSAN TEKNOLOGI INFORMASI DAN KOMPUTER

PROGRAM STUDI TEKNOLOGI REKAYASA KOMPUTER JARINGAN
POLITEKNIK NEGERI LHOKSEUMAWE
TAHUN AJARAN 2022/2023
 Daftar isi
BAB 9 Pemograman Berorientasi Objek.............................................................1

9.1 konsep pemograman berorientasi objek.............................................................1

9.2 Menggunakan objek...........................................................................................1

9.3 Menciptakan kelas..............................................................................................2

9.4 Menggunakan kelas dalam pemograman...........................................................3

9.5 Kelas dengan metode.........................................................................................4

9.6 Kata Kunci this...................................................................................................5

9.7 Lingkup Variabel...............................................................................................6

9.8 Penetu Akses : private dan public......................................................................7

9.9 Metode Kelas.....................................................................................................8

BAB 10 Konstruktor dan Overloading................................................................9

10.1 Konstruktor......................................................................................................9

10.2 Overloading terhadap Konstruktor.................................................................10

10.3 Overloading pada Metode..............................................................................11

10.4 variabel kelas..................................................................................................12

BAB 11 Pewarisan................................................................................................13

11.1 Pengertian Pewarisan.....................................................................................13

11.2 Cara Mewariskan Kelas.................................................................................15

11.3 Penentu Akses Protected................................................................................16

11.4 Memanggil Metode Superkelas.....................................................................17

11.5 Memanggil Konstruktor Superkelas..............................................................17

11.6 Penentu Akses final........................................................................................18

11.7 Objek dalam kelas..........................................................................................19

11.8 Penentu Abstract............................................................................................20

ii
11.9 Ikatan dimanis pada variabel bertipe kelas....................................................21

BAB 12 Paket........................................................................................................22

12.1 Pengantar Paket..............................................................................................22

12.2 Mendeklarasikan Paket..................................................................................23

12.3 Menggunakan import.....................................................................................24

BAB 13 Interface..................................................................................................25

13.1 Pengertian Interface.......................................................................................25

13.2 Mendeklarasikan Interface.............................................................................26

13.3 Pewarisan Interface........................................................................................28

13.4 Menggunakan Interface..................................................................................29

BAB 14 Penanganan Eksepsi..............................................................................30

14.1 Penanganan Eksepsi.......................................................................................30

14.1 Menangkap Eksepsi.......................................................................................31

14.3 Catch secara Bertingkah.................................................................................32

14.4 Melontarkan Eksepsi......................................................................................33

14.5 Melontarkan kembali Eksepsi........................................................................33

14.6 Klausa throws.................................................................................................34

iii
  BAB 9 Pemograman Berorientasi Objek

 9.1 konsep pemograman berorientasi objek

Konsep dari object oriented programming (OOP) adalah lebih dari sekedar
sebuah konsep pemrograman, Object oriented programming adalah cara berpikir
tentang aplikasi yang mempelajari untuk berpikir bahwa aplikasi bukan sekedar
prosedur melainkan sebagai object. Object yang dimaksud disini memiliki
pengertian suatu modul yang mengkombinasikan antara data dan kode program
yang bekerja sama dalam program dengan melewatkan proses satu sama lain. Jadi
object oriented programming merupakan cara yang paling efisien untuk menulis
program komputeryang sangat mudah untuk di kombinasikan dan untuk
dipergunakan kembali.

Object oriented programming lebih memfokuskan kepada manipulasi object.

Kenapa seorang programmer harus mempelajari object oriented programming
bahkan seorang programmer yang tidak pernah bekerja dengan object oriented
programing pun harus mempelajarinya juga. Hal ini dikarenakan pada suatu hari
nanti semua bahasa pemrograman akan menambahkan kemampuan object
oriented programming pada bahasanya.

 9.2 Menggunakan objek

Pemrograman berorientasi objek (PBO) adalah paradigma pemrograman

yang menggunakan konsep objek sebagai elemen dasar dalam memodelkan dan
membangun program. Dalam PBO, objek merupakan instansi dari kelas, yang
merupakan blueprint atau panduan untuk menciptakan objek-objek tersebut.Untuk
menggunakan objek dalam pemrograman berorientasi objek, langkah-langkah
umum yang perlu dilakukan adalah:

1. Mendefinisikan kelas: Pertama, Anda perlu mendefinisikan kelas yang

akan mewakili objek tertentu. Kelas ini berisi atribut (variabel) dan

1
 metode (fungsi) yang akan digunakan oleh objek tersebut. Misalnya, jika
Anda ingin membuat objek "Mobil", Anda dapat membuat kelas "Mobil"
yang memiliki atribut seperti "warna" dan "kecepatan" serta metode
seperti "maju" dan "berhenti".

2. Membuat objek: Setelah kelas didefinisikan, Anda dapat membuat objek

dengan menggunakan kelas tersebut. Objek adalah instansi konkret dari
kelas yang memiliki atribut dan metode yang sama dengan kelas tersebut.
Misalnya, Anda dapat membuat objek "mobilMerah" dari kelas "Mobil"
dengan atribut "warna" yang bernilai "merah".

3. Mengakses atribut dan metode objek: Setelah objek dibuat, Anda dapat
mengakses atribut dan metode objek tersebut. Anda dapat mengubah nilai
atribut, memanggil metode untuk melakukan operasi, atau mendapatkan
informasi dari objek tersebut. Misalnya, Anda dapat mengakses atribut
"warna" objek "mobilMerah" dan mengubahnya menjadi "biru", atau
memanggil metode "maju" pada objek "mobilMerah" untuk membuatnya
bergerak maju.

 9.3 Menciptakan kelas

class Mahasiswa:
def __init__(self, nama, nim):
self.nama = nama
self.nim = nim

def perkenalan(self):
print("Halo, nama saya", self.nama)
print("NIM saya adalah", self.nim)

# Membuat objek mahasiswa1

mahasiswa1 = Mahasiswa("John Doe", "123456")

# Mengakses atribut dan memanggil metode objek

2
 print(mahasiswa1.nama) # Output: John Doe
print(mahasiswa1.nim) # Output: 123456
mahasiswa1.perkenalan() # Output: Halo, nama saya John Doe \n NIM saya
adalah 123456

Dalam contoh tersebut, kita menciptakan kelas "Mahasiswa" dengan

atribut "nama" dan "nim", serta metode "perkenalan". Metode __init__
merupakan metode khusus yang digunakan untuk menginisialisasi objek ketika
dibuat. Metode perkenalan digunakan untuk mencetak pesan perkenalan objek
Mahasiswa.

 9.4 Menggunakan kelas dalam pemograman

Menggunakan kelas dalam pemrograman berorientasi objek berarti

memanfaatkan kelas sebagai panduan atau blueprint untuk membuat objek-
objek yang memiliki atribut dan perilaku yang sama. Ketika kita menggunakan
kelas, kita dapat:

1. Membuat objek: Kita dapat membuat objek baru dari suatu kelas
dengan menggunakan sintaks nama_objek = NamaKelas(). Objek yang
dibuat akan memiliki atribut dan metode yang telah didefinisikan dalam
kelas.

2. Mengakses atribut: Setiap objek yang dibuat dari kelas memiliki

atribut-atribut yang telah didefinisikan dalam kelas tersebut. Kita dapat
mengakses atribut objek menggunakan sintaks
nama_objek.nama_atribut.

3. Memanggil metode: Metode adalah fungsi yang terkait dengan kelas.

Kita dapat memanggil metode pada objek dengan menggunakan sintaks
nama_objek.nama_metode(). Metode dapat digunakan untuk
melakukan operasi tertentu pada objek atau mengembalikan nilai.

3
 Dengan menggunakan kelas, kita dapat mengorganisasi dan mengelompokkan
kode program ke dalam struktur yang lebih teratur dan terorganisir. Setiap
objek yang dibuat dari kelas akan memiliki karakteristik dan perilaku yang
spesifik sesuai dengan atribut dan metode yang telah didefinisikan dalam kelas
tersebut. Hal ini memungkinkan untuk membuat program yang lebih modular,
dapat digunakan kembali, dan lebih mudah untuk dikelola.

 9.5 Kelas dengan metode

Dalam pemrograman berorientasi objek, kelas adalah suatu entitas yang

digunakan untuk memodelkan objek-objek dengan atribut dan perilaku yang
serupa. Kelas berfungsi sebagai blueprint atau cetak biru untuk membuat objek-
objek tersebut. Sedangkan metode adalah fungsi-fungsi yang terkait dengan suatu
kelas dan digunakan untuk menggambarkan perilaku atau operasi yang dapat
dilakukan oleh objek-objek yang dibuat dari kelas tersebut.

Lebih lanjut, berikut adalah pengertian dari kelas dan metode dalam pemrograman
berorientasi objek:

1. Kelas: Kelas merupakan struktur atau template yang mendefinisikan

atribut-atribut (variabel) dan metode-metode (fungsi) yang dimiliki oleh
objek-objek yang dibuat dari kelas tersebut. Kelas menyediakan kerangka
kerja untuk menciptakan objek-objek dengan karakteristik yang sama.
Dalam kelas, kita dapat mendefinisikan atribut-atribut yang
merepresentasikan data atau informasi yang dimiliki oleh objek, serta
metode-metode yang menggambarkan perilaku atau operasi yang dapat
dilakukan oleh objek.

2. Metode: Metode adalah fungsi-fungsi yang terkait dengan suatu kelas.

Metode didefinisikan di dalam kelas dan beroperasi pada objek-objek yang
dibuat dari kelas tersebut. Metode memiliki akses ke atribut-atribut dalam

4
 kelas dan dapat mengubah atau mengakses data yang dimiliki oleh objek.
Metode juga dapat melakukan operasi tertentu atau mengembalikan nilai
berdasarkan logika dan fungsionalitas yang telah didefinisikan dalam
metode tersebut. Metode memungkinkan objek untuk melakukan tindakan
atau berinteraksi dengan lingkungan sekitarnya.

Dengan menggunakan kelas dan metode, kita dapat mengorganisasi kode program
menjadi unit-unit yang lebih terstruktur dan terorganisir. Setiap objek yang dibuat
dari kelas akan memiliki atribut-atribut yang sesuai dengan kelas tersebut, serta
dapat memanggil metode-metode yang telah didefinisikan dalam kelas untuk
melakukan tugas-tugas yang relevan. Hal ini memungkinkan untuk menciptakan
program yang lebih modular, mudah dipahami, dan dapat digunakan kembali.

 9.6 Kata Kunci this

Kata kunci "this" dalam pemrograman berorientasi objek digunakan untuk

merujuk pada objek saat ini yang sedang diproses atau sedang berinteraksi dengan
metode atau atribut dalam kelas. Kata kunci "this" memberikan cara untuk
mengakses atau merujuk pada objek yang sedang aktif dalam konteks
pemrograman berorientasi objek.

Dalam konteks pemrograman berorientasi objek, "this" biasanya digunakan untuk:

1. Merujuk pada atribut objek: Dalam metode kelas, kata kunci "this"
digunakan untuk merujuk pada atribut objek saat ini. Ini memungkinkan
untuk mengakses atau memanipulasi nilai atribut objek. Misalnya,
this.nama akan merujuk pada atribut "nama" dari objek saat ini.

2. Memanggil metode objek: Dalam metode kelas, "this" dapat digunakan

untuk memanggil metode objek lainnya. Hal ini berguna ketika metode
yang dipanggil memerlukan objek saat ini sebagai argumen. Misalnya,

5
 this.metodeLain() akan memanggil metode "metodeLain()" dari objek saat
ini.

3. Mencegah konflik nama: Jika ada konflik nama antara parameter metode
dan atribut kelas, "this" digunakan untuk membedakan antara atribut kelas
dan parameter lokal. Misalnya, jika ada parameter "nama" dalam metode
dan juga atribut "nama" dalam kelas, menggunakan "this.nama" akan
merujuk pada atribut kelas.

Penggunaan kata kunci "this" dapat bervariasi tergantung pada bahasa

pemrograman yang digunakan. Beberapa bahasa menggunakan "this" (seperti
Java), sementara bahasa lain menggunakan kata kunci yang berbeda seperti "self"
(seperti Python). Meskipun kata kuncinya berbeda, konsepnya tetap sama, yaitu
untuk merujuk pada objek saat ini dalam konteks pemrograman berorientasi
objek.

 9.7 Lingkup Variabel

Dalam pemrograman berorientasi objek, lingkup variabel merujuk pada

bagaimana variabel dapat diakses atau digunakan di dalam kelas atau objek. Ada
beberapa jenis lingkup variabel yang umum dalam pemrograman berorientasi
objek, yaitu:

1. Variabel Instance (Instance Variable): Variabel instance adalah variabel

yang nilainya unik untuk setiap objek yang dibuat dari kelas. Variabel ini
dideklarasikan di dalam kelas tetapi di luar metode. Setiap objek memiliki
salinan variabel instance dan dapat mengaksesnya melalui objek tersebut.
Variabel instance digunakan untuk menyimpan data yang spesifik untuk
setiap objek. Contoh: atribut "nama" dalam kelas "Mahasiswa".

6
 2. Variabel Kelas (Class Variable): Variabel kelas adalah variabel yang
nilainya sama untuk semua objek yang dibuat dari kelas. Variabel ini
dideklarasikan di dalam kelas tetapi di luar metode dengan menggunakan
kata kunci "static" (pada beberapa bahasa pemrograman). Variabel kelas
bersifat bersama dan dapat diakses melalui kelas atau objek. Variabel ini
umumnya digunakan untuk menyimpan data yang bersifat bersama atau
terbagi di antara semua objek. Contoh: atribut "jumlahMahasiswa" dalam
kelas "Mahasiswa".

3. Variabel Lokal (Local Variable): Variabel lokal adalah variabel yang

dideklarasikan di dalam suatu metode atau blok kode tertentu dan hanya
dapat diakses di dalam lingkup tersebut. Variabel ini memiliki jangkauan
yang terbatas pada metode atau blok tempat mereka dideklarasikan.
Variabel lokal hanya dapat diakses selama eksekusi metode atau blok
tersebut. Contoh: variabel "umur" dalam metode "hitungUmur" dalam
kelas "Mahasiswa".

Lingkup variabel ini mempengaruhi aksesibilitas variabel dan berapa lama

variabel tersebut akan hidup selama eksekusi program. Pemahaman yang baik
tentang lingkup variabel sangat penting dalam memahami bagaimana data
disimpan dan diakses di dalam objek-objek yang dibuat dari kelas dalam
pemrograman berorientasi objek.

 9.8 Penetu Akses : private dan public

Pada pemrograman berorientasi objek, terdapat konsep aksesibilitas yang

digunakan untuk mengatur bagaimana atribut dan metode dalam suatu kelas dapat
diakses dari luar kelas tersebut. Dua jenis aksesibilitas yang umum digunakan
adalah "private" dan "public".

7
 1. Private: Ketika suatu atribut atau metode dinyatakan sebagai private, itu
berarti hanya dapat diakses dan dimodifikasi dari dalam kelas tersebut.
Atribut atau metode private tidak dapat diakses langsung dari luar kelas
atau objek yang dibuat dari kelas tersebut. Tujuan penggunaan private
adalah untuk menerapkan konsep encapsulation (enkapsulasi) dalam
pemrograman berorientasi objek, di mana detail internal dari suatu kelas
disembunyikan dari luar. Dalam beberapa bahasa pemrograman, biasanya
ditandai dengan kata kunci "private" atau simbol khusus seperti tanda garis
bawah ("_") di depan nama atribut atau metode.

2. Public: Ketika suatu atribut atau metode dinyatakan sebagai public, itu
berarti dapat diakses dan dimodifikasi dari luar kelas tersebut. Atribut atau
metode public dapat diakses secara langsung melalui objek yang dibuat
dari kelas tersebut. Penggunaan public memungkinkan objek lain atau
bagian dari program lain untuk berinteraksi dengan kelas dan mengakses
atau menggunakan atribut serta metode yang dinyatakan sebagai public.
Dalam beberapa bahasa pemrograman, biasanya ditandai dengan kata
kunci "public".

Dengan menggunakan konsep private dan public, kita dapat mengontrol

aksesibilitas dan membentuk antarmuka yang sesuai untuk objek dalam
pemrograman berorientasi objek. Ini membantu dalam memastikan keamanan,
integritas data, dan memungkinkan untuk mengimplementasikan prinsip-prinsip
encapsulation dan information hiding yang penting dalam desain yang baik dalam
pemrograman berorientasi objek

 9.9 Metode Kelas

Dalam pemrograman berorientasi objek, metode kelas (class methods)

adalah metode yang terkait dengan kelas itu sendiri, bukan dengan objek individu
yang dibuat dari kelas tersebut. Metode kelas didefinisikan di dalam kelas dan

8
 biasanya menggunakan kata kunci khusus, seperti "class method" (pada beberapa
bahasa pemrograman), untuk menandai bahwa mereka adalah metode kelas.

Berikut adalah beberapa karakteristik dan penggunaan metode kelas dalam

pemrograman berorientasi objek:

1. Deklarasi Metode Kelas: Untuk mendeklarasikan metode kelas, biasanya

digunakan kata kunci khusus seperti "class method" atau "static"
(tergantung pada bahasa pemrograman yang digunakan). Metode kelas
didefinisikan di dalam kelas, tetapi tidak memerlukan instance atau objek
kelas untuk dipanggil. Contoh deklarasi metode kelas dalam bahasa Java:

2. Akses Tanpa Membuat Objek: Salah satu fitur utama metode kelas adalah
kemampuan untuk diakses tanpa membuat objek dari kelas tersebut.
Metode kelas dipanggil langsung melalui nama kelasnya, tanpa perlu
membuat objek terlebih dahulu. Ini berguna jika Anda ingin menggunakan
fungsionalitas kelas tanpa memerlukan objek spesifik.

3. Akses Atribut Kelas: Metode kelas biasanya memiliki akses terhadap

atribut kelas (variabel kelas). Ini berarti Anda dapat mengakses atau
memodifikasi nilai atribut kelas dalam metode kelas. Atribut kelas bersifat
bersama di antara semua objek yang dibuat dari kelas tersebut, dan dapat
digunakan untuk menyimpan data yang terkait dengan kelas secara
keseluruhan.

 BAB 10 Konstruktor dan Overloading

 10.1 Konstruktor
Konstruktor adalah sebuah method atau fungsi khusus yang ada di dalam
suatu class di dalam bahasa pemrograman yang digunakan untuk membuat objek
baru dari class tersebut. Konstruktor ini biasanya memiliki nama yang sama

9
 dengan nama classnya, dan dapat memiliki parameter atau tidak. Konstruktor
dijalankan otomatis ketika objek baru dibuat dari class, dan biasanya digunakan
untuk menginisialisasi nilai awal dari atribut-atribut (properties) yang dimiliki
oleh objek tersebut.i awal dari atribut-atribut (properties) yang dimiliki oleh objek
tersebut. akan otomatis dipanggil untuk melakukan inisialisasi nilai-nilai awal dari
objek tersebut.

Setiap kelas pada Java minimal memiliki satu konstruktor, yaitu konstruktor
bawaan (default constructor). Konstruktor bawaan ini akan dibuat otomatis oleh
Java jika tidak ada konstruktor yang didefinisikan oleh pengguna. Konstruktor
bawaan hanya melakukan inisialisasi nilai-nilai awal dari objek dengan nilai-nilai
default dari tipe data masing-masing.

Konstruktor pada Java sangat penting dalam pembuatan objek, karena dengan
konstruktor, pengguna bisa memastikan bahwa nilai-nilai awal dari objek sudah
terinisialisasi dengan benar, sehingga objek tersebut dapat digunakan dengan
benar pada saat program dijalankan.panjang konstruktor pada bahasa
pemrograman Java merujuk pada jumlah parameter yang diterima oleh
konstruktor tersebut. Jumlah parameter ini dapat bervariasi tergantung dari
kebutuhan dalam inisialisasi objek dari suatu class.

 10.2 Overloading terhadap Konstruktor

Overloading konstruktor adalah konsep dalam pemrograman berorientasi

objek di mana sebuah kelas memiliki beberapa konstruktor dengan nama yang
sama tetapi memiliki parameter yang berbeda. Dengan overloading konstruktor,
Anda dapat membuat objek kelas dengan cara yang berbeda tergantung pada
parameter yang Anda berikan saat membuatnya.

Berikut adalah beberapa hal yang perlu diperhatikan tentang overloading

konstruktor:

10
 1. Nama yang Sama, Parameter yang Berbeda: Konstruktor-overloading
memungkinkan Anda menggunakan nama yang sama untuk beberapa
konstruktor dalam kelas, tetapi dengan daftar parameter yang berbeda. Ini
memungkinkan Anda membuat konstruktor yang dapat menerima jenis
atau jumlah parameter yang berbeda untuk menginisialisasi objek dengan
cara yang berbeda.

2. Parameter yang Berbeda: Dalam konstruktor-overloading, parameter

konstruktor dapat berbeda dalam hal jenis, urutan, atau jumlahnya.
Misalnya, Anda dapat memiliki konstruktor dengan satu parameter integer
dan konstruktor lainnya dengan dua parameter string.

3. Kemampuan untuk Memanggil Konstruktor Lain: Dalam konstruktor-

overloading, Anda juga dapat memanggil konstruktor lain dalam
konstruktor yang sedang didefinisikan menggunakan kata kunci this(). Ini
memungkinkan inisialisasi yang lebih fleksibel dan penggunaan kembali
kode inisialisasi yang sama dalam konstruktor yang berbeda.

 10.3 Overloading pada Metode

Overloading pada metode adalah konsep dalam pemrograman berorientasi

objek di mana sebuah kelas memiliki beberapa metode dengan nama yang sama
tetapi memiliki parameter yang berbeda. Dengan overloading metode, Anda dapat
memiliki beberapa implementasi metode yang berbeda dengan tugas yang sama
tetapi dengan tipe atau jumlah parameter yang berbeda.

Berikut adalah beberapa hal yang perlu diperhatikan tentang overloading pada
metode:

1. Nama yang Sama, Parameter yang Berbeda: Overloading pada metode

memungkinkan Anda menggunakan nama yang sama untuk beberapa

11
 metode dalam kelas, tetapi dengan daftar parameter yang berbeda. Anda
dapat memiliki metode dengan nama yang sama tetapi menerima jenis atau
jumlah parameter yang berbeda.

2. Parameter yang Berbeda: Dalam overloading metode, parameter metode

dapat berbeda dalam hal jenis, urutan, atau jumlahnya. Misalnya, Anda
dapat memiliki metode calculateArea(int radius) untuk menghitung luas
lingkaran dengan jari-jari integer dan metode calculateArea(double radius)
untuk menghitung luas lingkaran dengan jari-jari bilangan desimal.

3. Pemanggilan Metode yang Sesuai: Saat Anda memanggil metode yang di-
overload, compiler akan memilih metode yang sesuai berdasarkan
argumen yang Anda berikan. Compiler akan mencocokkan argumen yang
Anda berikan dengan tipe parameter yang dideklarasikan dalam metode
yang di-overload dan memilih implementasi yang sesuai.

 10.4 variabel kelas

Variabel kelas dikenal juga sebagai variabel statik (static variables) karena
mereka memiliki nilai yang sama di antara semua objek kelas dan dapat diakses
melalui nama kelas tanpa perlu membuat objek.

Berikut adalah pengertian variabel kelas (variabel statik) dalam konteks

konstruktor:

1. Deklarasi Variabel Kelas: Variabel kelas dideklarasikan dengan

menggunakan kata kunci static sebelum tipe data variabel. Mereka
ditempatkan di dalam kelas tetapi di luar metode konstruktor dan metode
lainnya.

12
 2. Sifat Bersama: Variabel kelas bersifat bersama di antara semua objek yang
dibuat dari kelas tersebut. Ini berarti bahwa nilai variabel kelas sama untuk
semua objek dan berlaku untuk kelas secara keseluruhan.

3. Pengaksesan Variabel Kelas: Variabel kelas dapat diakses langsung

melalui nama kelas, tanpa perlu membuat objek. Anda dapat menggunakan
sintaks NamaKelas.namaVariabel untuk mengakses atau memodifikasi
nilai variabel kelas.

4. Penggunaan dalam Konstruktor: Variabel kelas dapat digunakan dalam

konstruktor untuk melakukan inisialisasi atau melakukan operasi lain yang
melibatkan variabel kelas tersebut. Misalnya, Anda dapat menggunakan
variabel kelas untuk melacak jumlah objek yang telah dibuat dari kelas.

 BAB 11 Pewarisan

 11.1 Pengertian Pewarisan

Pewarisan (inheritance) adalah konsep dalam pemrograman berorientasi objek

di mana sebuah kelas dapat mewarisi properti dan metode dari kelas lain. Dalam
pewarisan, kelas yang mewarisi disebut sebagai kelas anak atau subkelas,
sedangkan kelas yang memberikan warisan disebut sebagai kelas induk atau
superkelas.

Dengan pewarisan, kelas anak dapat mewarisi semua atribut dan metode dari
kelas induk, termasuk variabel, metode, dan perilaku kelas induk. Hal ini
memungkinkan kita untuk membuat hierarki kelas yang lebih terstruktur dan
memanfaatkan kembali kode yang sudah ada.

Beberapa hal yang perlu diperhatikan tentang pewarisan adalah sebagai berikut:

13
 1. Hubungan Hierarki: Pewarisan menciptakan hubungan hierarki antara
kelas anak dan kelas induk. Kelas anak mewarisi semua karakteristik kelas
induk dan dapat menambahkan atau mengubah perilaku atau properti yang
diwarisi.

2. Dapat Mewarisi Multiple Kelas: Beberapa bahasa pemrograman

mendukung pewarisan berganda (multiple inheritance), yang berarti
sebuah kelas anak dapat mewarisi properti dan metode dari lebih dari satu
kelas induk. Namun, pewarisan berganda juga dapat menimbulkan
kompleksitas dan konflik nama, sehingga tidak semua bahasa
pemrograman mendukung fitur ini.

3. Konsep "IS-A": Pewarisan menggunakan konsep "IS-A" di mana kelas

anak dapat dikatakan "IS-A" kelas induk. Misalnya, jika terdapat kelas
Mobil dan kelas Sedan, kita dapat mengatakan "Sedan" IS-A "Mobil",
sehingga kelas Sedan dapat mewarisi properti dan metode dari kelas
Mobil.

4. Override: Dalam pewarisan, kelas anak dapat mengganti (override) metode

yang diwarisi dari kelas induk dengan implementasi yang berbeda. Ini
memungkinkan kelas anak untuk memiliki perilaku yang khusus sesuai
dengan kebutuhan mereka.

Pewarisan memungkinkan penggunaan yang lebih efisien dan efektif dari

kode, karena kita dapat memanfaatkan kembali fungsionalitas yang sudah ada di
kelas induk dan menambahkan fitur-fitur khusus di kelas anak. Hal ini juga
memungkinkan pemodelan hierarki dan struktur yang lebih baik dalam desain
kelas.

 11.2 Cara Mewariskan Kelas

14
 Anda dapat mewariskan sebuah kelas ke kelas lain menggunakan konsep
pewarisan dalam pemrograman berorientasi objek. Berikut adalah langkah-
langkah umum untuk mewariskan kelas:

1. Tentukan Kelas Induk (Superclass): Pilih kelas yang akan menjadi kelas
induk atau superclass. Kelas ini akan memberikan warisan properti dan
metode kepada kelas anak.

2. Tentukan Kelas Anak (Subclass): Buat kelas baru yang akan menjadi kelas
anak atau subclass. Kelas ini akan mewarisi properti dan metode dari kelas
induk.

3. Gunakan Kata Kunci "extends": Dalam deklarasi kelas anak, gunakan kata
kunci "extends" diikuti dengan nama kelas induk yang ingin Anda warisi.
Misalnya, class Anak extends Induk.

4. Akses Properti dan Metode Kelas Induk: Setelah mewarisi kelas induk,
kelas anak dapat mengakses properti dan metode kelas induk dengan
menggunakan operator titik (.). Anda dapat menggunakan properti dan
metode kelas induk seolah-olah mereka adalah milik kelas anak.

5. Menggunakan Override (Opsional): Jika Anda ingin mengubah perilaku

metode yang diwarisi dari kelas induk, Anda dapat menggunakan override.
Dalam kelas anak, deklarasikan metode yang sama seperti di kelas induk
dengan implementasi yang berbeda. Gunakan anotasi @Override (untuk
bahasa yang mendukung) untuk menandai bahwa metode tersebut adalah
override.

 11.3 Penentu Akses Protected

15
 Penentu akses "protected" adalah salah satu penentu akses yang dapat
digunakan dalam pemrograman berorientasi objek. Dalam konteks pewarisan
(inheritance), penggunaan penentu akses "protected" memberikan akses yang
lebih terbatas daripada "public", tetapi lebih luas daripada "private". Berikut
adalah pengertian dan ciri-ciri dari penentu akses "protected":

1. Akses di dalam Kelas Itu Sendiri: Ketika sebuah anggota (atribut atau
metode) dideklarasikan sebagai "protected", anggota tersebut dapat
diakses oleh metode dalam kelas itu sendiri. Dalam hal ini, tidak ada
perbedaan antara "protected" dan "private" karena keduanya dapat diakses
hanya dalam lingkup kelas yang sama.

2. Akses dalam Subkelas: Anggota yang dideklarasikan sebagai "protected"

juga dapat diakses oleh kelas anak (subclass) yang mewarisi kelas tersebut.
Ini berarti anggota "protected" dapat diakses dan digunakan oleh metode
dalam kelas anak.

3. Tidak Dapat Diakses di Luar Kelas dan Subkelas: Anggota yang

dideklarasikan sebagai "protected" tidak dapat diakses langsung dari luar
kelas atau subkelas, seperti halnya anggota "private". Artinya, akses
langsung ke anggota "protected" dari kelas lain atau di luar hierarki
pewarisan tidak diizinkan.

4. Digunakan untuk Memfasilitasi Pewarisan: Penentu akses "protected"

sering digunakan dalam konteks pewarisan untuk memungkinkan akses
terbatas ke anggota kelas induk oleh kelas anak. Dengan demikian, kelas
anak dapat menggunakan anggota "protected" dalam implementasi
khususnya, sementara masih menjaga keterbatasan akses dari kelas lain di
luar hierarki pewarisan.

 11.4 Memanggil Metode Superkelas

16
 Dalam pemrograman berorientasi objek, ketika sebuah kelas anak
mewarisi sebuah kelas induk, kita dapat menggunakan kata kunci super untuk
memanggil metode dari kelas induk tersebut. Dengan memanggil metode
superkelas, kita dapat menjalankan logika dari metode di kelas induk dan
kemudian menambahkan logika tambahan di kelas anak. Berikut adalah beberapa
hal yang perlu diperhatikan saat memanggil metode superkelas:

1. Notasi super.namaMetode(): Untuk memanggil metode dari kelas induk,

gunakan notasi super.namaMetode(). Ini akan mengarahkan pemanggilan
metode ke implementasi metode di kelas induk.

2. Penggunaan dalam Metode Override: Metode di kelas anak yang memiliki

nama yang sama dengan metode di kelas induk (override) dapat
memanggil metode superkelas untuk menjalankan logika dari metode di
kelas induk sebelum menambahkan logika tambahan.

3. Urutan Pemanggilan: Jika ada rantai pewarisan dengan beberapa tingkatan

(kelas anak, kelas cucu, dll.), pemanggilan metode superkelas dapat
dilakukan dalam setiap kelas anak. Ini memungkinkan kita untuk
menjalankan logika dari metode di setiap tingkatan pewarisan sebelum
mencapai implementasi di kelas anak saat ini.

 11.5 Memanggil Konstruktor Superkelas

ketika sebuah kelas anak mewarisi sebuah kelas induk, kita dapat
menggunakan kata kunci super untuk memanggil konstruktor dari kelas induk
tersebut. Pemanggilan konstruktor superkelas digunakan untuk melakukan
inisialisasi yang relevan di kelas induk sebelum melanjutkan dengan inisialisasi
kelas anak. Berikut adalah beberapa hal yang perlu diperhatikan saat memanggil
konstruktor superkelas:

17
 1. Notasi super(...): Untuk memanggil konstruktor dari kelas induk, gunakan
notasi super(...), diikuti dengan argumen yang sesuai dengan parameter
konstruktor kelas induk yang ingin Anda panggil. Anda dapat
menyediakan argumen yang diperlukan untuk inisialisasi kelas induk.

2. Penggunaan dalam Konstruktor Kelas Anak: Pemanggilan konstruktor

superkelas biasanya dilakukan di awal konstruktor kelas anak. Ini
memastikan bahwa inisialisasi yang diperlukan di kelas induk dilakukan
sebelum melanjutkan dengan inisialisasi kelas anak.

3. Pemanggilan Otomatis: Jika konstruktor kelas anak tidak secara eksplisit

memanggil konstruktor superkelas, maka secara otomatis konstruktor
tanpa argumen dari kelas induk akan dipanggil. Namun, jika kelas induk
tidak memiliki konstruktor tanpa argumen, maka Anda perlu secara
eksplisit memanggil konstruktor kelas induk yang sesuai.

 11.6 Penentu Akses final

Dalam pemrograman berorientasi objek, penentu akses final memiliki
beberapa pengaruh terhadap pewarisan kelas. Berikut adalah pengertian dan
pengaruh penentu akses final dalam konteks pewarisan:

1. Penentu Akses final pada Kelas Induk: Ketika sebuah kelas dideklarasikan
dengan penentu akses final, artinya kelas tersebut tidak dapat diwariskan
oleh kelas lain. Ini berarti tidak ada kelas anak yang dapat mewarisi kelas
tersebut. Jika kita mencoba untuk membuat kelas anak dari kelas yang
diberi penentu akses final, maka akan terjadi kesalahan kompilasi.

Contoh:
inal class Parent {
// Implementasi kelas Parent

18
 }

// Kode ini akan menghasilkan kesalahan kompilasi

class Child extends Parent {
// Implementasi kelas Child
}

2. Penentu Akses final pada Metode: Ketika sebuah metode dideklarasikan

dengan penentu akses final, artinya metode tersebut tidak dapat di-override
oleh metode dengan nama yang sama di kelas anak. Metode dengan
penentu akses final akan memiliki implementasi yang tetap dan tidak dapat
diubah dalam hierarki pewarisan.

Dalam kesimpulannya, penentu akses final dalam pewarisan memiliki pengaruh

yang berbeda tergantung pada konteksnya. Jika diterapkan pada kelas induk, itu
mencegah kelas tersebut diwarisi. Jika diterapkan pada metode, itu mencegah
override metode di kelas anak. Jika diterapkan pada variabel, variabel konstan
tersebut tetap dapat diwariskan tetapi nilainya tidak dapat diubah di kelas anak.

 11.7 Objek dalam kelas

Objek dalam kelas dalam pewarisan mengacu pada penggunaan objek
sebagai anggota kelas di dalam kelas lain dalam hierarki pewarisan. Dalam
pemrograman berorientasi objek, pewarisan memungkinkan kelas anak untuk
mewarisi properti dan metode dari kelas induk. Namun, selain mewarisi properti
dan metode, kelas anak juga dapat memiliki objek sebagai anggota kelasnya
sendiri.

Ketika sebuah objek dibuat dari kelas anak, objek tersebut dapat memiliki objek
yang terkait dengan kelas induk atau kelas lain dalam hierarki pewarisan. Objek
dalam kelas ini dapat digunakan untuk mengakses properti dan metode yang
terkait dengan objek tersebut, serta untuk menjalankan logika yang terkait dengan
objek dalam konteks kelas tersebut.

19
 Dengan menggunakan objek dalam kelas dalam pewarisan, kita dapat
menciptakan struktur yang lebih kompleks dan fleksibel. Objek dalam kelas dapat
mewakili hubungan antarobjek, komposisi, atau agregasi antara objek dalam

hierarki pewarisan.

Dalam pewarisan, objek dalam kelas dapat digunakan untuk menciptakan

relasi, komposisi, atau agregasi antara objek-objek dalam hierarki pewarisan.
Objek dalam kelas memungkinkan kita untuk memodelkan struktur yang lebih
kompleks dan lebih fleksibel dalam pemrograman berorientasi objek

 11.8 Penentu Abstract

Penentu akses abstract digunakan dalam pemrograman berorientasi objek
untuk mendefinisikan kelas abstrak dan metode abstrak. Pada dasarnya, kelas
abstrak adalah kelas yang tidak dapat diinstansiasi dan berfungsi sebagai kerangka
kerja untuk kelas-kelas turunannya.

Berikut adalah pengertian penentu akses abstract dalam konteks pewarisan:

1. Kelas Abstract: Ketika sebuah kelas dideklarasikan dengan penentu akses

abstract, itu berarti kelas tersebut adalah kelas abstrak. Kelas abstrak tidak
dapat diinstansiasi langsung, tetapi hanya digunakan sebagai kerangka
kerja untuk kelas-kelas turunannya. Kelas abstrak dapat memiliki metode
abstrak dan metode konkret.
2. Metode Abstract: Ketika sebuah metode dideklarasikan dengan penentu
akses abstract, itu berarti metode tersebut adalah metode abstrak. Metode
abstrak tidak memiliki implementasi dan harus diimplementasikan oleh
kelas-kelas turunannya. Kelas yang memiliki satu atau lebih metode
abstrak harus dideklarasikan sebagai kelas abstrak.

Dengan menggunakan penentu akses abstract, kita dapat membuat struktur kelas
abstrak dan metode abstrak yang dapat diwarisi oleh kelas-kelas turunannya.
Kelas abstrak dan metode abstrak membantu dalam menciptakan kerangka kerja

20
 yang lebih umum dan memungkinkan implementasi khusus di dalam kelas-kelas
turunan.

 11.9 Ikatan dimanis pada variabel bertipe kelas

Ikatan (binding) pada variabel bertipe kelas terjadi ketika sebuah variabel
diberikan nilai atau di-ikat (bind) dengan objek yang merupakan instance dari
kelas tersebut. Dalam konteks ini, variabel bertipe kelas berperan sebagai
referensi atau "penunjuk" ke objek yang sesungguhnya berada di memori.

Ketika variabel bertipe kelas diikat dengan objek, variabel tersebut akan mengacu
pada objek yang sama. Perubahan yang dilakukan pada objek akan terlihat melalui
variabel yang mengacunya. Dalam hal ini, ikatan variabel bertipe kelas
memungkinkan manipulasi dan akses ke data dan metode objek yang sebenarnya
ikatan variabel bertipe kelas sangat penting dalam pemrograman berorientasi
objek, karena memungkinkan penggunaan dan manipulasi objek secara efisien
melalui referensi atau "penunjuk" yang diwakili oleh variabel.

Jika Anda merujuk pada "ikatan manis" atau "binding manis" dalam
konteks variabel bertipe kelas, hal tersebut merujuk pada mekanisme ikatan
variabel dengan objek yang spesifik pada saat runtime. Dalam pemrograman
berorientasi objek, ikatan manis atau binding manis dikenal sebagai late binding
atau dynamic binding.

Dalam late binding, penentuan metode atau properti yang akan dipanggil terjadi
pada saat runtime, berdasarkan tipe objek yang sesuai dengan variabel yang
digunakan. Ini berarti saat Anda memiliki variabel dengan tipe kelas dan Anda
memanggil metode atau mengakses properti melalui variabel tersebut, metode
atau properti yang tepat akan dipilih berdasarkan jenis objek yang diikat dengan
variabel pada saat runtime.

21
  BAB 12 Paket

 12.1 Pengantar Paket

Paket dalam Java adalah cara untuk mengatur dan mengelompokkan kelas-
kelas terkait bersama dalam struktur hierarkis. Paket digunakan untuk
menghindari konflik nama dan menyediakan struktur yang terorganisir untuk
pengembangan perangkat lunak yang kompleks.

Berikut adalah beberapa konsep dasar yang perlu dipahami tentang paket dalam
Java:

1. Organisasi Kelas: Paket digunakan untuk mengorganisasi kelas-kelas

dalam kelompok yang terkait secara logis. Misalnya, jika Anda sedang
mengembangkan aplikasi pengolahan data, Anda dapat memiliki paket
untuk kelas-kelas yang terkait dengan penyimpanan data, paket untuk
kelas-kelas yang terkait dengan logika bisnis, dan paket untuk kelas-kelas
yang terkait dengan antarmuka pengguna.

2. Ruang Nama: Paket memberikan mekanisme ruang nama yang

memungkinkan Anda menggunakan nama kelas yang sama dalam konteks
yang berbeda. Dengan menggunakan nama paket yang berbeda, Anda
dapat menghindari konflik nama yang mungkin terjadi antara kelas-kelas
yang ada.

3. Akses Terbatas: Paket juga digunakan untuk mengendalikan akses

terhadap kelas dan member dalam Java. Dengan menggunakan kata kunci
public, private, dan protected pada deklarasi kelas dan member, Anda
dapat mengatur tingkat akses yang sesuai untuk mengontrol bagaimana
kelas dan member tersebut dapat diakses dari paket lain.

22
 4. Impor: Dalam Java, Anda dapat mengimpor paket-paket dan kelas-kelas
yang ada di dalamnya untuk digunakan dalam kode Anda. Dengan
menggunakan pernyataan import, Anda dapat mempersingkat penulisan
nama kelas dan member dalam kode Anda dan membuatnya lebih mudah
dibaca dan dikelola.

 12.2 Mendeklarasikan Paket

Mendeklarasikan paket dalam Java berarti memberikan sebuah identitas

atau namespace kepada kelas-kelas dan sumber daya terkait lainnya yang
digunakan dalam pengembangan perangkat lunak. Paket digunakan untuk
mengelompokkan dan mengatur kelas-kelas dengan cara yang terstruktur.

Berikut adalah pengertian mendeklarasikan paket dalam Java:

1. Identifikasi Nama Paket: Pilihlah nama yang unik dan deskriptif untuk
paket Anda. Nama paket biasanya terdiri dari beberapa kata yang
dipisahkan oleh tanda titik (.) dan sering kali menggunakan konvensi
penamaan dalam gaya domain yang terbalik.

2. Pernyataan package: Untuk mendeklarasikan paket dalam sebuah file Java,

letakkan pernyataan package di bagian atas file, sebelum semua deklarasi
kelas dan import lainnya. Pernyataan package memberitahu kompiler
bahwa kelas-kelas dalam file ini termasuk dalam paket yang diberikan.

Contoh:
package com.example.data;

Pernyataan di atas mendeklarasikan paket dengan nama com.example.data.

3. Struktur Direktori yang Sesuai: Untuk mencerminkan struktur paket yang

dideklarasikan, pastikan file Java disimpan dalam struktur direktori yang

23
 sesuai. Setiap bagian dari nama paket akan menjadi subdirektori dalam
struktur direktori. Misalnya, paket com.example.data akan memiliki
struktur direktori com/example/data.

4. Impor Paket atau Kelas (Opsional): Jika Anda ingin menggunakan kelas
atau sumber daya dari paket lain, Anda perlu mengimpor paket atau kelas
yang diperlukan dalam kode Java. Dalam kode Java lainnya, gunakan
pernyataan import untuk mengimpor paket atau kelas tersebut agar dapat
digunakan.

 12.3 Menggunakan import

Dalam Java, pernyataan import digunakan untuk mengimpor paket atau

kelas dari paket tertentu agar dapat digunakan dalam kode Java Anda. Import
memungkinkan Anda menggunakan kelas-kelas, antarmuka, enumerasi, atau
member lain yang ada dalam paket lain.

Berikut adalah beberapa contoh penggunaan pernyataan import dalam Java:

1. Mengimpor Seluruh Paket:

Jika Anda ingin mengimpor seluruh paket, Anda dapat menggunakan
pernyataan import diikuti oleh nama paket yang ingin Anda impor. Ini
akan membuat semua kelas, antarmuka, enumerasi, dan member lain
dalam paket tersebut dapat digunakan dalam kode Anda tanpa
menyebutkan nama paket secara eksplisit.

Contoh:
import java.util.*;

Pernyataan di atas mengimpor seluruh paket java.util, yang berisi banyak

kelas dan utilitas umum seperti ArrayList, HashMap, dan sebagainya.

24
 2. Mengimpor Kelas Tertentu:
Jika Anda hanya ingin mengimpor satu kelas dari paket tertentu, Anda
dapat menggunakan pernyataan import diikuti oleh nama kelas yang ingin
Anda impor. Ini memungkinkan Anda menggunakan kelas tersebut tanpa
harus menyebutkan nama paket secara eksplisit.

Contoh:

import java.util.ArrayList;

Pernyataan di atas mengimpor kelas ArrayList dari paket java.util.

3. Mengimpor Kelas dengan Nama yang Sama:

Jika ada konflik nama antara kelas yang diimpor dan kelas dalam paket
saat ini, Anda dapat menggunakan pernyataan import dengan penamaan
lengkap untuk menghindari ambiguitas.

 BAB 13 Interface

 13.1 Pengertian Interface

Interface dalam pemrograman berorientasi objek adalah sebuah kontrak

yang mendefinisikan metode-metode yang harus diimplementasikan oleh kelas-
kelas yang mengimplementasikan interface tersebut. Dalam pengertian yang lebih
sederhana, interface adalah sekumpulan metode yang harus ada dalam kelas-kelas
yang mengimplementasikannya.

Berikut adalah beberapa karakteristik dan pengertian lebih lanjut tentang

interface:

25
 1. Kontrak: Interface berfungsi sebagai kontrak antara objek yang
menggunakan interface dan objek yang mengimplementasikan interface
tersebut. Interface menentukan metode-metode yang harus ada dalam
kelas yang mengimplementasikannya, tetapi tidak mengatur implementasi
detail metode tersebut.

2. Tipe Abstrak: Interface dianggap sebagai tipe data abstrak yang dapat
digunakan untuk menyatakan bahwa suatu objek dapat memenuhi kontrak
yang didefinisikan oleh interface tersebut. Dalam bahasa pemrograman
Java, sebuah objek dapat memiliki banyak tipe, termasuk tipe interface.

3. Tidak Dapat Diinstansiasi: Interface tidak dapat diinstansiasi menjadi

objek langsung. Namun, interface dapat diimplementasikan oleh kelas-
kelas yang menyediakan implementasi konkret untuk metode-metode
yang didefinisikan dalam interface.

4. Mendukung Multiple Inheritance: Dalam Java, sebuah kelas dapat

mengimplementasikan banyak interface. Ini memungkinkan kelas untuk
mewarisi perilaku dari beberapa interface secara bersamaan, yang
mendukung konsep multiple inheritance (pewarisan ganda) melalui
interface.

5. Menggunakan Kata Kunci interface: Untuk mendefinisikan sebuah

interface dalam Java, kita menggunakan kata kunci interface diikuti oleh
nama interface dan blok kode yang berisi deklarasi metode-metode yang
harus ada dalam kelas yang mengimplementasikannya.

Interface memungkinkan penggunaan polimorfisme, abstraksi, dan kontrak yang

jelas dalam pemrograman berorientasi objek. Dengan menggunakan interface, kita
dapat menyusun kode yang lebih modular, memisahkan antara spesifikasi

26
 (interface) dan implementasi (kelas), dan membuat kode lebih fleksibel dan
mudah diubah.

 13.2 Mendeklarasikan Interface

Mendeklarasikan sebuah interface dalam pemrograman berorientasi objek
adalah langkah awal untuk membuat sebuah kontrak yang menentukan metode-
metode yang harus diimplementasikan oleh kelas-kelas yang mengadopsi
(implement) interface tersebut.

Berikut adalah pengertian mendeklarasikan sebuah interface dalam Java:

1. Identifikasi Nama Interface: Pilihlah nama yang deskriptif untuk interface

Anda. Nama interface biasanya menggunakan konvensi penamaan dalam
gaya kapitalisasi camel case, di mana setiap kata dimulai dengan huruf
kapital. Misalnya, Drawable, Resizable, atau Shape.

2. Gunakan Kata Kunci interface: Untuk mendeklarasikan sebuah interface

dalam Java, gunakan kata kunci interface diikuti oleh nama interface yang
Anda inginkan.

3. Deklarasikan Metode-Metode: Setelah menuliskan deklarasi interface,

buatlah blok kode dengan tanda kurung kurawal {}. Di dalam blok kode
tersebut, deklarasikan metode-metode yang harus diimplementasikan oleh
kelas-kelas yang mengimplementasikan interface tersebut. Metode-metode
dalam interface tidak memiliki implementasi konkret, hanya deklarasi
dengan tipe pengembalian, nama, dan parameter.

contoh:

27
 public interface Drawable {
void draw();
void resize(int width, int height);
}

Pada contoh di atas, kita mendeklarasikan sebuah interface dengan nama

Drawable. Interface tersebut memiliki dua metode, yaitu draw() dan resize() yang
harus diimplementasikan oleh kelas-kelas yang mengimplementasikan interface
Drawable.

Setelah interface dideklarasikan, kelas-kelas lain dapat mengimplementasikan

(implement) interface tersebut dengan menggunakan kata kunci implements.
Dengan mengimplementasikan interface, kelas-kelas tersebut harus memberikan
implementasi konkret untuk semua metode yang dideklarasikan dalam interface.

 13.3 Pewarisan Interface

Pewarisan interface dalam pemrograman berorientasi objek adalah

mekanisme di mana sebuah interface dapat mewarisi metode-metode dari
interface lain. Dalam pewarisan interface, sebuah interface anak dapat mewarisi
metode-metode dari satu atau lebih interface induk.

Berikut adalah beberapa hal yang perlu diperhatikan tentang pewarisan interface:

1. Kata Kunci extends: Untuk mewarisi interface lain, gunakan kata kunci
extends diikuti oleh nama interface yang ingin diwarisi. Sebuah interface
anak hanya dapat mewarisi dari satu atau lebih interface induk.

2. Mewarisi Metode-Metode: Saat sebuah interface anak mewarisi dari

interface induk, semua metode yang dideklarasikan dalam interface induk
akan diwarisi oleh interface anak. Interface anak tidak hanya mewarisi

28
 deklarasi metode, tetapi juga harus memberikan implementasi konkret
untuk semua metode yang diwarisi.

3. Multiple Inheritance: Dalam Java, sebuah interface dapat mewarisi dari

lebih dari satu interface induk, sehingga mendukung konsep multiple
inheritance (pewarisan ganda) melalui interface. Hal ini memungkinkan
sebuah interface untuk menggabungkan perilaku dari berbagai interface
yang berbeda.

4. Hierarchy Interface: Dengan menggunakan pewarisan interface, Anda

dapat membuat hirarki interface di mana beberapa interface mungkin menjadi
induk untuk interface lainnya. Ini memungkinkan Anda untuk mengorganisir dan
mengelompokkan kontrak-kontrak yang terkait bersama-sama.

Pewarisan interface memungkinkan Anda untuk membangun hierarki

kontrak-kontrak yang bersifat umum dan khusus dalam pemrograman berorientasi
objek. Dengan menggunakan pewarisan interface, Anda dapat mengatur dan
mengelompokkan kontrak-kontrak yang terkait bersama-sama, memfasilitasi
modularitas, polimorfisme, dan penggunaan yang lebih fleksibel dari kode Anda.

 13.4 Menggunakan Interface

Menggunakan interface dalam pemrograman berorientasi objek adalah
cara untuk memanfaatkan kontrak yang telah didefinisikan dalam sebuah interface
untuk mengatur perilaku objek.

Berikut adalah pengertian menggunakan interface dalam Java:

1. Abstraksi dan Polimorfisme: Interface memungkinkan Anda untuk

menciptakan abstraksi yang memisahkan spesifikasi dari implementasi
konkret. Anda dapat menggunakan interface untuk mendefinisikan
metode-metode yang harus ada dalam kelas-kelas yang
mengimplementasikannya, tetapi tanpa memberikan implementasi
konkret. Dengan demikian, Anda dapat menerapkan polimorfisme di mana

29
 objek dengan tipe interface dapat digunakan secara generik untuk
berinteraksi dengan objek yang mengimplementasikan interface tersebut.

2. Kontrak Konkret: Interface menentukan kontrak yang harus dipenuhi oleh

kelas-kelas yang mengimplementasikannya. Dengan menggunakan
interface, Anda dapat menyediakan spesifikasi yang jelas tentang metode-
metode yang harus ada dalam kelas-kelas tersebut, termasuk tipe
pengembalian, nama, dan parameter metode. Ini membantu dalam menjaga
konsistensi dan memudahkan kolaborasi antara komponen-komponen
dalam sebuah sistem.

3. Modularitas dan Kode yang Dapat Digunakan Kembali: Dengan

menggunakan interface, Anda dapat memisahkan kontrak dari
implementasi konkret, sehingga memungkinkan Anda untuk membangun
kode yang modular. Anda dapat mengimplementasikan kelas-kelas yang
berbeda namun mengimplementasikan interface yang sama, sehingga
memungkinkan Anda untuk menggunakan kembali kode yang ada dalam
berbagai konteks.

4. Fleksibilitas dan Penggantian Objek: Dengan menggunakan interface,

Anda dapat menggunakan objek dengan tipe interface untuk berinteraksi
dengan objek yang mengimplementasikan interface tersebut. Ini
memberikan fleksibilitas yang tinggi karena Anda dapat dengan mudah
menggantikan objek dengan objek lain yang mengimplementasikan
interface yang sama tanpa mengubah kode yang ada.

Dalam keseluruhan, menggunakan interface memungkinkan Anda untuk

membuat kode yang lebih modular, fleksibel, dan dapat digunakan kembali.
Interface membantu dalam memisahkan kontrak dari implementasi konkret,
memfasilitasi polimorfisme, dan meningkatkan abstraksi dalam kode Anda.

30
  BAB 14 Penanganan Eksepsi

 14.1 Penanganan Eksepsi

Penanganan eksepsi dalam konteks pemrograman Java merujuk pada cara-

cara untuk mengatasi atau menangani pengecualian (exceptions) yang terjadi saat
menjalankan program. Ketika suatu eksepsi terjadi, program akan menghentikan
eksekusi normal dan mencari bagian kode yang dapat menangani eksepsi tersebut.

Penanganan eksepsi dilakukan menggunakan blok try-catch-finally, di mana blok

try berisi kode yang berpotensi menyebabkan pengecualian, blok catch
menangkap dan menangani pengecualian yang sesuai, dan blok finally (opsional)
berisi kode yang akan dijalankan baik pengecualian terjadi maupun tidak.

Berikut adalah penjelasan singkat tentang elemen-elemen penanganan eksepsi

dalam Java:
1. Blok Try: Ini adalah blok yang berisi kode yang mungkin menyebabkan
pengecualian. Jika pengecualian terjadi dalam blok try, eksekusi kode
langsung beralih ke blok catch yang sesuai.

2. Blok Catch: Blok catch menangkap pengecualian yang dihasilkan oleh

blok try. Setiap blok catch menangani jenis pengecualian tertentu. Anda
dapat menentukan tipe pengecualian yang ingin ditangkap dan menulis
kode yang akan dieksekusi jika pengecualian tersebut terjadi.

3. Blok Finally: Blok finally adalah opsional dan berada setelah blok try-
catch. Blok finally akan dijalankan terlepas dari apakah pengecualian
terjadi atau tidak. Blok ini sering digunakan untuk membersihkan sumber
daya atau menyelesaikan tugas terakhir sebelum keluar dari metode.

31
 Penanganan eksepsi memungkinkan program untuk menghadapi situasi tidak
terduga dan memberikan kesempatan untuk mengatasi pengecualian secara elegan
atau melakukan tindakan yang sesuai dengan kebutuhan aplikasi.

 14.1 Menangkap Eksepsi

Dalam pemrograman Java, "menangkap eksepsi" merujuk pada proses
menangani atau menangkap pengecualian (exceptions) yang terjadi saat
menjalankan program. Ketika suatu eksepsi terjadi, program dapat menghentikan
eksekusi normal dan mencari bagian kode yang dapat menangani atau mengatasi
eksepsi tersebut.

Untuk menangkap eksepsi, Anda menggunakan blok catch di dalam konstruksi

try-catch. Blok catch menangkap pengecualian yang dihasilkan oleh blok try dan
menyediakan kode yang akan dieksekusi jika pengecualian tersebut terjadi.

Dalam beberapa kasus, Anda juga dapat menggunakan blok catch yang
lebih umum untuk menangkap pengecualian dari jenis yang lebih luas, seperti
Exception, untuk menangani berbagai jenis pengecualian sekaligus. Namun,
sebaiknya diusahakan untuk menangkap pengecualian dengan tipe yang lebih
spesifik agar penanganan eksepsi dapat dilakukan dengan lebih tepat.

Menangkap eksepsi memungkinkan Anda untuk merespons dan mengatasi situasi

yang tidak terduga saat program berjalan. Dengan menggunakan penanganan
eksepsi yang tepat, Anda dapat menghindari berhentinya program secara tiba-tiba
dan memberikan tanggapan yang sesuai kepada pengguna atau melanjutkan
eksekusi program dengan langkah alternatif yang diperlukan.

 14.3 Catch secara Bertingkah

Dalam konteks pemrograman Java, "catch secara bertingkah" merujuk
pada kemampuan untuk menangkap dan menangani berbagai jenis pengecualian

32
 (exceptions) dalam satu blok catch menggunakan mekanisme pola penanganan
eksepsi yang diperkenalkan dalam Java 7

Sebelum Java 7, untuk menangani beberapa jenis pengecualian, diperlukan

beberapa blok catch terpisah, masing-masing menangani satu jenis pengecualian.
Namun, dengan penanganan eksepsi secara bertingkah yang diperkenalkan dalam
Java 7, Anda dapat menangkap beberapa jenis pengecualian yang berbeda dalam
satu blok catch.

Keuntungan menggunakan catch secara bertingkah adalah mengurangi

duplikasi kode dan membuat kode lebih ringkas. Anda dapat menangkap beberapa
jenis pengecualian yang memiliki tindakan penanganan yang sama dalam satu
blok catch, menghindari penulisan blok catch terpisah untuk setiap jenis
pengecualian.

Namun, perlu diperhatikan bahwa jika Anda menggunakan catch secara

bertingkah, Anda tidak akan memiliki informasi tipe pengecualian yang spesifik
yang terjadi. Jadi, jika Anda perlu melakukan penanganan khusus untuk setiap
jenis pengecualian, lebih baik menggunakan beberapa blok catch terpisah.

 14.4 Melontarkan Eksepsi

Dalam pemrograman Java, "melontarkan eksepsi" merujuk pada tindakan
melemparkan atau menghasilkan pengecualian (exceptions) secara eksplisit dalam
kode. Ketika Anda ingin menunjukkan bahwa suatu situasi atau kondisi tertentu
mengarah pada kesalahan atau keadaan yang tidak normal, Anda dapat
melontarkan eksepsi.

Untuk melontarkan eksepsi, Anda menggunakan kata kunci "throw" diikuti oleh
objek pengecualian yang sesuai. Objek pengecualian harus merupakan turunan
dari kelas Exception atau turunannya. Saat melontarkan eksepsi, Anda dapat
menyertakan pesan yang menjelaskan alasan pengecualian dengan menggunakan

33
 kata kunci "new" untuk membuat objek pengecualian dan memberikan pesan
melalui konstruktor.

Melontarkan eksepsi memungkinkan Anda untuk secara eksplisit

menandai situasi yang tidak normal atau kesalahan dalam kode Anda. Hal ini
memungkinkan Anda memberikan informasi yang jelas tentang alasan
pengecualian dan memungkinkan kode lain yang memanggil metode Anda untuk
menangani pengecualian tersebut.

 14.5 Melontarkan kembali Eksepsi

Dalam pemrograman Java, "melontarkan kembali eksepsi" (rethrowing an
exception) merujuk pada tindakan menangkap sebuah pengecualian (exceptions)
dan kemudian melemparkannya kembali ke bagian kode yang memanggil metode
yang menghasilkan pengecualian tersebut. Dengan melontarkan kembali eksepsi,
Anda memberikan kesempatan kepada kode pemanggil untuk menangani atau
memproses pengecualian tersebut.

Untuk melontarkan kembali eksepsi, Anda dapat menggunakan pernyataan

"throw" tanpa diikuti oleh objek pengecualian baru. Dalam blok catch, Anda dapat
menangkap pengecualian, melakukan tindakan tertentu, dan kemudian
melemparkannya kembali menggunakan pernyataan "throw". Dalam hal ini,
pengecualian yang dilemparkan kembali adalah pengecualian yang ditangkap
dalam blok catch.

Melontarkan kembali eksepsi memungkinkan Anda untuk mengubah

lokasi penanganan pengecualian. Dengan melontarkan kembali eksepsi, Anda
dapat memberikan kesempatan kepada kode pemanggil untuk menangani
pengecualian secara lebih sesuai atau melakukan tindakan khusus yang
diperlukan. Hal ini memungkinkan pemisahan tanggung jawab dalam penanganan
eksepsi antara metode yang menghasilkan eksepsi dan metode yang
memanggilnya.

 14.6 Klausa throws

34
 Klausa "throws" dalam Java digunakan untuk menyatakan bahwa suatu
metode atau konstruktor dapat menghasilkan atau melemparkan pengecualian
tertentu kepada pemanggilnya. Dengan menggunakan klausa "throws", Anda
memberikan informasi kepada pengguna metode tentang jenis pengecualian yang
mungkin terjadi saat memanggil metode tersebut.

Ketika Anda menggunakan klausa "throws" pada deklarasi metode atau

konstruktor, Anda harus menyebutkan tipe pengecualian yang dapat dihasilkan
oleh metode tersebut. Jika metode dapat menghasilkan lebih dari satu jenis
pengecualian, tipe pengecualian tersebut dipisahkan oleh koma.

Penggunaan klausa "throws" memungkinkan Anda untuk menyebarkan

tanggung jawab penanganan eksepsi kepada kode yang memanggil metode.
Dengan memberikan informasi tentang pengecualian yang mungkin terjadi, Anda
membantu pengguna kode Anda untuk mengetahui penanganan yang tepat dan
memperlakukan eksepsi yang mungkin terjadi secara lebih baik.

Perlu diingat bahwa klausa "throws" hanya digunakan untuk mendeklarasikan

pengecualian yang dapat dihasilkan oleh metode, tetapi tidak secara langsung
menangani atau menangkap pengecualian. Penanganan pengecualian harus
dilakukan di tempat yang memanggil metode tersebut.

35