LAPORAN PRAKTIKUM

PEMROGRAMAN BERORIENTASI OBJEK

Disusun Untuk Memenuhi Tugas Laporan Praktikum Mata Kuliah
Pemrograman berbasis Objek

Dosen Pengampu :
Dewi Primasari S.Si., M.M

Disusun Oleh :
Nama : M Wildan Nurohman
NPM : 221106043031
Kelas : Reguler B

LABORATORIUM BESAR
PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS TEKNIK
UNIVERSITAS IBN KHALDUN BOGOR
2024
 KATA PENGANTAR

Puji syukur kita panjatkan kehadirat Allah Swt. yang telah memberikan rahmat dan
hidayah-Nya sehingga saya dapat menyelesaikan tugas yang berjudul “Laporan Praktikum
Pemrograman Berorientasi Objek” ini tepat pada waktunya.

Adapun tujuan dari penulisan dari laporan ini adalah untuk memenuhi tugas pada mata
kuliah Pemrograman Berorientasi Objek. Selain itu, laporan ini juga bertujuan untuk
menambah wawasan tentang pemrograman menggunakan bahsa pemograman Java.

Dalam penyusunan laporan ini, saya mengucapkan terimaksih sebesar- besarnya kepada
semua pihak yang telah membantu terselesaikannya laporan ini. Adapun pihak-pihak tersebut
antara lain:

1. Dewi Primasari, S.Si., M.M. selaku dosen pengampu mata kuliah Pemrograman
Berorientasi Objek.
2. Seluruh asisten praktikum Teknik Informatika Fakultas Teknik Universitas Ibn Khaldun
Bogor.
3. Orang tua, sahabat, kerabat, dan pihak-pihak lainnya yang tidak bisa penyusun sebutkan
satu persatu.

Penulis menyadari bahwa laporan praktikum ini masih banyak kekurangan dan kesalahan
serta masih jauh dari sempurna, oleh karena itu kritik dan saran yang membangun sangat di
harapkan. Akhir kata kami berharap semoga laporan Praktikum ini bermanfaat
bagi kita semua.

Penyusun

M Wildan
Nurohman
221106043031
 DAFTAR ISI

KATA PENGANTAR ................................................................................................................... 2

DAFTAR ISI ............................................................................................................................... 3
PRAKTIKUM 1 .......................................................................................................................... 5
INSTALASI ECLIPSE ............................................................................................................... 5
PENDAHULUAN ............................................................................................................... 5
TAHAPAN DAN PROSEDUR .............................................................................................. 6
HASIL PRAKTIKUM ........................................................................................................... 7
ANALISA ........................................................................................................................... 8
KESIMPULAN ................................................................................................................... 8
PRAKTIKUM 2 .......................................................................................................................... 9
FUNCTION METHOD ............................................................................................................ 9
PENDAHULUAN ............................................................................................................... 9
TAHAPAN DAN PROSEDUR ............................................................................................ 10
HASIL PRAKTIKUM ......................................................................................................... 10
ANALISA ......................................................................................................................... 11
KESIMPULAN ................................................................................................................. 11
PRAKTIKUM 3 ........................................................................................................................ 12
LOOPING ............................................................................................................................ 12
PENDAHULUAN ............................................................................................................. 12
TAHAPAN DAN PROSEDUR ............................................................................................ 13
HASIL PRAKTIKUM ......................................................................................................... 14
ANALISA ......................................................................................................................... 16
KESIMPULAN ................................................................................................................. 16
PRAKTIKUM 4 ........................................................................................................................ 17
FOR .................................................................................................................................... 17
PENDAHULUAN ............................................................................................................. 17
TAHAPAN DAN PROSEDUR ............................................................................................ 18
HASIL PRAKTIKUM ......................................................................................................... 19
ANALISA ......................................................................................................................... 20
KESIMPULAN ................................................................................................................. 20
PRAKTIKUM 5 ........................................................................................................................ 21
FIBONACCI ......................................................................................................................... 21
PENDAHULUAN ............................................................................................................. 21
 TAHAPAN DAN PROSEDUR ............................................................................................ 22
