Inheritance (Pewarisan)
di Java
Pemrograman Berorientasi Objek 2026
Program Studi S1 Sistem Informasi - FRI
1
Tujuan Pembelajaran
Setelah kuliah ini, Anda akan mampu:
1. Memahami konsep pewarisan dan pentingnya dalam pemrograman berorientasi objek.
2. Mengimplementasikan konsep pewarisan di Bahasa pemrograman java.
3. Menjelaskan perbedaan relasi is-a (inheritance) dan has-a (dekomposisi)
2
Kenapa butuh inheritance
Tanpa inheritance Dengan inheritance
Kode duplikat di setiap class Atribut & method diturunkan dari Mamalia
Sulit dikelola jika class bertambah Tambah class baru cukup extends
Apa itu Pewarisan (inheritance)?
• Definisi: Pewarisan adalah mekanisme dalam pemrograman berorientasi objek di mana satu
kelas (subclass/anak) mewarisi atribut, kontruktor dan perilaku (metode) dari kelas lain
(superclass/induk).
• Tujuan: Meningkatkan penggunaan kembali kode (reusability), mengurangi redundansi, dan
membangun hubungan hierarkis antar kelas.
Manfaat Utama inheritance:
• Penggunaan Kembali Kode: Gunakan kembali kode yang sudah ada tanpa menulis ulang.
• Ekstensibilitas: Mudah menambahkan fitur baru atau memodifikasi yang sudah ada.
• Polimorfisme: Mendukung pemanggilan metode secara dinamis.
4
Istilah Dasar
• Superclass (Kelas Induk):
Kelas yang properti dan superclass
metodenya diwarisi.
• Subclass (Kelas Anak):
Kelas yang mewarisi dari
superclass.
• Hubungan IS-A: Subclass
“adalah” jenis dari
superclass (contoh: subclass
Kambing adalah
Mamalia).
5
Sintaks untuk Pewarisan
// Superclass • Contoh:
class Superclass {
// Field dan metode class Mamalia {
} void makan() {
[Link]("Hewan ini
// Subclass makan.");
}
class Subclass extends Superclass {
}
// Field dan metode tambahan
}
class Kambing extends Mamalia {
• Kata Kunci: extends digunakan untuk menetapkan void ngembek() {
pewarisan. [Link]("mbeeee.");
}
}
6
Penjelasan Kode Contoh
public class Main {
public static void main(String[] args) {
Kambing kambingku = new Kambing();
[Link](); // Diwarisi dari Mamalia
[Link](); // Didefinisikan di Kambing
}
}
Output:
Hewan ini makan.
Mbeeee.
7
Jenis-jenis Pewarisan
Java mendukung jenis-jenis pewarisan berikut:
• Pewarisan Tunggal: Satu subclass mewarisi dari satu
superclass.
• Contoh: Kambing extends Mamalia
• Pewarisan Multilevel: Subclass menjadi superclass untuk
kelas lain.
• Contoh: Mamalia -> Kambing -> KambingGunung
• Pewarisan Hirarkis: Beberapa subclass mewarisi dari satu
superclass.
• Contoh: Mamalia -> Kambing, Mamalia -> Sapi
• Pewarisan Ganda (melalui Interface): Java tidak
mendukung pewarisan ganda dengan kelas tetapi
memungkinkannya menggunakan interface.
8
Pengubah Akses (Access Modifier) dalam Pewarisan
Modifier Kelas Sama Subclass Luar Kelas
private ✓ ✗ ✗
default ✓ ✓ (sama paket) ✗
protected ✓ ✓ ✗
public ✓ ✓ ✓
Catatan Penting:
• Anggota private dari superclass tidak dapat diakses langsung di subclass. Gunakan getter/setter.
• Gunakan protected jika atribut perlu diakses langsung oleh subclass.
9
Menimpa Metode (Method overriding)
• Definisi: Ketika subclass memberikan implementasi spesifik untuk metode yang sudah didefinisikan di
superclass.
• Aturan:
1. Nama metode, tipe kembalian, dan parameter harus cocok persis.
2. Tingkat akses tidak boleh lebih restriktif daripada metode superclass.
Contoh:
class Hewan {
void suara() {
[Link]("Hewan mengeluarkan suara.");
}
}
class Anjing extends Hewan {
@Override
void suara() {
[Link]("Anjing menggonggong.");
}
}
10
Menggunakan Kata Kunci super
• Tujuan: Merujuk ke kelas induk (superclass) langsung dari subclass.
• 3 Kegunaan Utama:
1. super() — Memanggil konstruktor superclass. Harus di baris pertama konstruktor subclass.
2. [Link] — Mengakses atribut milik superclass.
3. [Link]() — Memanggil method superclass yang di-override.
Contoh:
class Hewan {
String nama;
Hewan(String nama) { [Link] = nama; }
void info() { [Link]("Hewan: "+ nama); }
}
class Anjing extends Hewan {
Anjing(String nama) { super(nama); } // 1. super() konstruktor
void info() {
[Link](); // 3. [Link]()
[Link]("Nama: "+ [Link]); // 2. [Link]
}
}
11
Rantai Konstruktor
• Apa itu? Saat objek subclass dibuat, konstruktor superclass selalu dipanggil lebih dulu.
• Analoginya: Seperti membangun rumah — fondasi (superclass) harus selesai dulu, baru dinding
(subclass).
• Yang perlu diingat:
1. super() otomatis dipanggil jika tidak ditulis secara manual.
2. Jika superclass butuh argumen → wajib tulis super(argumen) di baris pertama konstruktor subclass.
Contoh 3 Level:
class Hewan{ Hewan(){[Link]("1. Hewan");} }
class Mamalia extends Hewan{
Mamalia(){[Link]("2. Mamalia");} }
class Kambing extends Mamalia{
Kambing(){[Link]("3. Kambing");} }
Output new Kambing(): → 1. Hewan → 2. Mamalia → 3. Kambing (dari atas ke bawah!)
12
Keuntungan Pewarisan
1. Penggunaan Kembali Kode: Menghindari kode yang berulang dengan menggunakan kelas
yang sudah ada.
2. Pemeliharaan: Perubahan di superclass secara otomatis tercermin di subclass.
3. Ekstensibilitas: Mudah menambahkan fitur baru dengan memperluas kelas yang ada.
4. Polimorfisme: Memungkinkan pemanggilan metode secara dinamis.
22
Kerugian Pewarisan
1. Kopling Kuat: Subclass sangat bergantung pada superclass.
2. Kompleksitas: Hirarki yang dalam dapat membuat kode sulit dipahami.
3. Fragilitas: Perubahan di superclass mungkin secara tidak sengaja memengaruhi subclass.
23
Komposisi - Alternatif lain dari
relasi pewarisan
24
Apa itu Komposisi?
• Definisi: Komposisi adalah hubungan “HAS-A” di mana suatu kelas memiliki referensi ke objek lain sebagai bagian dari
implementasinya.
• Hubungan HAS-A: Kelas A memiliki objek dari kelas B sebagai bagian dari dirinya.
• Contoh:
class Mesin {
private String nama;
void nyalakan() {
[Link]("Mesin menyala.");
}
}
class Mobil {
private Mesin mesin;
Mobil() {
[Link] = new Mesin();
}
void mulai() {
[Link]();
[Link]("Mobil siap digunakan.");
}
}
Array Object dalam Komposisi
• Konsep: Sebuah class dapat memiliki array of objects dari class lain sebagai atribut (komposisi).
• Contoh: Mobil memiliki 4 Ban → relasi "has-a" menggunakan array Ban[].
Array Object dalam Komposisi
// Class Ban (bagian dari Mobil)
class Ban {
String merk;
int ukuran;
Ban(String merk, int ukuran) {
[Link] = merk;
[Link] = ukuran;
}
void tampilInfo() {
[Link](" Ban: " + merk + " (Ring " + ukuran + ")");
}
}
Array Object dalam Komposisi
// Class Mobil memiliki array Ban[] → Komposisi
class Mobil {
private String nama;
private Ban[] banList;
Mobil(String nama, String[] merkBan, int[] ukuranBan) {
[Link] = nama;
banList = new Ban[[Link]];
for (int i = 0; i < [Link]; i++) {
banList[i] = new Ban(merkBan[i], ukuranBan[i]);
}
}
void tampilInfo() {
[Link]("Mobil: " + nama);
[Link]("Jumlah ban: " + [Link]);
}
}
Array Object dalam Komposisi
// Class Main untuk membuat objek Mobil
public class Main {
public static void main(String[] args) {
//array untuk menyimpan nama merek setiap ban(4 ban)
String[] merkBan = {"Bridgestone", "Bridgestone", "Dunlop", "Dunlop"};
//array untuk menyimpan ukuran setiap ban (4 ban)
int[] ukuranBan = {16, 16, 16, 16};
//Membuat Objek Mobil dengan nama avanza
Mobil avanza = new Mobil("Toyota Avanza", merkBan, ukuranBan);
[Link]();
}
}
Struktur Data Array di C# - Hasibuan2025
Kelebihan Komposisi
1. Kopling Longgar: Perubahan pada kelas yang digunakan (komponen) tidak selalu
memengaruhi kelas yang menggunakannya.
2. Fleksibilitas Tinggi: Objek dapat diubah atau diganti secara dinamis pada runtime.
3. Desain Modular: Kode lebih mudah diuji, didebug, dan dimodifikasi karena setiap kelas
fokus pada tanggung jawab tunggal.
Kekurangan Komposisi
1. Lebih Banyak Kelas: Komposisi sering kali menghasilkan lebih banyak kelas kecil
dibandingkan hierarki pewarisan.
2. Kode Lebih Verbose: Dibutuhkan lebih banyak kode untuk membuat dan mengelola objek
yang digunakan dalam komposisi.
Kapan Menggunakan Pewarisan?
Gunakan pewarisan ketika:
1. Ada hubungan “IS-A” yang jelas antara dua kelas.
• Contoh: Anjing adalah Hewan.
2. Anda ingin memanfaatkan polimorfisme untuk memanggil metode subclass melalui
referensi superclass.
3. Hierarki kelas stabil dan tidak sering berubah.
Kapan Menggunakan Komposisi?
Gunakan komposisi ketika:
1. Ada hubungan “HAS-A” antara dua kelas.
• Contoh: Mobil memiliki Mesin.
2. Anda ingin desain yang fleksibel dan mudah dimodifikasi.
3. Anda ingin menghindari kopling kuat dan hierarki kaku.
Pewarisan vs Komposisi: Perbandingan
Aspek Pewarisan Komposisi
Hubungan IS-A HAS-A
Kopling Kuat Longgar
Fleksibilitas Rigid Fleksibel
Perubahan Sulit dimodifikasi Mudah dimodifikasi
Penggunaan Ulang Terbatas pada hierarki Bebas diimplementasikan
Best Practices untuk pewarisan (inheritance)
1. Gunakan pewarisan hanya ketika ada hubungan “IS-A” yang jelas.
2. Lebih utamakan komposisi daripada pewarisan jika memungkinkan.
3. Jaga agar hirarki tetap dangkal untuk meningkatkan keterbacaan.
4. Gunakan kelas abstrak atau interface untuk mendefinisikan perilaku umum.
35
Kesimpulan
1. Pewarisan memungkinkan satu kelas mewarisi properti dan metode dari kelas lain.
2. Gunakan kata kunci extends untuk membuat hubungan subclass-superclass.
3. Timpa metode untuk memberikan implementasi spesifik.
4. Gunakan kata kunci super untuk mengakses anggota superclass atau konstruktor.
5. Hindari hirarki yang dalam untuk menjaga kejelasan kode.
6. Pewarisan cocok untuk hubungan “IS-A” tetapi dapat menciptakan kopling kuat.
7. Komposisi lebih fleksibel dan mendukung desain modular dengan kopling longgar.
8. Prinsip “Favor Composition over Inheritance” adalah panduan penting dalam perancangan
perangkat lunak.
9. Campuran kedua pendekatan sering kali merupakan solusi yang masuk akal.
Latihan
1. Buat hierarki kelas untuk kendaraan (Kendaraan, Mobil, Truk, dll.).
2. Implementasikan penimpaan metode untuk metode seperti startEngine().
3. Gunakan kata kunci super untuk memanggil konstruktor superclass.
37