Dalam dunia pemrograman biasanya para programer membuat sebuah kode program yang sangat rinci agar setiap baris kode program tersebut berjalan dengan lancar. Kode yang rinci biasanya sangat sedikit (lebih singkat dalam pembuatan kode) dan mudah dipahami setiap barisnya. Terkadang bagi para pemula yang baru menyentuh dunia pemrograman, biasanya dalam pembuatan kode akan sangat banyak dalam membuat sebuah baris kode.
.jpg?1640854856027)
Sebenarnya tidak ada yang salah dengan baris kode yang sangat banyak, akan tetapi hal tersebut dapat membuat seorang programer menjadi lebih sulit ketika akan memperbaiki sebuah error pada kode dan membutuhkan waktu yang sangat lama untuk memperbaikinya. Oleh sebab itu, java membuat sebuah konsep yang dimana kode pemrograman dapat lebih terstruktur dan mudah ketika selama pembuatan kode.
Pada artikel ini akan menjelaskan konsep inheritance yang merupakan salah satu konsep agar kode lebih terstruktur dan mudah selama pembuatan kode. Berikut penjelasan beserta contoh agar lebih mudah dipahami.
Inheritance
Inheritance adalah sebuah konsep pewarisan sifat berupa variabel dan fungsi yang dimiliki oleh class untuk diwariskan kepada kelas-kelas yang lain.
Konsep dari inheritance sendiri yaitu untuk membuat struktur class pada pemrograman yang dimana struktur tersebut terdapat sebuah Parentclass atau Superclass sebagai induk kelas dan Subclass sebagai anak kelas. Konsep tersebut merupakan sebuah percabangan dari sebuah class (Superclass) yang memiliki sifat umum menjadi sebuah class(Subclass) yang memiliki sifat lebih spesifik.
.jpg?1640854907779)
Pada inheritance, Superclass dapat menurunkan sifat yang dimilkinya kepada setiap subclass tetapi tidak semua sifat yang dimiliki oleh superclass dapat diwariskan kepada subclass.
Tipe akses / hak akses yang dapat diwarisi dari superclass kepada sublclass ialah protected dan public sedangkan private tidak akan diturunkan kepada subclass. contoh konsep dari inheritance : Sebuah bangun ruang yaitu segitiga. Segitiga merupakan sebuah parentclass yang memiliki alas dan tinggi juga rumus yaitu1/2 x alas x tinggi. Segitiga siku-siku, segitiga sama sisi, segitiga sama kaki dan segitiga sembarang merupakan sebuah subclass dari segitiga. Maka subclass memiliki nilai alas, tinggi dan rumus dari parentclass.
Dalam pembuatan kode berdasarkan konsep inheritance, biasanya para programmer juga menggunakan metode overriding atau metode overloading untuk subclass agar program dapat berjalan dengan lancar. Untuk pembahasan konsep ineritance disini akan menggunakan metode overriding saja, berikut penjelasan metode overriding pada konsep inheritance
Metode Overriding
.jpg?1640854925912)
Metode overriding adalah sebuah pembuatan ulang metode yang ada pada superclass di subclass atau anak kelas. Metode overriding digunakan agar subclass memiliki fungsi yang lebih spesifik. Seperti contoh pada konsep inheritance diatas, Subclass hanya memiliki nilai alas, tinggi dan rumus. Maka dengan menggunakan metode overriding, subclass dapat membuat rumus tersendiri yang dimana lebih spesifik dari parentclass.
Untuk lebih memahami konsep dari inheritance dan metode overriding, mari kita pahami kasus dibawah berikut beserta pemrogramannya :
Contoh Kasus Inheritance dan Metode Overriding
.jpg?1640854940702)
Sebuah franchise makanan yang terdiri dari beberapa pegawai seperti manajer, pelayan, koki, kasir dan satpam. Setiap pegawai memiliki sebuah nama, id pegawai dan gaji. Untuk pegawai dengan id pegawai 01 memiliki tanggung jawab sebagai manager dengan gaji 7 juta. Pegawai dengan id pegawai 02 memiliki tugas untuk melakukan transaksi dengan pembeli dan gaji sebesar 1 juta .
Pegawai dengan id pegawai 03 memiliki tugas untuk memasak makanan dengan gaji sebesar 2 juta. Pegawai dengan id pegawai 4 memiliki tugas melayani dan menyajikan setiap makanan yang dipesan oleh pembeli dengan gaji 1 juta. Pegawai dengan id pegawai 05 memiliki tugas untuk menjaga keamanan didalam atau diluar frenchise dengan gaji 1 juta.
Dari kasus diatas maka kita dapat mengetahui, bahwa :
1. Pegawai memiliki String nama; int id_pegawai; String gaji; void menampilkan();
2. Manager memiliki void tugas(); void menampilkan();
3. Kasir memiliki void tugas(); void menampilkan();
4. Koki memiliki void tugas(); void menampilkan();
5. Pelayan memiliki void tugas(); void menampilkan();
6. Satpam memiliki void tugas(); void menampilkan();
.jpg?1640685172984)
Baca Juga : Sebuah Tips Lulusan SMK Bisa Tembus Perusahaan IT Multinasional, Berikut 10 Penjelasannya!
Kode pemrograman
Berikut merupakan pemrograman berdasarkan struktur inheritance :
|
pegawai.java package pewarisan_sifat; public class pegawai{ String nama ; int id_pegawai; String gaji; public void menampilkan(){ System.out.println(“Menampilkan nama, id pegawai, gaji dan tugas.”); System.out.println("------------------------------------------------------"); } } |
Setelah membuat class pegawai sebagai superclass, maka selanjutnya membuat subclass seperti manager.java, kasir.java, koki.java, pelayan.java , satpam.java.
file tersebut harus berada dalam package yang sama yaitu “pewarisan_sifat”.
Pada class manager, kasir, koki, pelayan dan satpam jangan lupa tambahkan “extands (nama superclass)” sebagai tanda bahwa manager, kasir, koki, pelayan dan satpam merupakan subclasss dari pegawai.
contoh : public class asisten extends pegawai;
*ket : pegawai merupakan superclass dan asisten merupakan subclass.
Pada subclass, jangan lupa menggunakan metode overriding.
|
manager.java package pewarisan_sifat; public class manager extends pegawai{ //tambahkan @Override diatas fungsi void menampilkan(). //override sendiri berfungsi sebagai pembuatan ulang method dari superclass untuk subclass. @Override public void menampilkan() { //untuk nilai dari void menampilkan bisa berbeda dari nilai yang ada pada superclass. System.out.println(“Nama : ”+nama); System.out.println(“Id Pegawai : ”+id_pegawai); System.out.println(“Gaji : ”+gaji); } //untuk fungsi dari void tugas() merupakan fungsi spesifik yang hanya dimiliki oleh class public void tugas(){ System.out.println(“Tugas : Melakukan manajemen untuk franchise”); System.out.println(“----------------------------------------------”); } } |
|
kasir.java package pewarisan_sifat; public class kasir extends pegawai{ @Override public void menampilkan() { System.out.println(“Nama : ”+nama); System.out.println(“Id Pegawai : ”+id_pegawai); System.out.println(“Gaji : ”+gaji); } public void tugas(){ System.out.println(“Tugas : Melakukan transaksi dengan pembeli”); System.out.println(“----------------------------------------------”); } }
|
|
koki.java package pewarisan_sifat; public class kasir extends pegawai{ @Override public void menampilkan() { System.out.println(“Nama : ”+nama); System.out.println(“Id Pegawai : ”+id_pegawai); System.out.println(“Gaji : ”+gaji); } public void tugas(){ System.out.println(“Tugas : Memasak makanan dan Membuat minuman”); System.out.println(“----------------------------------------------”); } } |
|
pelayan.java package pewarisan_sifat; public class pelayan extends pegawai{ @Override public void menampilkan() { System.out.println(“Nama : ”+nama); System.out.println(“Id Pegawai : ”+id_pegawai); System.out.println(“Gaji : ”+gaji); } public void tugas(){ System.out.println(“Tugas : Melayani dan Menyajikan pesanan pembeli”); System.out.println(“----------------------------------------------”); } } |
|
satpam.java package pewarisan_sifat; public class satpam extends pegawai{ public void menampilkan() { System.out.println(“Nama : ”+nama); System.out.println(“Id Pegawai : ”+id_pegawai); System.out.println(“Gaji : ”+gaji); } public void tugas(){ System.out.println(“Tugas : Menjaga keamanan didalam dan diluar frenchise”); System.out.println(“----------------------------------------------”); } } |
Setelah membuat kode pada subclass, maka selanjutnya adalah membuat sebuah Main_project.java yang berfungsi untuk mengeksekusi kode program diatas.
|
Main_project.java package pewarisan_sifat; public class Main_project{ public static void main(String[] args){ //membuat sebuah object // "pegawai" merupakan class, lalu "Pegawai" merupakan objek yang akan dibuat, lalu "new pegawai();" merupakan constructor. pegawai Pegawai = new pegawai(); manager Manager = new manager(); kasir Kasir = new kasir(); koki Koki = new koki(); pelayan Pelayan = new pelayan(); satpam Satpam = new satpam();
Manager.nama = "sifa"; Manager.id_pegawai = 1; Manager.gaji = "7 Juta"; Kasir.nama = "Aldi"; Kasir.id_pegawai = 2; Kasir.gaji = "1,2 Juta"; Koki.nama = "Reza"; Koki.id_pegawai = 3; Koki.gaji = "2 Juta"; Pelayan.nama = "Dean"; Pelayan.id_pegawai = 4; Pelayan.gaji = "1,2 Juta"; Satpam.nama = "Aldi"; Satpam.id_pegawai = 2; Satpam.gaji = "1 Juta"; //nilai tersebut akan dimasukkan kedalam variabel yang ada pada superclass.
Pegawai.menampilkan();
//memanggil nilai variabel pada superclass dan memasukkannya kedalam fungsi yang ada pada class; Manager.menampilkan(); Manager.tugas(); Kasir.menampilkan(); Kasir.tugas(); Koki.menampilkan(); Koki.tugas(); Pelayan.menampilkan(); Pelayan.tugas(); Satpam.menampilkan(); Satpam.tugas(); } } |
Berikut hasil eksekusi dari Main_project.java :
Sumber referensi :
https://www.petanikode.com/java-oop-inheritance/
https://codekey.id/java/overriding-java/
https://lancangkuning.com/post/17294/pengertian-inheritance-pada-java.html