HASIL PRAKTIKUM ......................................................................................................... 23
ANALISA ......................................................................................................................... 24
KESIMPULAN ................................................................................................................. 24
PRAKTIKUM 6 ........................................................................................................................ 25
INHERITANCE & OVERLOADING ........................................................................................ 25
PENDAHULUAN ............................................................................................................. 25
TAHAPAN DAN PROSEDUR ............................................................................................ 26
HASIL PRAKTIKUM ......................................................................................................... 27
KESIMPULAN ................................................................................................................. 29
PRAKTIKUM 7 ........................................................................................................................ 30
POLYMORPHISM ............................................................................................................... 30
PENDAHULUAN ............................................................................................................. 30
TAHAPAN DAN PROSEDUR ............................................................................................ 31
HASIL PRAKTIKUM ......................................................................................................... 32
ANALISA ......................................................................................................................... 33
KESIMPULAN ................................................................................................................. 34
PRAKTIKUM 8 ........................................................................................................................ 35
INTERFACE ......................................................................................................................... 35
PENDAHULUAN ............................................................................................................. 35
TAHAPAN DAN PROSEDUR ............................................................................................ 36
HASIL PRAKTIKUM ......................................................................................................... 37
ANALISA ......................................................................................................................... 39
KESIMPULAN ................................................................................................................. 39
UJIAN PRAKTIKUM................................................................................................................. 40
 PRAKTIKUM 1
INSTALASI ECLIPSE

PENDAHULUAN

Tujuan Praktikum
1. Mahasiswa bisa mendownload aplikasi Eclipse.
2. Mahasiswa diharapkan mampu menginstal aplikasi Eclipse.
3. Mahasiswa diharapkan mampu menggunakan aplikasi Ecplise
4. Mahasiswa diharapkan mampu memahami tentang pemograman Java.

Waktu dan Tempat

1. Tanggal : 13 September 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar

Bahan dan Alat

1. Laptop HP 14s – DQ0XXX
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

Instalasi
1. Siapkan perangkat komputer yang akan digunakan dalam praktikum ini.
2. Download Aplikasi Eclipse IDE 2023-09 melalui link di bawah ini.
Eclipse: https://www.eclipse.org/downloads/

3. Lakukan instalasi setelah selesai mengunduh. Selama proses instalasi

mungkin Anda akan melihat tampilan Eclipse Installer. Silakan pilih menu
Eclipse IDE for Java Developers untuk melanjutkan instalasi.

4. Pada tampilan selanjutnya pilih Install lalu tunggu sampai proses instalasi
selesai.
 HASIL PRAKTIKUM

1. Membuat Program Java Sederhana

Output:
 ANALISA

Dari praktikum diatas didapat analisa instalasi Eclipse IDE ini

sangat mudah, namun harus berhati-hati dengan file .exe pastikan file .exe
tidak corrupt akibat gagal download, karena apabila corrupt maka instalasi
bisa saja berjalan namun pada tengah instalasi dapat error bisa juga ketika
awal instalasi sudah terjadi fatal error. Dan baca dengan teliti jika akan
melanjutkan ke tahap selanjutnya agar tidak salah, dan Memiliki
pemahaman tentang cara menangani error selama instalasi penting. Jika
terjadi kesalahan, pengguna harus dapat merujuk pada pesan kesalahan dan
mencari solusi atau dukungan dari sumber daya online atau komunitas.

Untuk membuat proyek menggunakan Eclipse IDE, pertama-tama, buka

Eclipse dan pilih workspace tempat proyek akan disimpan. Setelah itu,
pastikan berada dalam perspektif Java untuk pengembangan aplikasi Java.
Selanjutnya, buat proyek baru dengan mengklik kanan pada area kosong di
Package Explorer, pilih "New" > "Java Project," dan beri nama proyek.
Setelah proyek terbentuk, tambahkan package dan kelas dengan mengikuti
langkahlangkah yang sama. Tulis kode Java di dalam editor yang muncul,
simpan, dan jalankan program. Terakhir, eksplorasi fitur-fitur Eclipse
seperti autocomplete dan debugging untuk meningkatkan produktivitas
pengembangans.

KESIMPULAN

Eclipse adalah Integrated Development Environment (IDE) yang

kuat dan populer yang digunakan untuk pengembangan perangkat lunak,
terutama dalam konteks pengembangan aplikasi Java. Dengan Eclipse,
pengembang dapat membuat, mengelola, dan mengompilasi proyek-proyek
secara efisien. Eclipse menyediakan antarmuka yang kaya fitur, termasuk
penyunting kode, debugger, manajemen proyek, dan dukungan untuk
berbagai bahasa pemrograman. Kelebihan Eclipse meliputi fleksibilitas,
dukungan plugin yang luas, dan kemampuan untuk mengintegrasikan
proyek dengan sistem manajemen versi seperti Git. Kesimpulannya, Eclipse
menjadi pilihan yang andal untuk pengembangan perangkat lunak,
memungkinkan pengembang untuk bekerja dengan nyaman dan efektif
dalam proses pembuatan aplikasi.
 PRAKTIKUM 2
FUNCTION METHOD

PENDAHULUAN

Tujuan Praktikum
1. Mahasiswa diharapkan mampu memahami tentang Function (method).
2. Mahasiswa diharapkan mampu membuat Function (method).
3. Mahasiswa diharapkan mampu memahami Function (Method).
Waktu dan Tempat
1. Tanggal : 20 September 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar
Bahan dan Alat
1. Laptop HP 14s – DQ0XXX
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka software Eclipse IDE
3. Buat proyek baru atau gunakan proyek yang sudah ada.
4. Klik kanan pada proyek di Package Explorer, pilih "New" > "Class".
5. Beri nama kelasnya sebagai rumuspersegi.
6. Tulis kode program untuk kelas rumuspersegi dengan metode hitungLuas
dan hitungKeliling.
7. Simpan file tersebut dalam direktori proyek.
8. Klik kanan pada proyek di Package Explorer, pilih "New" > "Class".
9. Beri nama kelasnya sebagai HasilFunctionPersegi.
10. Tulis kode program untuk kelas HasilFunctionPersegi dengan metode main.
11. Simpan file tersebut dalam direktori proyek.

HASIL PRAKTIKUM

1. Membuat rumuspersegi.java
 ANALISA

Dalam praktikum diatas dapat di analisa bahwa penulis memulai

membuat project java, membuat class rumuspersegi yang memiliki
konstruktor untuk menerima panjang sisi sebagai parameter, serta dua
method untuk menghitung luas dan keliling persegi. Penggunaan konsep
class, konstruktor, dan method menunjukkan pemahaman konsep
pemrograman berorientasi objek (OOP). Penulis membuat class
HasilFunctionPersegi yang berfungsi sebagai program utama. Program ini
menggunakan Scanner untuk menerima input dari pengguna, membuat
objek dari class rumuspersegi, dan menghitung luas serta keliling persegi.
Hasil perhitungan kemudian ditampilkan pada layar bersama dengan
informasi identitas penulis dan kelas. Penerimaan input dari pengguna
menggunakan Scanner dan tampilan hasil perhitungan dioutputkan ke layar.
Ini mencerminkan pemahaman tentang input/output dalam konteks
pengembangan aplikasi. Penulis menyertakan identitas diri seperti nama,
kelas, dan semester. Ini menunjukkan keterbukaan dan keterlibatan penulis
dalam dokumentasi. Terdapat komentar di dalam kode program yang
memberikan penjelasan tentang fungsi dan tujuan setiap bagian kode. Ini
membantu pembaca, termasuk pembaca yang mungkin belum terlalu
familiar dengan kode tersebut. Penulis menggunakan package untuk
mengorganisir kelas-kelas yang dibuat. Ini memperlihatkan praktik baik
dalam struktur proyek Java. Meskipun tidak terdapat penanganan exception
yang menyeluruh, penulis memastikan menutup objek Scanner
menggunakan scanner.close(). Hal ini mencegah terjadinya resource leak.

KESIMPULAN

Dalam praktikum diatas dapat disimpulkan bahwa penulis telah

berhasil membuat dan mengimplementasikan program Java untuk
menghitung luas dan keliling persegi. Dengan pembuatan class
`rumuspersegi` dan `HasilFunctionPersegi`, penulis berhasil menerapkan
konsep OOP seperti enkapsulasi, konstruktor, dan pemanggilan method.
Penulis berhasil mengimplementasikan mekanisme input/output dengan
menggunakan kelas Scanner untuk menerima input dari pengguna dan
menampilkan hasil perhitungan. Penulis memilih untuk mengorganisir
 kelas-kelas dalam package, yang menunjukkan pemahaman terhadap
konsep struktur proyek dalam Java. Penulis menyertakan informasi
identitas diri seperti nama, kelas, dan semester, menunjukkan transparansi
dalam dokumentasi. Meskipun tidak terdapat penanganan exception yang
menyeluruh, penulis memastikan menutup objek Scanner untuk mencegah
terjadinya resource leak.

PRAKTIKUM 3
LOOPING

PENDAHULUAN

Tujuan Praktikum
1. Mahasiswa diharapkan mampu memahami tentang Looping.
2. Mahasiswa diharapkan mampu membuat Looping.
Waktu dan Tempat
1. Tanggal : 04 Oktober 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar
Bahan dan Alat
1. Laptop HP 14s – DQ0XXX
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka software Eclipse IDE
3. Pilih atau buat proyek baru sesuai kebutuhan.
4. Buat file baru dalam proyek Anda dengan nama looping.java.
5. buat kode program looping di dalam file tersebut.
6. Jalankan program dengan mengeklik tombol "Run" atau menggunakan
kombinasi tombol tertentu seperti Ctrl + F11.
7. Program akan menampilkan output teks dan meminta input dari pengguna,
sesuai dengan logika program yang telah diimplementasikan.
8. Pastikan untuk mengikuti petunjuk input yang diminta.
9. Program pertama menampilkan kelipatan dari angka yang dimasukkan
hingga mencapai 20.
10. Program kedua memberikan saran berdasarkan nilai IPK yang dimasukkan.
11. Sesuaikan atau modifikasi program sesuai kebutuhan atau tujuan praktikum.
12. Lakukan eksperimen dengan mengganti nilai input untuk melihat perubahan
dalam output.
13. Simpan proyek dan kode program Anda.
14. Tambahkan komentar di dalam kode program untuk membantu pembaca
atau pengguna lain untuk memahami logika dan tujuan dari setiap bagian
program.

HASIL PRAKTIKUM

1. Looping
 Output:

2. IF

Output:
 ANALISA

Dalam praktikum diatas dapat di analisa bahwa penulis membuat

Program Looping Program dimulai dengan menampilkan informasi pribadi
dan keterangan semester. Selanjutnya, program meminta pengguna
memasukkan angka. Menggunakan BufferedReader untuk membaca input
dari pengguna. Menggunakan while loop untuk mencetak kelipatan dari
angka yang dimasukkan hingga mencapai 20.

Membuat Program IPK, program dimulai dengan menampilkan

informasi pribadi dan keterangan semester. Selanjutnya, program meminta
pengguna memasukkan nilai IPK. Menggunakan BufferedReader untuk
membaca input dari pengguna. Menggunakan ifelse if-else untuk
menentukan saran berdasarkan rentang nilai IPK. Menerapkan kesalahan
dengan menggunakan blok try-catch untuk menangani kesalahan input,
terutama kesalahan konversi nilai IPK.

KESIMPULAN

Dari praktikum di atas dapat disimpulkan bahwa Kedua program

menggunakan BufferedReader untuk membaca input dari pengguna.
Penanganan kesalahan (error handling) diimplementasikan dengan baik
untuk memastikan program dapat mengatasi kesalahan input yang mungkin
terjadi. Output program disajikan secara jelas. Dengan implementasi
struktur dasar, looping, percabangan, dan penanganan kesalahan, kedua
program ini berhasil memenuhi tujuan praktikum dan memberikan
pengalaman interaktif kepada pengguna.
 PRAKTIKUM 4
FOR

PENDAHULUAN

Tujuan Praktikum
1. Penulis diharapkan mampu memahami tentang Looping.
2. Penulis diharapkan mampu membuat Looping.

Waktu dan Tempat

4. Tanggal : 11 Oktober 2023
5. Waktu : 10.00 – 11.45
6. Tempat : Laboratorium Besar
Bahan dan Alat
3. Laptop HP 14s – DQ0XXX
4. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka software Eclipse IDE di perangkat komputer.
3. Buat package baru dengan nama `tugas_4_satria_sudirja_for`.
4. Buat class baru di dalam package tersebut dengan nama `for_abcd`.
5. Program ini meminta pengguna memasukkan jumlah perulangan dan
mencetak pola segitiga menggunakan karakter 'A', 'B', 'C', dst.
6. Jalankan program dengan mengeklik tombol "Run" atau menggunakan
kombinasi tombol tertentu seperti `Ctrl + F11`.
7. Program akan menampilkan pesan untuk memasukkan jumlah perulangan.
8. Setelah pengguna memasukkan nilai, program akan mencetak pola segitiga
sesuai dengan jumlah perulangan yang dimasukkan.
9. Perhatikan hasil keluaran program dan sesuaikan dengan logika program
yang telah diimplementasikan.
10. Sesuaikan atau modifikasi program sesuai kebutuhan atau tujuan praktikum.
11. Lakukan eksperimen dengan mengganti jumlah perulangan untuk melihat
perubahan
12. Simpan proyek dan kode program Anda.
13. Tambahkan komentar di dalam kode program untuk menjelaskan langkah-
langkah atau bagian-bagian penting.
14. Komentar membantu pembaca atau pengguna lain untuk memahami logika
dan tujuan dari setiap bagian program.
 HASIL PRAKTIKUM

1.For

Output:
 ANALISA

Dalam praktikum diatas dapat di analisa bahwa penulis telah berhasil

membuat program Java yang menggunakan Eclipse IDE untuk mencetak pola
segitiga dengan karakter 'A', 'B', 'C', dan seterusnya. Berikut adalah beberapa
poin analisis terkait praktikum tersebut:

- Program menggunakan loop for untuk mengontrol jumlah baris pada pola
segitiga.
- Loop bersarang digunakan untuk mencetak karakter pada setiap baris.
- Program meminta pengguna memasukkan jumlah perulangan (jumlah baris
segitiga) menggunakan BufferedReader.
- Penanganan kesalahan input diimplementasikan dengan menggunakan try-
catch, yang akan menangkap kesalahan jika pengguna memasukkan input
yang tidak valid.
- Program terstruktur dengan baik, menggunakan kelas dan metode utama
(main).
- Deklarasi variabel dan tipe data sesuai dengan kebutuhan program.
- Program memberikan interaksi yang baik dengan pengguna dengan
menampilkan pesan dan meminta input.
- Pesan output dan hasil cetakan pola segitiga disusun dengan rapi.
- Penggunaan variabel karakter yang dihitung berdasarkan nilai dari karakter
'A' menunjukkan kreativitas dalam mencetak pola.
-
KESIMPULAN

Dari praktikum diatas dapat disimpulkan bahwa dengan

menciptakan program pola segitiga menggunakan loop for dan Eclipse IDE,
penulis berhasil menciptakan program yang interaktif dan kreatif.
Penanganan kesalahan, struktur dasar program, dan penggunaan loop
menunjukkan pemahaman yang baik terhadap dasar-dasar pemrograman
Java. Peningkatan potensial dan kreativitas dalam logika program dapat
 terus dikembangkan untuk menghasilkan solusi yang lebih kompleks dan
kaya fitur.

PRAKTIKUM 5
FIBONACCI

PENDAHULUAN

Tujuan Praktikum
1. Penulis diharapkan mampu memahami tentang Fibonacci dan Rekursi.
2. Penulis diharapkan mampu membuat program java menggunakan Fibonacci
dan Rekursi.
Waktu dan Tempat
1. Tanggal : 18 Oktober 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar

Bahan dan Alat

1. Laptop Lenovo
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka software Eclipse IDE di perangkat komputer.
3. buat proyek baru sesuai kebutuhan.
4. Buat package baru dengan nama fibonacci.
5. Buat class baru di dalam package tersebut dengan nama
FibonacciPraktikumSatria.
6. Jalankan program dengan mengeklik tombol "Run" atau menggunakan
kombinasi tombol tertentu seperti Ctrl + F11.
7. Input Program akan meminta pengguna memasukkan nilai n.
8. Program kemudian mencetak nilai deret Fibonacci ke-n dan menyusun
deretnya.
9. Perhatikan hasil keluaran program dan sesuaikan dengan logika program
yang telah diimplementasikan.
10. Program ini menggambarkan nilai deret Fibonacci dan menyusun deretnya
hingga ken.
11. Simpan dan Evaluasi:
12. Simpan proyek dan kode program Anda.
13. Tambahkan komentar di dalam kode program untuk menjelaskan langkah-
langkah atau bagian-bagian penting.
14. Komentar membantu pembaca atau pengguna lain untuk memahami logika
dan tujuan dari setiap bagian program.
 HASIL PRAKTIKUM

1. Membuat Program Fibonacci

Output:
 ANALISA

Dalam praktikum diatas dapat di analisa bahwa penulis berhasil

membuat program dalam bahasa Java untuk menghasilkan dan
menampilkan deret Fibonacci. Berikut adalah beberapa poin analisis terkait
praktikum tersebut:

- Program menggunakan rekursi untuk menghitung nilai deret

Fibonacci. Fungsi `f` dipanggil secara rekursif untuk menghitung
nilai deret Fibonacci ke-n.
- Rekursi dapat memberikan solusi yang sederhana untuk masalah
deret Fibonacci, tetapi perlu diperhatikan bahwa untuk nilai `n` yang
besar, metode rekursif dapat menjadi tidak efisien karena
memerlukan perhitungan berulang-ulang.
- Program memanfaatkan `BufferedReader` untuk mengambil input
pengguna berupa nilai `n`.
- Dilakukan penanganan kesalahan jika nilai `n` yang dimasukkan
negatif, dan pesan kesalahan akan ditampilkan.
- Program memberikan output berupa nilai deret Fibonacci ke-n serta
susunan deretnya.
- Hasil ditampilkan dengan jelas dan informatif.
- Digunakan perulangan `for` untuk menampilkan susunan deret
Fibonacci hingga ke-n.
- Hasil setiap elemen deret dicetak pada baris yang sama.
- Program melakukan penutupan `BufferedReader` setelah selesai
digunakan untuk membaca input pengguna.

KESIMPULAN

Dalam praktikum diatas dapat disimpulkan bahwa Praktikum ini

berhasil mengimplementasikan konsep rekursi dalam pemrograman Java
untuk menghasilkan deret Fibonacci. Pesan kesalahan dan output yang
informatif membantu pengguna memahami hasil dari program. Melalui
praktikum ini, penulis telah menunjukkan pemahaman yang baik terhadap
konsep rekursi dan implementasinya dalam pemrograman Java.
 PRAKTIKUM 6
INHERITANCE & OVERLOADING

PENDAHULUAN

Tujuan Praktikum
1. Mahasiswa diharapkan mampu memahami pewarisan dalam OOP.

2. Mahasiswa diharapkan mampu memahami konsep Overloading.

3. Mahasiswa diharapkan mampu mengetahui dan memahami Package, Class,

Variabel dan method, Subclass, Variabel dan method subclass.
4. Mahasiswa diharapkan dapat mengaplikasikan pada sebuah program Java
Waktu dan Tempat
1. Tanggal : 06 Desember 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar
Bahan dan Alat
1. Laptop Lenovo
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka Eclipse IDE.
3. Pilih "File" > "New" > "Java Project". Isi nama proyek "Tugas7 dan klik
"Finish".
4. Klik kanan pada proyek yang baru dibuat. Pilih "New" > "Package" beri
nama paket "Hitung" dan klik "Finish".
5. Klik kanan pada paket "Hitung" pilih "New" > "Class" beri nama kelas
"SegiEmpat". Pilih opsi "public static void main(String[] args)" jika ingin
menambahkan metode utama, dan Klik "Finish".
6. Tambahkan Variabel dan Metode pada Class SegiEmpat meliputi package
Hitung; public class SegiEmpat { protected int panjang; protected int lebar;
protected int luas() protected int keliling()
7. Klik kanan pada paket "Hitung". Pilih "New" > "Class". Beri nama kelas
"BujurSangkar" dan pilih "SegiEmpat" sebagai superclass, dan Klik
"Finish".
8. Tambahkan Variabel dan Metode pada Subclass BujurSangkar meliputi
package Hitung;, public class BujurSangkar extends SegiEmpat.
9. Klik kanan pada paket "Hitung". Pilih "New" > "Class". Beri nama kelas
"PersegiPanjang" dan pilih "SegiEmpat" sebagai superclass. Klik "Finish".
10. Tambahkan Variabel dan Metode pada Subclass PersegiPanjang meliputi
package Hitung;, public class PersegiPanjang extends SegiEmpat
11. Klik kanan pada paket "Hitung". Pilih "New" > "Class". Beri nama kelas
"MainProgram" dan pilih "SegiEmpat" sebagai main utama dari program.
Klik "Finish".
12. Penulis telah membuat proyek Java dengan struktur kelas dan package yang
telah ditentukan menggunakan Eclipse IDE. Selanjutnya,
mengimplementasikan metode dan variabel khusus untuk subclass
BujurSangkar dan PersegiPanjang sesuai kebutuhan.
 HASIL PRAKTIKUM

Hitung SegiEmpat
Program:
Output:
 ANALISA

Dalam pembuatan program menghitung luas dan keliling persegi dan bujursangkar
menggunakan Java Eclipse dengan metode inheritance dan overloading, terdapat
keuntungan dalam pengelolaan kode dan struktur program. Penerapan inheritance
memungkinkan untuk membuat hierarki kelas, di mana kelas turunan dapat mewarisi sifat
dan perilaku dari kelas induk. Dengan demikian, kode dapat direuse dengan lebih efisien
dan mudah dipelihara. Penggunaan overloading memungkinkan untuk mendefinisikan
beberapa versi dari method dengan nama yang sama, namun dengan parameter yang
berbeda. Hal ini berguna untuk menyederhanakan pemanggilan method dan membuat
program lebih fleksibel. Dengan kombinasi kedua konsep ini, program dapat lebih modular,
mudah dipahami, dan dapat diadaptasi dengan baik untuk menghitung luas dan keliling
persegi serta bujursangkar tanpa memerlukan redundansi kode yang tidak perlu

KESIMPULAN

Secara keseluruhan, penggunaan metode inheritance dan overloading dalam

pembuatan program menghitung luas dan keliling persegi serta bujursangkar menggunakan
Java Eclipse memberikan keuntungan dalam hal efisiensi, pemeliharaan kode, dan
fleksibilitas. Inheritance memungkinkan penggunaan kembali kode dan struktur program
yang efisien, sementara overloading memberikan fleksibilitas dalam mendefinisikan beberapa
versi dari method dengan nama yang sama. Dengan demikian, program dapat dirancang
dengan struktur yang modular, mudah dipahami, dan dapat diadaptasi dengan baik tanpa
mengorbankan performa. Kombinasi kedua konsep ini membantu menciptakan solusi yang
elegan dan efektif dalam mengelola perhitungan luas dan keliling persegi serta bujursangkar.
 PRAKTIKUM 7
POLYMORPHISM

PENDAHULUAN

Tujuan Praktikum
1. Mahasiswa diharapkan mampu memahami tentang Polymorphism pada
program java.
2. Mahasiswa diharapkan mampu Membuat Program java menggunakan
Polymorphism.
Waktu dan Tempat
1. Tanggal : 01 November 2023
2. Waktu : 10.00 – 11.45
3. Tempat : Laboratorium Besar
Bahan dan Alat
1. Laptop HP 14s – DQ0XXX
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka Eclipse IDE.
3. Buat proyek baru dan beri nama VolumeKubusBalok.
4. Buat package baru dengan nama volumekubus_balok.
5. Dalam package volumekubus_balok, buat file volume.java. Definisikan
interface volume dengan satu metode abstract hitungVolume().
6. Dalam package volumekubus_balok, buat file Balok.java. Definisikan
class `Balok` yang mengimplementasikan interface volume.
7. Dalam package volumekubus_balok, buat file Kubus.java. Definisikan
class Kubus yang mengimplementasikan interface volume.
8. Buat Class HasilVolume Sebagai Program Utama. Tulis program utama
untuk menghitung volume balok dan kubus menggunakan konsep
polymorphism.
9. Jalankan program HasilVolume untuk menguji perhitungan volume balok
dan kubus menggunakan konsep polymorphism.
 HASIL PRAKTIKUM

1. Menghitung volume Balok Kubus

Output:
 ANALISA

Penggunaan polimorfisme dalam menghitung volume balok dan kubus

pada suatu program Java dapat memberikan fleksibilitas dan keterbacaan yang
tinggi. Dengan menggunakan konsep polimorfisme, kita dapat membuat
antarmuka atau kelas abstrak untuk representasi bentuk tiga dimensi umum, dan
kemudian membuat kelas turunan untuk masing-masing bentuk khusus, seperti
balok dan kubus.

Dengan mengimplementasikan polimorfisme, kita dapat membuat metode

perhitungan volume yang dapat digunakan oleh objek dari kelas-kelas turunan
tanpa perlu mengetahui tipe spesifik dari objek tersebut. Contohnya, kita dapat
membuat antarmuka "BentukTigaDimensi" atau kelas abstrak yang memiliki
metode "hitungVolume". Kelas Balok dan Kubus dapat mengimplementasikan
antarmuka ini atau menurunkan dari kelas abstrak tersebut.

Dengan pendekatan ini, pemanggilan metode "hitungVolume" dapat

dilakukan tanpa memperhatikan apakah objek tersebut adalah balok atau kubus.
Sebagai contoh, kita dapat membuat array atau koleksi objek
"BentukTigaDimensi" yang mencakup keduanya, dan kita dapat menghitung
volume mereka secara bersamaan tanpa perlu tahu tipe spesifik dari setiap objek.

Selain itu, pendekatan ini mendukung ekspansi dalam hal menambahkan

bentuk tiga dimensi lainnya di masa mendatang. Dengan menambahkan kelas
turunan baru dan mengimplementasikan metode "hitungVolume" sesuai
kebutuhan, kita dapat mengintegrasikan bentuk baru tersebut ke dalam program
tanpa memodifikasi kodenya secara signifikan.

Secara keseluruhan, penggunaan polimorfisme dalam menghitung volume

balok dan kubus dapat mempermudah pengembangan, pemeliharaan, dan
perluasan program dengan menciptakan struktur yang dinamis, modular, dan
mudah dimengerti.
 KESIMPULAN

penggunaan polimorfisme dalam menghitung volume balok dan kubus pada program Java
membawa sejumlah manfaat. Konsep ini memungkinkan penciptaan antarmuka umum atau
kelas abstrak untuk bentuk tiga dimensi, yang dapat diimplementasikan oleh kelas turunan
seperti balok dan kubus. Keuntungan utama dari polimorfisme adalah fleksibilitas, di mana
metode perhitungan volume dapat dipanggil tanpa memerlukan pengetahuan spesifik
tentang tipe objek. Hal ini memfasilitasi manajemen dan pemeliharaan kode yang lebih
mudah, memungkinkan pengelolaan berbagai objek bentuk tiga dimensi dengan cara yang
konsisten. Selain itu, pendekatan ini memungkinkan ekspansi dengan menambahkan bentuk
tiga dimensi baru tanpa mengubah secara signifikan kode yang sudah ada. Dengan
demikian, penggunaan polimorfisme memberikan solusi yang dinamis, modular, dan
skalabel untuk mengatasi perhitungan volume berbagai bentuk tiga dimensi
dalam suatu program.
 PRAKTIKUM 8
INTERFACE

PENDAHULUAN

Tujuan Praktikum
1. Penulis diharapkan mampu memahami konsep dasar OOP seperti
interface,inheritance, dan polimorfisme.
2. Penulis diharapkan mampu membuat interface (Superhero) dan
mengimplementasikannya dalam kelas-kelas (Satria, Spiderman,
Superman).
3. Penulis diharapkan mampu memahami dan menerapkan konsep
polimorfisme melalui metode yang diimplementasikan di kelas-kelas
superhero.
Waktu dan Tempat
1. Tanggal : 13 Desember 2023
2. Waktu : 10.00 – 11.40
3. Tempat : Laboratorium Besar

Bahan dan Alat

1. Laptop HP 14s – DQ0XXX
2. Eclipse IDE
 TAHAPAN DAN PROSEDUR

1. Siapkan perangkat komputer dan software yang akan digunakan dalam

praktikum ini.
2. Buka Eclipse IDE.
3. Buat proyek baru dengan nama SuperheroProject
4. Dalam proyek, buat package baru dengan nama superhero. Klik kanan
pada proyek, pilih New -> Package, dan masukkan nama superhero.
5. buat file baru dengan nama Superhero.java.
6. - Tulis kode untuk interface `Superhero` sesuai dengan definisi yang
dibutuhkan.
7. Buat file baru dengan nama SuperHero.java.
8. Buat file baru dengan nama Pahlawan.java.
9. Buat file baru dengan nama Super.java.
10. Buat file baru dengan nama Thor.java.
11. Buat file baru dengan nama "Loki.java".
12. Buat file baru dengan nama "Hulk.java".
13. Jalankan class untuk menguji implementasi program.
 HASIL PRAKTIKUM

1. Superhero
 ANALISA

Dalam praktikum diatas dapat di analisa bahwa penulis membuat

program superhero dalam Java dengan Eclipse IDE, berikut adalah
beberapa poin analisis:

• Program menggambarkan konsep OOP dengan baik, termasuk penggunaan

interface, inheritance, dan polymorphism.
• Interface Superhero diimplementasikan dengan baik dan digunakan untuk
menciptakan objek dengan tipe yang sama.
• Package superhero digunakan untuk mengelompokkan kelas-kelas terkait.
• Program menjalani pengujian dengan baik dan memberikan output yang
sesuai.

KESIMPULAN

Dalam praktikum pembuatan program superhero menggunakan

Eclipse IDE, kesimpulannya adalah program telah berhasil
mengimplementasikan konsep-konsep dasar Pemrograman Berorientasi
Objek (OOP) secara efektif. Penerapan interface, inheritance, dan
polymorphism berhasil menghasilkan struktur program yang terorganisir
dan mudah dimengerti. Penggunaan Eclipse IDE memberikan kemudahan
dalam pengembangan dan manajemen proyek. Pengujian dan debugging
yang baik menunjukkan ketelitian dalam pengembangan program.
Dokumentasi yang memadai memperkuat pemahaman terhadap struktur
kode. Secara keseluruhan, praktikum ini memberikan pengalaman yang
positif dalam penerapan konsep OOP dalam pembuatan program Java,
sementara juga memberikan ruang untuk pengembangan lebih lanjut.
 UJIAN PRAKTIKUM
Soal 1:

Output :
Soal 2

Output: