(Acc) 32601900026-Nur Muhammad Syaifuddin (Pemrograman Berorientasi Objek)

LAPORAN PRAKTIKUM
PEMROGRAMAN BERORIENTASI OBJEK

HALAMAN JUDUL
Disusun Oleh :
NAMA : NUR MUHAMMAD SYAIFUDDIN
NIM : 32601900026
PRODI TEKNIK INFORMATIKA

FAKULTAS TEKNOLOGI INDUSTRI
UNIVERSITAS ISLAM SULTAN AGUNG
SEMARANG
2020
HALAMAN PENGESAHAN
Laporan Praktikum
Pemrograman Berorientasi Objek
Disusun Oleh :
Nur Muhammad Syaifuddin (32601900026)
Telah disetujui sebagai syarat untuk memenuhi mata kuliah Pemrograman

Berorientasi Objek. Jurusan Teknik Informatika Fakultas Teknologi Industri
Universitas Islam Sultan Agung Semarang.
Hari :
Tanggal :
1. Sigit Ardianto 1.
Mengetahui,
Laboran Dosen Praktikum
WerdhaWilubertha H, S.Kom Sam Farisa Chaerul Haviana, ST., M.Kom
ii
KATA PENGANTAR
Puji syukur penulis panjatkan kepada Allah SWT, yang telah memberikan
rahmat, taufik serta hidayah-Nya, sehingga laporan Pemrograman Berorientasi
Objek dapat terselesaikan.
Tanpa lupa penulis mengucapkan terima kasih kepada :

1. Rektor UNISSULA Bapak Drs. H. Bedjo Santoso, M.T., P.h.D yang
mengizinkan penulis menimba ilmu di kampus ini.
2. Dekan Fakultas Teknologi Industri Ibu Dr, Hj, Sri Arttini Dwi Prasetyowati,
M,Si.
3. Dosen pengampu Bapak Sam Farisa Chaerul Haviana, ST., M.Kom yang
telah memberi ilmu tentang Pemrograman Berorientasi Objek.
4. Orang tua penulis yang telah mengizinkan untuk menyelesaikan laporan ini.
5. Dan kepada semua pihak yang tidak dapat saya sebutkan satu persatu.
Penulis menyadari bahwa dalam penyusunan laporan ini masih terdapat

banyak kekurangan, untuk itu penulis mengharap kritik dan saran dari pembaca
untuk sempurnanya laporan ini. Semoga dengan ditulisnya laporan ini dapat
menjadi sumber ilmu bagi setiap pembaca.
Semarang, 13 Desember 2020
Nur Muhammad Syaifuddin
iii
DAFTAR ISI
HALAMAN JUDUL .............................................................................................. i

HALAMAN PENGESAHAN ............................................................................... ii
KATA PENGANTAR .......................................................................................... iii
DAFTAR ISI ......................................................................................................... iv
DAFTAR GAMBAR .......................................................................................... viii
DAFTAR TABEL ................................................................................................ xi
BAB I INSTALASI JDK DAN NETBEANS ...................................................... 1
1.1 Tujuan ....................................................................................................... 1
1.2 Dasar Teori ............................................................................................... 1
1.3 Latihan ...................................................................................................... 2
1.3.1 Instalasi JDK 8 .................................................................................. 2
1.3.2 Instalasi Netbeans IDE ...................................................................... 2
1.3.3 Nebeans IDE 8 .................................................................................. 3
1.3.4 Program Sederhana ........................................................................... 6
1.3.5 Penambahan Komentar ..................................................................... 8
1.4 Tugas ........................................................................................................ 9
1.5 Kesimpulan ............................................................................................. 10
BAB II VARIABEL, TIPE DATA, DAN OPERATOR .................................. 11
2.1 Tujuan ..................................................................................................... 11
2.2 Dasar Teori ............................................................................................. 11
2.2.1 Variabel ........................................................................................... 11
2.2.2 Tipe Data ......................................................................................... 12
2.2.3 Operator........................................................................................... 13
2.3 Latihan .................................................................................................... 14
2.4 Tugas ...................................................................................................... 18
2.5 Kesimpulan ............................................................................................. 29
BAB III ARRAY DAN STRING ....................................................................... 30
3.1 Tujuan ..................................................................................................... 30
3.2 Dasar Teori ............................................................................................. 30
iv
3.2.1 Array ............................................................................................... 30
3.2.2 String ............................................................................................... 32
3.3 Latihan .................................................................................................... 35
3.4 Tugas ...................................................................................................... 54
3.5 Kesimpulan ............................................................................................. 61
BAB IV KONSEP DASAR PEMROGRAMAN JAVA ................................... 62
4.1 Tujuan ..................................................................................................... 62
4.2 Dasar Teori ............................................................................................. 62
4.2.1 Pengantar Pemrograman Berorientasi Objek .................................. 62
4.2.2 Apa Itu Kelas? ................................................................................. 63
4.2.3 Mendefinisikan Kelas...................................................................... 64
4.2.4 Contoh Kasus Sederhana................................................................. 65
4.2.5 Instansiasi Objek ............................................................................. 66
4.2.6 Mengisi Nilai Pada Referensi Objek ............................................... 66
4.2.7 Method............................................................................................. 67
4.2.8 Mendefinisikan Method .................................................................. 67
4.2.9 Pengembalian Nilai di Dalam Method ............................................ 68
4.2.10 Method Berparameter ...................................................................... 68
4.2.11 Constructor ..................................................................................... 69
4.2.12 Kata Kunci This .............................................................................. 70
4.2.13 Melakukan Overload Terhadap Method ......................................... 71
4.2.14 Overload Pada Constructor ............................................................ 72
4.2.15 Menentukan Tingkat Akses Data dan Method ................................ 72
4.2.16 Kata Kunci Static ............................................................................ 73
4.2.17 Kata Kunci Final ............................................................................. 74
4.2.18 Kelas di Dalam Kelas (inner class)................................................. 74
4.3 Latihan .................................................................................................... 75
4.4 Tugas .................................................................................................... 104
4.5 Kesimpulan ........................................................................................... 110
BAB V PEWARISAN (INHERITANCE) ........................................................ 111
5.1 Tujuan ................................................................................................... 111
v
5.2 Dasar Teori ........................................................................................... 111
5.2.1 Pewarisan ...................................................................................... 111
5.2.2 Overriding ..................................................................................... 113
5.2.3 Overloading .................................................................................. 113
5.3 Latihan .................................................................................................. 114
5.4 Tugas .................................................................................................... 124
5.5 Kesimpulan ........................................................................................... 129
BAB VI POLIMORFISME .............................................................................. 130
6.1 Tujuan ................................................................................................... 130
6.2 Dasar Teori ........................................................................................... 130
6.3 Latihan .................................................................................................. 130
6.4 Tugas .................................................................................................... 135
6.5 Kesimpulan ........................................................................................... 139
BAB VII PENANGANAN EKSEPSI .............................................................. 140
7.1 Tujuan ................................................................................................... 140
7.2 Dasar Teori ........................................................................................... 140
7.2.1 Eksepsi .......................................................................................... 140
7.2.2 Menggunakan Kata Kunci Try dan Catch..................................... 141
7.2.3 Penjebakan Beberapa Tipe Eksepsi .............................................. 141
7.2.4 Menggunakan Kata Kunci Throw ................................................. 142
7.2.5 Menggunakan Kata Kunci Throws................................................ 142
7.2.6 Menggunakan Kata Kunci Finally ................................................ 143
7.3 Latihan .................................................................................................. 143
7.4 Tugas .................................................................................................... 152
7.5 Kesimpulan ........................................................................................... 154
BAB VIII INPUT DAN OUTPUT .................................................................... 155
8.1 Tujuan ................................................................................................... 155
8.2 Dasar Teori ........................................................................................... 155
8.2.1 Pengertian Stream ......................................................................... 155
8.2.2 Tipe Stream ................................................................................... 155
8.2.3 Melakukan Input ........................................................................... 156
vi
8.2.4 Membaca Input Data Karakter ...................................................... 157
8.2.5 Membaca Input Data String .......................................................... 157
8.2.6 Membaca Input Data Numerik ...................................................... 157
8.2.7 Dasar – dasar Baca Tulis File ....................................................... 157
8.3 Latihan .................................................................................................. 158
8.4 Tugas .................................................................................................... 166
8.5 Kesimpulan ........................................................................................... 177
DAFTAR PUSTAKA
LAMPIRAN
vii
DAFTAR GAMBAR
Gambar 1. 1 Tampilan awal netbeans IDE ............................................................. 3

Gambar 1. 2 Membuat projek baru ......................................................................... 3
Gambar 1. 3 Memilih kategori projek ..................................................................... 4
Gambar 1. 4 Memberi nama projek ........................................................................ 4
Gambar 1. 5 Tampilan awal projek hello_word...................................................... 5
Gambar 1. 6 Program utama hello_word ................................................................ 6
Gambar 1. 7 Hasil eksekusi program hello_word ................................................... 7
Gambar 1. 8 Penambahan komentar pada program ................................................ 8
Gambar 1. 9 Output tugas 1 .................................................................................. 10
Gambar 2. 1 Output latihan 1 operasi aritmatika .................................................. 15
Gambar 2. 2 Output latihan 2 operasi relasi .......................................................... 16
Gambar 2. 3 Output latihan 3 operasi logika ........................................................ 17
Gambar 2. 4 Output tugas 1 operator tambah ....................................................... 20
Gambar 2. 5 Output tugas 1 operator kurang ........................................................ 20
Gambar 2. 6 Output tugas 1 operator kali ............................................................. 21
Gambar 2. 7 Output tugas 1 operator bagi ............................................................ 21
Gambar 2. 8 Output tugas 1 jika operator tidak ada ............................................. 22
Gambar 2. 9 Output tugas 2 operator AND .......................................................... 24
Gambar 2. 10 Output tugas 2 operator OR ........................................................... 25
Gambar 2. 11 Output tugas 2 operator NOT ......................................................... 25
Gambar 2. 12 Output tugas 2 jika operator tidak ada ........................................... 26
Gambar 2. 13 Output tugas 3 konversi tipe data ................................................... 28
Gambar 3. 1 Output latihan 1 ................................................................................ 36
viii
Gambar 3. 10 Output latihan 10 ............................................................................ 50
Gambar 3. 13 Output tugas 1 ................................................................................ 55
Gambar 4. 14 Output latihan 14 .......................................................................... 101
Gambar 4. 17 Output tugas 1 .............................................................................. 108
Gambar 4. 18 Output tugas 1 .............................................................................. 109
Gambar 5. 1 Hirarki class dosen ......................................................................... 112
Gambar 5. 2 Class diagram untuk hirarki dosen ................................................. 112
Gambar 5. 3 Output latihan 1 .............................................................................. 117
ix
Gambar 6. 1 Output latihan polimorfisme .......................................................... 134
Gambar 6. 2 Output tugas 1 ............................................................................... 138
Gambar 8. 1 Output latihan 1 .......................................................................................... 159
Gambar 8. 5 Isi file input.txt ........................................................................................... 163
Gambar 8. 6 Isi file output.txt yang telah dibuat ............................................................ 165
Gambar 8. 7 Membuat file input.txt, mengecek, mengisi, dan menampilkan file .......... 174
Gambar 8. 8 File input.txt ............................................................................................... 174
Gambar 8. 9 Merename nama file input.txt .................................................................... 174
Gambar 8. 10 Nama file yang telah direname ................................................................ 174
Gambar 8. 11 Menghapus file inputUser.txt ................................................................... 175
Gambar 8. 12 File inputUser.txt berhasil dihapus........................................................... 175
Gambar 8. 13 Membuat file output.dat, mengecek, mengisi, dan menampilkan file ..... 175
Gambar 8. 14 File output.dat .......................................................................................... 176
Gambar 8. 15 Merename file output.dat ......................................................................... 176
Gambar 8. 16 Nama file yang telah direname ................................................................ 176
Gambar 8. 17 Menghapus file outputUser.dat ................................................................ 176
Gambar 8. 18 File outputUser.dat berhasil dihapus ........................................................ 176
x
DAFTAR TABEL
Tabel 1. 1 Operator relasi ...................................................................................... 13

Tabel 3. 1Daftar nilai PBO 5 mahasiswa .............................................................. 31
Tabel 3. 2 Konversi nilai ke huruf ........................................................................ 32
xi
BAB I
INSTALASI JDK DAN NETBEANS
1.1 Tujuan
1. Prakikan dapat melakukan instalasi dan setting Java Development Kit
(JDK).
2. Praktikan dapat menggunakan Netbeans IDE sebagai editor
pemrograman.
3. Praktikan dapat menjalankan (eksekusi) program java sederhana yang
ditulis dengan Netbeans IDE.
1.2 Dasar Teori

Untuk menulis program JAVA dapat digunakan berbagai editor, bahkan
editor paling sederhana seperti Notepad pun dapat digunakan. Namun pada
umumnya, agar penulisan program lebih terarah, beberapa editor telah
disediakan untuk membantu para programmer. Beberapa editor atau IDE
(Integrated Development Environment) yang telah ada untuk Java, antara
lain : (Primakara, 2015)
1. NetBeans (Open Source - Common Development and Distribution
License (CDDL)).
2. NetBeans yang disponsori Oracle, yang dilengkapi dengan GUI Editor.
3. Eclipse JDT (open source- Eclipse Public License).
4. Eclipse dibuat dari kerja sama antara perusahaan - perusahaan anggota
'Eclipse Foundation' (beserta individu - individu lain). Banyak nama
besar yang ikut dalam 'Eclipse Foundation', termasuk IBM, BEA, Intel,
Nokia, Borland. Eclipse bersaing langsung dengan Netbeans IDE.
Plugin tambahan pada Eclipse jauh lebih banyak dan bervariasi
dibandingkan IDE lainnya.
5. IntelliJ IDEA (commercial, free 30-day trial).
6. Oracle JDeveloper (free).
7. JCreator (ada versi berbayar maupun free).
1
2
8. JCreator ditulis dalam C/C++ sehingga lebih cepat dan menggunakan

memori lebih sedikit dari kebanyakan IDE lain.
1.3 Latihan
1.3.1 Instalasi JDK 8
Sebelum memulai pemrograman Java, kita harus menginstal Java
Development Kit (JDK) dan Netbeans IDE yang disediakan secara gratis
oleh Oracle. Java Development Kit tersedia dan dapat didownload pada
situs:
http://www.oracle.com/technetwork/java/javase/downloads/index.ht
ml.
JDK 8 untuk berbagai platform tersedia pada situs tersebut. Installer
yang mengekstrak file JDK akan membuat direktori yang diperlukan dan 4
sekaligus menyalin file - file ke dalam direktori tersebut. Installshield
Wizard memberikan tampilan bahwa Java siap diinstalasi.
1.3.2 Instalasi Netbeans IDE
Netbeans versi terbaru dapat didownload secara gratis pada situs
Netbeans yaitu : https://netbeans.org/downloads/. Untuk memulai instalasi
Netbeans, jalankan aplikasi file netbeans yang sudah Anda download
sebelumnya dan lanjutkan langkah instalasi.
3
1.3.3 Nebeans IDE 8

Pada praktikum Pemrograman Berbasis Objek ini akan menggunakan
netbeans sebagai editor pemrograman. Berikut langkah – langkah
penggunaan netbeans.
1. Setelah masuk ke netbeans maka akan terlihat tampilan seperti pada
gambar di bawah.
Gambar 1. 1 Tampilan awal netbeans IDE

Gambar di atas adalah tampilan awal dari netbeans IDE.
2. Untuk memulai projek baru, pilih file -> new project pada bagian menu.
Gambar 1. 2 Membuat projek baru

Gambar di atas adalah item untuk membuat projek baru di netbeans
IDE.
4
3. Kemudian pada saat bagian choose project category pilih java dan pada
bagian project pilih java application.
Gambar 1. 3 Memilih kategori projek

Gambar di atas menunjukan kategori dan projek yang akan kita buat.
Kemudian klik next untuk melanjutkan.
4. Selanjutnya masuka project name dan project location. Sebagai Latihan
beri nama projek dengan hello_word.
Gambar 1. 4 Memberi nama projek

Gambar di atas adalah tampilan untuk memasukan nama dan lokasi
projek yang akan kita disimpan. Pada bagian create main class, dapat
diberikan nama yang berbeda dari project name nya. Tidak perlu
5
menambahkan .Main atau .Java, NetBeans akan secara otomatis

memberikan ekstensi-nya. Setelah selesai, klik finish.
Gambar 1. 5 Tampilan awal projek hello_word

Dengan demikian projek baru telah berhasil dibuat. Untuk
pembuatan class baru akan dijelaskan lebih lanjut pada praktikum
berikutnya yang membahas khusus tentang pembuatan class.
6
1.3.4 Program Sederhana

Pada projek hello_word yang dibuat tambahkan perintah sebagai
berikut:
System.out.println(“Hello World!”);
Gambar 1. 6 Program utama hello_word

Keterangan:
A. Sintaks utama untuk program yang ditulis dengan JAVA adalah:
[modifier] class nama_class
{
…
}
Ada beberapa modifier pada JAVA, yaitu public, private, protected,
dan default.
7
B. Bagian ini merupakan bagian utama yang ditempatkan pada bagian awal
pada program JAVA. static menunjukkan tipe method. void
menunjukkan bahwa method tidak mengembalikan nilai atau objek.
main merupakan nama method utama program JAVA. String
merupakan tipe argumen yang akan diterima sebagai parameter dari
command JAVA. args merupakan array argumen yang dapat
ditambahkan pada saat menggunakan command JAVA untuk
menjalankan program JAVA.
C. Perintah untuk menampilkan “Hello_World!” pada layer monitor.
Selanjutnya program dapat dieksekusi dengan klik tombol play atau
tekan shift+F6.
Gambar 1. 7 Hasil eksekusi program hello_word

Gambar di atas adalah output dari program, yaitu menampilkan teks
“Hello_World”.
8
1.3.5 Penambahan Komentar

Untuk membantu mengingat arti (tujuan) penulisan serangkaian kode
yang telah ditulis, biasanya kita memberikan beberapa komentar pada
program yang kita buat. Pada JAVA, untuk membuat komentar dapat
dilakukan dengan cara:
a. Komentar dengan menggunakan tanda //. Tanda ini digunakan untuk
memberikan komentar dalam satu baris. Tanda // diletakan pada awal
baris.
b. Komentar dengan menggunakan tanda /* dan */. Tanda ini digunakan
untuk memberikan komentar yang ditulis pada beberapa kalimat. Tanda
/* diletakan pada awal kalimat dan tanda */ diletakan akhir kalimat.
Gambar 1. 8 Penambahan komentar pada program

Gambar di atas adalah contoh penggunaan komentar.
9
1.4 Tugas
1. Buatlah sebuah program yang mencetak data berikut!
Nama : Nur Muhammad Syaifuddin
NIM : 32601900026
Alamat : Desa Sembaturagung rt 04 rw 02
No. Telepon : 085747450205
Email : nurmuhammadsyaifuddin@std.unissula.ac.id
Data bisa diganti dengan data Anda.
Jawab:
a. Kode program
package com.prak.pbo;
import java.util.Scanner;
public class Main {

public static void main(String [] args){
System.out.println("Nama\t: Nur Muhammad Syaifuddin");

System.out.println("NIM\t: 32601900026\n");
Scanner input = new Scanner(System.in);
System.out.print("Nama\t: ");
String nama = input.nextLine();
System.out.print("NIM\t: ");
String nim = input.nextLine();
System.out.print("Alamat\t: ");
String alamat = input.nextLine();
System.out.print("Telp\t: ");
String telepon = input.nextLine();
System.out.print("Email\t: ");
String email = input.nextLine();
}
}
10
b. Output program
Gambar 1. 9 Output tugas 1
c. Penjelasan
Program di atas adalah program untuk menampilkan biodata
mahasiswa. Dimana untuk setiap data yaitu nama, nim, alamat,
nomor telepon, dan email diinputkan oleh user.
java.util.Scanner adalah library untuk memanggil fungsi input
di java. Fungsi nextLine() adalah untuk menginputkan value
apabila kata yang diinputkan mengandung spasi atau lebih dari satu
kata.
1.5 Kesimpulan
Pada BAB I ini kita telah melakukan instalasi JDK dan Netbeans IDE
untuk membuat projek dengan bahasa pemrograman java. Kita juga telah
berhasil membuat projek pertama kita di Netbeans IDE yaitu hello_word.
Pada struktur kode program terdapat sintaks public static void
main(String [] args), sintaks tersebut adalah method utama di java,
dimana segala jenis perintah akan dieksekusi di blok state method main.
Untuk penambahan komentar yaitu dengan tanda // jika hanya satu baris,
jika lebih gunakan /* dan */ di awal dan akhir kalimat. Sintaks
System.out.println(); adalah perintah untuk menampilkan sesuatu di
console dan memberi satu baris baru.
BAB II
VARIABEL, TIPE DATA, DAN OPERATOR
2.1 Tujuan
1. Praktikan dapat membuat variabel dengan benar.
2. Praktikan dapat menggunakan berbagai tipe data dalam berbagai
kepentingan.
3. Praktikan mampu menggunakan berbagai operator dan
mengimplementasikannya dalam pemrograman.
2.2 Dasar Teori

2.2.1 Variabel
Variabel adalah suatu nama dari suatu lokasi di memori yang digunakan
untuk menyimpan data sementara. Variabel diberi nama tertentu yang
menunjukan domain yang diwakilinya. Dalam memberikan nama variabel,
ada beberapa ketentuan yang harus diperhatikan yaitu : (Sudarso, 2016)
a. Panjang karakter nama variabel tidak dibatasi.
b. Nama variabel diawali dengan huruf, tanda garis bawah (underscore)
atau tanda dollar ($).selanjutnya dapat diikuti oleh karakter lain, selain
operator (*, -, +).
c. Bersifat case sensitive (membedakan huruf kapital dan huruf kecil).
d. Tidak diperbolehkan menggunakan kata – kata kunci yang digunakan
pada java, seperti: if, for, while, dll.
Data yang tersimpan dalam variabel memiliki tipe tertentu. Sebelum
digunakan dalam aplikasi, suatu variabel harus dideklarasikan terlebih
dahulu. Berikut adalah sintaksnya :
[tipe_data] [nama_variabel]
Beberapa tipe data yang dapat digunakan akan dibahas pada sub-bab
berikutnya.
11
12
2.2.2 Tipe Data

A. Karakter
Karakter tunggal, diberikan dengan tipe data char. Data yang
memiliki tipe data ini ditulis dengan diapit tanda petik tungal, seperti:
‘A’, ‘S’, ‘?’, dll. char berbeda dengan String. String adalah kumpulan
dari beberapa karakter. Data yang memiliki tipe data ini ditulis dengan
diapit tanda petik ganda.
Contoh:
String nama, golDarah;
nama = “udin”;
golDarah = “AB”;
B. Integer
Tipe data integer merupakan bilangan bulat (positif, 0, atau negatif).
Contoh:
int x1, x2, jumlah;
jumlah = x1 + x2;
Selain integer, adapula tipe data bilangan bulat yang lain, yang
membedakan hanyalah panjang memori yang ditempatinya.
- Byte menempati lokasi sebesar 1 byte.
- Short menempati lokasi sebesar 2 byte.
- Int menempati lokasi sebesar 4 byte.
- Long menempati lokasi sebesar 8 byte.
C. Floating point
Untuk merepresentasikan data pecahan (bukan integer) dapat
digunakan dua macam tipe data, yaitu float atau double. Tipe data float
memiliki panjang lokasi penyimpanan sebesar 4 byte sedangkan double
sepanjang 8 byte.
Contoh:
Int x1, x2;
float Rata2;
double PanjangJalur;
Rata2 = (x1 + x2)/2;
PanjangJalur = 1.5E3;
13
D. Boolean
Tipe data Boolean hanya memiliki 2 kemungkinan nilai yaitu true
dan false.
Contoh:
boolean selesai;
selesai = true;
2.2.3 Operator
A. Operator aritmatika
Operator aritmatika di JAVA seperti pada umumnya terdiri dari
penjumlahan (+), pengurangan (-), pembagian (/), perkalian (*), dan
modulo (%).
Disamping operator – operator dasar tersebut, ada beberapa cara
singkat untuk menuliskan operator aritmatika seperti:
- x = x + 1, dapat disingkat menjadi x++
- x = x – 1, dapat disingkat menjadi x—
- x = x + 3, dapat disingkat menjadi x += 3
- x = x – 3, dapat disingkat menjadi x -= 3
B. Operator relasi
Operator relasi digunakan dalam ekspresi boolean yang akan
menghasilkan nilai boolean guna menentukan langkah eksekusi blok
pernyataan tertentu. Berikut adalah simbol dari operator relasi:
Tabel 1. 1 Operator relasi
Simbol Keterangan
> Lebih dari
< Kurang dari
>= Lebih dari sama dengan
<= Kurang dari sama dengan
== Sama dengan
!= Tidak sama dengan
14
C. Operator logika
Operator logika digunakan juga dalam ekspresi boolean yang akan
menghasilkan nilai boolean guna menentukan langkah eksekusi blok
pernyataan tertentu. Beberapa operator logika seperti AND (&&), OR
(||) atau NOT (!).
2.3 Latihan
1. Operator aritmatika
a. Kode program
public class Main {

public static void main(String[] args) {

int A = 100, B = 30;

int jumlah = A + B;
int kurang = A - B;
int kali = A * B;
float bagi = (float) A / B;
int modulo = A % B;
System.out.println("penjumlahan " + A + " + " + B + "

= " + jumlah);
System.out.println("pengurangan " + A + " - " + B + "
= " + kurang);
System.out.println("perkalian " + A + " * " + B + " =
" + kali);
System.out.println("pembagian " + A + " / " + B + " =
" + bagi);
System.out.println("modulo " + A + " mod " + B + " = "
+ modulo);
}
}
15
b. Output program
Gambar 2. 1 Output latihan 1 operasi aritmatika
c. Penjelasan
Program di atas adalah program untuk melakukan operasi
aritmatika yaitu +, -, *, /, dan modulo. Pada program di atas kita
melakukan operasi aritmatika dengan 2 nilai yaitu 100 dan 30.
Maka, hasil dari penjumlahan, penguranganm, perkalian,
pembagian, dan modulo dari 2 nilai tersebut, akan seperti gambar
output di atas.
2. Operator relasi
a. Kode program
public class Main {

int A = 100, B = 30;

boolean lb = A > B;
boolean lk = A < B;
boolean lbs = A >= B;
boolean lks = A <= B;
boolean sm = A == B;
boolean tsm = A!= B;
16
System.out.println(A + " > " + B + " => " + lb);

System.out.println(A + " < " + B + " => " + lk);
System.out.println(A + " >= " + B + " => " + lbs);
System.out.println(A + " <= " + B + " => " + lks);
System.out.println(A + " == " + B + " => " + sm);
System.out.println(A + " != " + B + " => " + tsm);
}
}
b. Output program
Gambar 2. 2 Output latihan 2 operasi relasi
c. Penjelasan
Program di atas adalah program dari penggunaan operator relasi
yaitu >, <, >=, <=, ==, dan !=. pada program di atas kita
membandingkan 2 nilai yaitu 100 dan 30, maka setelah dilakukan
perbandingan 2 nilai tersebut, hasilnya akan seperti pada gambar
output di atas.
17
3. Operator logika
a. Kode program
public class Main {
boolean A = true, B = false;
boolean o_and = A && B;
boolean o_or = A || B;
boolean o_notA = !A;
boolean o_notB = !B;
System.out.println(A + " AND " + B + " => " + o_and);
System.out.println(A + " OR " + B + " => " + o_or);
System.out.println("NOT " + A + " => " + o_notA);
System.out.println("NOT " + B + " => " + o_notB);
}
}
b. Output program
Gambar 2. 3 Output latihan 3 operasi logika
c. Penjelasan
Program di atas adalah program dari penggunaan operator
logika, dimana kita memiliki 2 variabel boolean, A bernilai true dan
B bernilai false. Kemudian dilakukan operasi AND, OR, dan NOT
pada kedua variabel tersebut, sehingga menghasilkan output seperti
gambar di atas.
18
2.4 Tugas
1. Buatlah program kalkulator sederhana yang mengimplementasikan
beberapa operator yang sudah dijelaskan.
Jawab:
a. Kode program
public class Main {

static void calculate(float a, String operator, float
b){
float hasil;
switch (operator){
case "+":
hasil = a + b;
displayHasil(a, operator, b, hasil);
break;
case "-":
hasil = a - b;
break;
case "*":
hasil = a * b;
break;
case "/":
hasil = a / b;
break;
default:
System.out.println("\noperator tidak ditemukan");
}
19
static void displayHasil(float a, String operator,

float b, float hasil){
System.out.println("\njadi, " + a + " " + operator + "
" + b);
System.out.println("hasilnya adalah " + hasil);
}
public static void main (String[]args){

Scanner udin = new Scanner (System.in);

float a,b,hasil;
String operator;
System.out.print("nilai a = ");
a = udin.nextFloat();
System.out.print("operator = ");
operator = udin.next();
System.out.print("nilai b = ");
b = udin.nextFloat();
calculate(a, operator, b);

}
}
20
b. Output program
Gambar 2. 4 Output tugas 1 operator tambah
Gambar 2. 5 Output tugas 1 operator kurang

21
Gambar 2. 6 Output tugas 1 operator kali
Gambar 2. 7 Output tugas 1 operator bagi

22
Gambar 2. 8 Output tugas 1 jika operator tidak ada
c. Penjelasan
Program di atas adalah program untuk membuat kalkulator
sederhana, yaitu menggunakan operator tambah, kurang, kali, dan
bagi. Masing – masing gambar di atas menunjukan output dari
masing – masing operator. Jika operator yang kita inputkan salah,
maka program akan menampilkan pesan di console “operator tidak
ditemukan”.
2. Buatlah sebuah program untuk menampilkan hasil operasi dasar logika
AND, OR, dan NOT.
Jawab:
a. Kode program
public class Main {
static void displayOperasiLogika(String operator){
if(operator.equals("or") || operator.equals("OR")){
operasiOr(true, true);
operasiOr(true, false);
23
operasiOr(false, true);
operasiOr(false, false);
}else if(operator.equals("and") ||
operator.equals("AND")){
operasiAnd(true, true);
operasiAnd(true, false);
operasiAnd(false, true);
operasiAnd(false, false);
}else if(operator.equals("not") ||
operator.equals("NOT")){
operasiNot(true);
operasiNot(false);
}else{
System.out.println("\noperator Logika tidak
ditemukan");
}
}
static void operasiOr(boolean a, boolean b){

boolean hasil;
hasil = a || b;
System.out.println(a + " || " + b + " = " + hasil);
}
static void operasiAnd(boolean a, boolean b){

boolean hasil;
hasil = a && b;
System.out.println(a + " && " + b + " = " + hasil);
}
static void operasiNot(boolean a){

boolean b;
b = !a;
System.out.println("!" + a + " = " + b);
}

24
System.out.print("Pilih Operator Logika = ");

String operator = input.nextLine();
System.out.println();
displayOperasiLogika(operator);
}
b. Output program
Gambar 2. 9 Output tugas 2 operator AND

25
Gambar 2. 10 Output tugas 2 operator OR
Gambar 2. 11 Output tugas 2 operator NOT

26
Gambar 2. 12 Output tugas 2 jika operator tidak ada
c. Penjelasan
Program di atas adalah program untuk menampilkan hasil dari
operasi logika AND, OR, dan NOT. Untuk AND, jika semua true
maka hasilnya true, satu saja bernilai false, maka hasilnya false.
Untuk OR, jika semua atau salah satu saja true maka hasilnya true,
jika semua false hasilnya false. Dan untuk NOT, jika true maka
hasilnya false dan jika false maka hasilnya true.
3. Buatlah sebuah program yang melibatkan proses casting nilai pada
sebuah variabel!
Jawab:
a. Kode program
public class Main {
static void castingValue(int a, int b){

System.out.println("\nNilai int a = " + a);
System.out.println("Nilai int b = " + b);
System.out.println("Nilai float a = " + (float) a);
System.out.println("Nilai float b = " + (float) b);
27
int bagiInt = a / b;
float bagiFloat = (float) a / b;
System.out.println("Hasil bagi int = " + bagiInt);
System.out.println("Hasil bagi float = " + bagiFloat +
"\n");
}

System.out.print("Nilai a = ");
int a = input.nextInt();
System.out.print("Nilai b = ");
int b = input.nextInt();
castingValue(a, b);
}
28
b. Output program
Gambar 2. 13 Output tugas 3 konversi tipe data
c. Penjelasan
Program di atas adalah program untuk menampilkan casting
nilai dari tipe data integer ke tipe data float. Dimana user
menginputkan nilai a dan b bertipe integer, kemudian nilai a dan b
akan di konversi ke tipe data float. Dan kedua nilai akan dibagi.
Hasil baginya berupa nilai bertipekan integer dan float.
29
2.5 Kesimpulan
Pada BAB II ini kita telah mempelajari apa itu variabel, tipe data, dan
operator di bahasa pemrograman java. Variabel tersebut diantaranya
integer, short, byte, long, float, double, char, dan string. Kita sudah tahu
bagaimana cara penulisan variabel dan tipe data yang benar. Bagaimana
fungsi dari penggunaan operator aritmatika, relasi, dan logika. Kita juga
telah tahu bagaimana cara mengkonversi tipe data ke tipe data lain.
Sehingga diharapkan setelah ini kita mampu menerapkannya pada projek
java kita nanti.
BAB III
ARRAY DAN STRING
3.1 Tujuan
1. Praktikan mengerti dan memahami penggunaan array dan string
2. Praktikan mampu menggunakan operator dan method yang menyertai
penerapan array dan string
3.2 Dasar Teori

3.2.1 Array
Array merupakan tipe data yang digunakan apabila data diberikan
berupa kelompok data yang disajikan secara berurutan. Setiap elemen data
memiliki tipe data yang sama. Array menggunakan sekelompok lokasi
memori yang berurutan dengan nama dan tipe data yang berbeda. (Zakaria,
2017)
Sintaks:
Tipe_data nama_variabel [];
Atau
Tipe_data [] nama_variabel;
Besarnya alokasi memori yang akan digunakan perlu diberikan sebelum
variabel bertipe array tersebut digunakan. Apabila alokasi memori tidak
diberikan secara eksplisit, maka Java akan memberikannya secara implisit.
Kemudian, setiap elemen data disebut dengan nama_variabel_array yang
diikuti dengan indeks penomorannya.
Sebagai contoh, apabila akan dibuat variabel penjualan bertipe array
dengan alokasi memori sebesar 11, dan akan memberikan nilai 125 untuk
penjualan ke-11, maka dapat dituliskan:
Sintaks:
int penjualan[];
penjualan = new int[11];
penjualan[11] = 125;
30
31
untuk mengetahui jumlah elemen dari sekelompok data yang bertipe

array, dapat digunakan perintah length.
Sintaks:
nama_variabel_array.length
Model array sebagaimana yang dijelaskan di awal merupakan array satu
dimensi. Sangat dimungkinkan suatu variabel membutuhkan array dua
dimensi, misalkan pada aplikasi matriks. Sintaks untuk array dua dimensi
adalah sebagai berikut:
Tipe_data nama_variabel [][];
Atau
Tipe_data [][] nama_variabel;
Sebagai contoh, apabila akan dibuat variabel penjualan bertipe array
dua dimensi, dengan alokasi memori sebesar 12 untuk dimensi pertama dan
31 untuk dimensi kedua, serta akan memberikan nilai 125 untuk penjualan
pada dimensi (11,23) maka dapat dituliskan:
int penjualan[][];
penjualan = new int [12][31];
penjualan[11][23] = 125;
Diketahui daftar nilai matakuliah PBO untuk 5 mahaiswa sebagaimana
terlihat pada Tabel di bawah:
Tabel 3. 1 Daftar nilai PBO 5 mahasiswa
Nilai
Mahsiswa ke -
Rata2 tugas UTS UAS
1 50 60 70
2 70 75 87
3 89 90 90
4 65 76 89
5 65 70 80
32
Selanjutnya akan dicari nilai akhir untuk setiap mahasiswa yang

merupakan nilai rata-rata dari ketiga komponen penilaian (rata2 tugas, UTS,
dan UAS). Selanjutnya, pemberian nilai dengan huruf diberikan sebagai
berikut:
Tabel 3. 2 Konversi nilai ke huruf
Nilai Huruf
Nilai > 80 A
70 < nilai <= 80 B
60 < nilai <= 70 C
50 < nilai <= 60 D
Nilai <= 50 E
3.2.2 String
String merupakan deretan karakter. Pada java, string merupakan objek
dari kelas String. Penulisan string dilakukan dengan mengapit data
menggunakan tanda petik (ganda). Berikut adalah sintaksnya :
String judul = “Pemrograman Berbasis Objek”;
String dapat dioperasikan dengan menggunakan beberapa operator atau
method untuk beberapa kepentingan yang berbeda. Yaitu diantaranya
sebagai berikut:
a. Mengetahui panjang string
Untuk mengetahui panjang string dapat digunakan method length().
Berikut adalah contoh sintaksnya:
System.out.println(judul.length());
b. Mengetahui kesamaan antara dua string
Untuk mengetahui kesamaan antara dua string dapat menggunakan
operator == atau method equal(String) atau method
equal.IgnoreCase(String).
c. Melakukan perbandingan karakter – karakter pada string

Untuk melakukan perbandingan karakter – karakter secara berurutan
dari awal string dapat menggunakan method compareTo().
33
d. Mendapatkan karakter pada posisi tertentu

Untuk mendapatkan karakter pada posisi tertentu dapat digunakan
method charAt(int Posisi). Posisi pertama bernilai integer 0, hingga
posisi terakhir bernilai N-1 (dengan N adalah panjang string).
e. Mendapatkan posisi karakter pada string
Untuk mendapatkan posisi karakter pada string dapat dilakukan du
acara sebagai berikut:
- Apabila posisi awal pencarian tidak ditentukan, maka untuk
mendapatkan posisi karakter pada string dapat menggunakan
method indexOf(char Karakter). Apabila karakter tidak
ditemukan, maka akan diberikan nilai - 1.
- Apabila posisi awal pencarian telah ditentukan, maka untuk
mendapatkan posisi karakter pada pada string dapat digunakan
method indexOf(char Karakter, int Awal). Nilai Awal
merupakan bilangan integer yang menunjukkan posisi awal
pencarian. Apabila karakter tidak ditemukan, maka akan diberikan
nilai -1.
f. Melakukan konversi huruf besar ke huruf kecil
Untuk melakukan konversi huruf besar ke huruf kecil dapat
menggunakan method toLowerCase().
g. Melakukan konversi huruf kecil ke huruf besar
Untuk melakukan konversi huruf besar ke huruf kecil dapat
menggunakan method toUpperCase().
h. Melakukan penyambungan antar dua string
Untuk melakukan penyambungan antar dua string dapat
menggunakan operator +.
34
i. Membuat string baru

Untuk membuat string baru dari string yang sudah ada dapat
dilakukan dua cara, sebagai berikut:
- Untuk membuat string baru dari string yang telah ada mulai dari
karakter awal string dapat menggunakan method substring(int
awal).
- Untuk membuat string baru dari string yang telah ada mulai dari
karakter awal hingga karakter akhir string dapat menggunakan
method substring(int awal, int akhir).
j. Melakukan modifikasi string
Untuk melakukan modifikasi string, dapat dilakukan dengan cara
sebagai berikut:
- Untuk me replace karakter pada string dengan karakter baru dapat
menggunakan method replace(char karakterLama, char
karakterBaru).
- Untuk menghilangkan spasi di awal dan di akhir string dapat

menggunakan method trim().
k. Membuat array karakter dari string
Untuk membuat array karakter dari string yang telah ada, dapat
dilakukan du acara sebagai berikut:
- Menggunakan method toCharArray() yang diperoleh dari class
string. Implementasi dari method ini membutuhkan adanya
pendeklarasian variabel array char untuk menampung larik karakter
yang dihasilkan.
- Menggunakan method getChars(int Awal, int Akhir, char[]
arrayChar, int posAwal), dengan Awal merupakan posisi awal
karakter pada string, Akhir merupakan posisi akhir karakter pada
string, arrayChar merupakan variabel untuk menyimpan larik
karakter yang dihasilkan, dan posAwal merupakan indeks awal
untuk menyimpan karakter pertama.
35
3.3 Latihan
1. Array satu dimensi
a. Kode program
package com.prakpbo;
public class Main {


System.out.println("Nama\t: 32601900026\n");
int penjualan[] = {100, 120, 112, 105, 105, 122,108,

121, 122, 130, 115, 125};
int N = penjualan.length;
for (int i=0; i<N; i++){
System.out.println("Penjualan ke-"+i+" =
"+penjualan[i]);
}
}
}
36
b. Output program
Gambar 3. 1 Output latihan 1

c. Penjelasan
Program di atas adalah contoh program array satu dimensi.
Dimana kita membuat variabel yang menampung kumpulan data
penjualan. Kemudian kita lakukan perulangan dengan indeks kurang
dari panjang array. Kemudian kita tampilkan hasilnya di console.
Sehingga output program akan tampil seperti gambar di atas.
37
2. Array dua dimensi

a. Kode program
public class Main {


System.out.println("Nama\t: 32601900026\n");
double nilai[][]={{50, 60, 70}, {70, 75, 87},{89, 90,

90},{65, 76, 89},{65, 70, 80}};
int N = nilai.length;
char huruf;
for (int i=0;i<N;i++){
int M = nilai[i].length;
double totNilai=0;
for(int j=0;j<M;j++){
totNilai+= nilai[i][j];
}
double rata2 = totNilai/M;
if (rata2 > 80.0d)
{
huruf='A';
}
else if (rata2 > 70.0d){
huruf='B';
}
huruf='C';
}
huruf='D';
}
else
{
huruf='E';
38
}
System.out.println("Nilai mahasiswa ke-"+i+" =
"+rata2+" ("+huruf+")");
}
}
b. Output program

c. Penjelasan
Program di atas adalah contoh program array dua dimensi.
Dimana kita menapung data array dua dimensi pada variabel “nilai”.
Kemudian variabel “N” untuk menampung panjang array, dan
variabel “huruf” untuk menampung nilai huruf. Kemudian
dilakukan dua kali perulangan, perulangan pertama untuk indeks
baris, sedangkan perulangan kedua untuk indeks kolom. Lalu dicari
rata – rata nya dan dilakukan kondisi untuk nilai hurufnya. Sehingga
akan menghasilkan output seperti gambar di atas.
39
3. Mengetahui panjang String

a. Kode program
public class PanjangString {


System.out.println("NIM\t:32601900026\n");
String A = "Pemrograman Berorientasi Object";

String B = "Jurusan Teknik Informatika";
String C, D, E;
C = "Fakltas Teknologi Industri";
D = "Uneversitas Islam Sultan Agung";
E = "Semarang";
int nA = A.length();
int nB = B.length();
int nC = C.length();
System.out.println(A+"--> panjang string: " + nA);

System.out.println(B+"--> panjang string: " + nB);
System.out.println(C+"--> panjang string: " +
C.length());
System.out.println(D+"--> panjang string: " +
D.length());
System.out.println(E+"--> panjang string: " +
E.length());
}
}
40
b. Output program

c. Penjelasan
Program di atas adalah program untuk mengetahui panjang pada
suatu String menggunakan method .length(), yaitu itu menghitung
jumlah karakter pada String termasuk spasi yang ada di dalamnya.
Sehingga, program di atas akan menghasilkan output seperti gambar
di atas.
4. Mengetahui kesamaan antara dua String
a. Kode program
public class KesamaanString {

String A = "Laboratorium Komputasi dan Sistem Cerdas";

String B = "LABORATORIUM KOMPUTASI DAN SISTEM CERDAS";
String C = "Laboratorium Komputasi Sistem Cerdas";
String D = "LABORATORIUM KOMPUTASI SISTEM CERDAS";
String E = "Laboratorium Komputasi dan Sistem Cerdas";
boolean tes1, tes2, tes3;

tes1 = A.equals(B);
tes2 = (A==C);
41
tes3 = A.equals(E);
System.out.println("("+A+") == ("+B+") --> "+tes1);

System.out.println("("+A+") == ("+C+") --> "+tes2);
System.out.println("("+A+") == ("+E+") --> "+tes3);
System.out.println("("+B+") == ("+D+") -->
"+B.equals(D));
System.out.println("("+C+") == ("+E+") --> "+(C==E));
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk mengetahui kesamaan
pada String. Pada kode di atas kita menggunakan operator relasi
“==” dan method .equals() untuk mengetahui kesamaan pada
String. Perbedaannya adalah operator “==” membandingkan alamat
memori dari Stringnya, jika alamat memorinya berbeda meskipun
isi Stringnya sama, maka hasilnya adalah false. sedangka method
.equals() membandingkan isi Stringnya, meskipun alamat
memorinya berbeda tetapi isi Stringnya sama, makan hasilnya true.
Sehingga didapatkan output seperti gambar di atas.
42
5. Pembandingan karakter pada String

a. Kode program
public class KesamaanKarakterString {

String[] nama = {"Megawati Sukarno Putri",

"Susilo BambangYudoyono",
"Jusuf Kalla",
"Prabowo Subiyanto",
"Boediono","Wiranto"};
String sementara;
int N = nama.length;
System.out.println("Daftar nama sebelum diurutkan");

System.out.println((i+1)+". "+nama[i]);
}
for (int i=0; i<=N-2; i++){

for (int j=i+1; j<=N-1; j++){
if (nama[i].compareTo(nama[j])>0){
sementara = nama[i];
nama[i] = nama[j];
nama[j] = sementara;
}
}
}
System.out.println("Daftar nama setelah diurutkan");

43
System.out.println((i+1)+". "+nama[i]);
}
}
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk pembandingan karakter
pada dua String. Sintaks yang digunakan adalah .compareTo()
yang berfungsi untuk melakukan pembandingan karakter pada dua
String yang dimulai pada karakter indeks ke - 0, dimana jika
karakternya sama akan mengembalikan nilai 0 dan akan increment
satu karakter di depannya, jika lebih besar akan mengembalikan
nilai positif, dan jika lebih kecil akan mengembalikan nilai negatif.
Sehingga output yang dihasilkan akan seperti pada gambar di atas.
44
6. Mendapatkan karakter pada posisi tertentu

a. Kode program
import java.util.Random;
public class KarakterPadaPosisi {


Random rand = new Random();
System.out.println(A);
for (int i=0; i<=10; i++){
int ke = rand.nextInt(A.length());
System.out.println("Karakter ke-" + ke + " = " +
A.charAt(ke));
}
}
}
45
b. Output program

c. Penjelasan
Program di atas adalah program untuk mengambil karakter
String berdasarkan posisi secara random. Menggunakan class
bawaan java yaitu class Random dan menggunakan method bawaan
String yaitu .charAt(). Sehingga output yang dihasilkan seperti
pada gambar di atas.
7. Mendapat posisi karakter pada String
a. Kode program
public class PosisiPadaKarakter {

46
System.out.println("Karakter (s) terletak pada posisi

ke : "+A.indexOf('s'));
System.out.println("Karakter (a) terletak pada posisi
ke : "+A.indexOf('a'));
System.out.println("Karakter (v) terletak pada posisi
ke : "+A.indexOf('v'));
System.out.println("Setelah posisi ke 10, karakter (s)
terletak pada posisi ke : "+A.indexOf('s',10));
System.out.println("Setelah posisi ke 10, karakter (a)
terletak pada posisi ke : "+A.indexOf('a',10));
}
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk mengetahui posisi dari
karakter pada String. Yaitu menggunakan method bawaan String
.indekOf() untuk mengetahui di posisi ke berapa karakter tersebut
berada. Jika tidak diberi parameter awal pencarian, maka pencarian
posisi dimulai dari indeks ke – 0. Jika diberi parameter awal
pencarian, maka pencarian karakter dimulai dari indeks awal yang
dimasukan. Sehingga, output program akan seperti pada gambar di
atas.
47
8. Konversi huruf besar ke huruf kecil dan sebaliknya

a. Kode program
public class UpperDanLowerCase {

String A = "laboratorium Komputasi dan Sistem Cerdas";

String Besar = A.toUpperCase();
String Kecil = A.toLowerCase();
System.out.println("Kalimat awal : "+A);

System.out.println("Diubah ke huruf besar : "+Besar);
System.out.println("Diubah ke huruf kecil : "+Kecil);
}
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk melakukan konversi huruf
pada String dari huruf besar ke huruf kecil semua dan huruf kecil ke
huruf besar semua. Yaitu menggunakan method bawaan String
.toUpperCase() untuk mengkonversi huruf kecil ke huruf besar
dan .toLowerCase() untuk mengkonversi huruf besar ke huruf
kecil. Sehingga kan didapatkan output seperti pada gambar di atas.
48
9. Melakukan penyambungan antara dua String atau lebih

a. Kode program
public class MenyambungkanAntarDuaString {


String A;
String B;
String C;
A = "Laboratorium ";
B = "Komputasi ";
C = "Sistem Cerdas";
String Lab = A + B + "dan " + C;
System.out.println(B);
System.out.println(C);
System.out.println("============SETELAH
DIGABUNG============");
System.out.println(Lab);
}
}
49
b. Output program

c. Penjelasan
Program di atas adalah program yang berfungsi untuk
menyambungkan antara dua string atau lebih dengan menggunkan
operator +. Dalam program diatas terdapat sintaks String Lab = A
+ B + C; yang berfungsi untuk menyambungkan beberapa string
yang berada dalam program diatas. Sehingga, akan dihasilkan output
seperti pada gambar di atas.
10. Membuat String baru
a. Kode program
public class StringBaru {



String penggal1 = A.substring(10);
String penggal2 = A.substring(20);
String penggal3 = A.substring(10,30);
String penggal4 = A.substring(20,25);
System.out.println("=====Menmbuat String Baru=====");
50
System.out.println("Kalimat asli: "+A);

System.out.println("Pemenggalan mulai karakter ke-10 :
"+penggal1);
System.out.println("Pemenggalan mulai karakter ke-20 :
"+penggal2);
System.out.println("Pemenggalan mulai karakter ke-10
sampai ke-30 : "+penggal3);
System.out.println("Pemenggalan mulai karakter ke-20
sampai ke-25 : "+penggal4);
}
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk membuat string baru dari
string yang sudah pernah ada, yang dapat dilakukan dengan dua cara
yaitu, untuk membuat string baru dari string yang telah ada mulai
dari karakter awal string dapat menggunakan method
substring(int awal) dan untuk membuat string baru dari string
yang telah ada mulai dari karakter awal hingga karakter akhir string
dapat menggunakan method substring(int awal, int akhir).
Sehingga, akan menampilkan output seperti pada gambar di atas.
51
11. Modifikasi String

a. Kode program
public class ModifikasiString {

System.out.println("Nama\t: Nur Muhammad SYaifuddin");

String A = " Laboratorium Komputasi dan Sistem Cerdas

";
String B = A.replace("a", "A");

String C = A.replace("i", "u");
String D = A.trim();
System.out.println("Kalimat asli : "+A);

System.out.println("Replace a dengan A: "+B);
System.out.println("Replace i dengan u: "+C);
System.out.println("Hilangkan spasi awal & akhir: "+D);
}
}
b. Output program

52
c. Penjelasan
Program di atas adalah program untuk melakukan memodifikasi
string. Dengan cara me-replace karakter pada string dengan
karakter baru menggunkan method replace(char karakter
lama,char karakter baru) dan untuk menghilangkan spasi di

awal dan di akhir dapat menggunakan method trim().
12. Array karakter dari String
a. Kode program
import java.util.Arrays;
public class ArrayKarakterString {


String A = "Lab. KSC";

char[] karakter0 = A.toCharArray();
char[] karakter1 = new char[7];
A.getChars(2, 6, karakter1, 1);
System.out.println("kalimat Asli : "+A);

System.out.println("Per karakter : ");
for (int i=0; i<A.length(); i++){
System.out.println("Karakter ke-"+(i+1)+":
"+karakter0[i]);
}
System.out.println("Karakter ke-2 sampai ke-6 : ");
for (int i=1; i<karakter1.length; i++){
System.out.println("Karakter ke-"+i+":
"+karakter1[i]);
}
}
}
53
b. Output program

c. Penjelasan
Program di atas adalah program untuk membuat array karakter
dari string yang telah ada. Yaitu dapat dilakukan dengan dua cara
yaitu menggunakan method bawaan String yaitu toCharArray().
Implementasi dari method ini membutuhkan adanya pendeklarasian
variabel array char untuk menampung larik karakter yang
dihasilkan dan dengan menggunakan method getChars(int awal,
int akhir, char[] array Char, int pos Awal), Sehingga
akan menghasilkan output seperti pada gambar di atas.
54
3.4 Tugas
1. Buatlah program antrian FIFO!
Jawab:
a. Kode program
package tugas.prak.pbo;
import java.util.LinkedList;
import java.util.Queue;
public class Main {
static int antrian;
static void addUser(Queue<String> listAntrianUser,

String user){
antrian++;
listAntrianUser.add(user);
System.out.println(antrian + " orang sedang mengantri
= " + listAntrianUser);
static void removeAntrian(Queue<String>

listAntrianUser){
antrian--;
listAntrianUser.poll();
System.out.println("Tersisa antrian " + antrian + "
orang yaitu " + listAntrianUser);
}

Queue<String> listAntrianUser = new LinkedList<>();
addUser(listAntrianUser, "udin");
55
addUser(listAntrianUser, "eko");
addUser(listAntrianUser, "supar");
addUser(listAntrianUser, "jatmiko");
addUser(listAntrianUser, "wagiyo");
removeAntrian(listAntrianUser);
}
b. Output program
c. Penjelasan
Program di atas adalah program antrian FIFO(first in first out)
yang menggunakan interface queue. Jadi, kita harus instansiasi
terlebih dahulu interface queue. Baru setelah itu kita bisa
memanipulasi objeknya untuk menambah atau menghapus data.
Metode FIFO akan menambahkan dan meanghapus data dari depan.
56
2. Buatlah program antrian LIFO!

Jawab:
a. Kode program
package tugas.prak.pbo;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
public class Main {
static int antrian;
static void addUser(Queue<String> listAntrianUser,

String user){
antrian++;
listAntrianUser.add(user);
System.out.println(antrian + " orang sedang mengantri
= " + listAntrianUser);
static void removeAntrian(Queue<String>

listAntrianUser){
antrian--;
listAntrianUser.poll();
System.out.println("Tersisa antrian " + antrian + "
orang yaitu " + listAntrianUser);
}

57
Queue<String> listAntrianUser =
Collections.asLifoQueue(new ArrayDeque<>());
addUser(listAntrianUser, "udin");
addUser(listAntrianUser, "eko");
addUser(listAntrianUser, "supar");
addUser(listAntrianUser, "jatmiko");
addUser(listAntrianUser, "wagiyo");
}
b. Output program

58
c. Penjelasan
Program di atas adalah program antrian LIFO(last in first out)
yang menggunakan interface queue. Jadi, kita harus instansiasi
terlebih dahulu interface queue. Baru setelah itu kita bisa
memanipulasi objeknya untuk menambah atau menghapus data.
Metode LIFO akan menambahkan data dari belakang dan
meanghapus data dari depan.
3. Buatlah program searching dan sorting pada sebuah elemen array!
Jawab:
a. Kode program
public class Main {

int [] arrayAngka = {2,4,6,8,0,1,3,5,7,9};

boolean nilai = false;
printAngka(arrayAngka);

System.out.print("Masukan angka yang dicari indeksnya
0 - 8 = ");
int cari = input.nextInt();
for (int indeks = 0 ; indeks < arrayAngka.length ;
indeks ++){
if(cari == arrayAngka[indeks]){
System.out.println("nilai " + cari + " ada di indeks "
+ indeks);
nilai = true;
59
}
}
if (!nilai){
System.out.println("nilai " + cari + " tidak ada");
}
System.out.println("\ndata setelah diurutkan dari

terkecil");
Arrays.sort(arrayAngka);
System.out.println("\ndata setelah diurutkan dari

terbesar");
reverse(arrayAngka);
}
static void printAngka(int [] dataArray){
System.out.println("array = " +
Arrays.toString(dataArray));
}
static void reverse(int []dataArray){

int[] arrayBuffer =
Arrays.copyOf(dataArray,dataArray.length);
for (int i = 0 ; i < dataArray.length ; i ++){

dataArray[i] = arrayBuffer[(arrayBuffer.length - 1) -
i];
}
}
}
60
b. Output program
c. Penjelasan
Program di atas adalah program untuk mencari indeks dari
data yang ada di dalam elemen array yang telah disediakan. Jika
data yang dicari tidak ada, maka akan muncul pesan di console
“nilai yang dicari tidak ada”. Kemudian data akan diurutkan dari
yang erkecil dan terbesar seperti pada gambar di atas.
61
3.5 Kesimpulan
Pada BAB III ini dapat disimpulkan bahwa array merupakan tipe data
yang digunakan unutuk menampung kumpulan data yang disajikan secara
berurutan. Setiap elemen data memiliki tipe data yang sama. Array
menggunakan sekelompok lokasi memori yang berurutan dengan nama dan
tipe data yang berbeda. Besarnya alokasi memori yang akan digunakan
perlu diberikan sebelum variabel bertipe array tersebut digunakan. Apabila
alokasi memori tidak diberikan secara eksplisit, maka Java akan
memberikannya secara implisit. Kemudian, setiap elemen data disebut
dengan nama_variabel_array yang diikuti dengan indeks penomorannya.
Sedangkan String merupakan deretan karakter. Pada java, string
merupakan objek dari kelas String. Penulisan string dilakukan dengan
mengapit data menggunakan tanda petik (ganda). String dapat dioperasikan
dengan menggunakan beberapa operator atau method untuk beberapa
kepentingan yang berbeda.
BAB IV
KONSEP DASAR PEMROGRAMAN JAVA
4.1 Tujuan
1. Praktikan mampu memahami konsep dasar pemrograman java.
2. Praktikan dapat membedakan arti dan pemakaian kelas objek, referensi
objek, method, constructor, dan beberapa kata kunci dalam
pemrograman java.
4.2 Dasar Teori

4.2.1 Pengantar Pemrograman Berorientasi Objek
Secara umum, sebuah program komputer terdiri atas kode (proses logis
program) dan data yang dapat berupa variabel maupun konstanta. Kode dan
data tersebut kemudian diatur sehingga dapat bekerja sama untuk
menghasilkan program keluaran yang akan digunakan untuk menyelesaikan
sebuah permasalahan.
Pada model pemrograman prosedural, alur kerja program berorientasi
pada proses (process-oriented). Program merupakan gabungan dari data dan
kode dengan struktur program yang berupa urutan proses. Pendekatan
semacam ini memiliki kelemahan, yaitu akan menemui banyak kesulitan
ketika menangani kasus - kasus yang kompleks, membutuhkan ribuan baris
kode. Kondisi seperti itu akan menyulitkan programmer dalam melacak
kesalahan (debugging), menyisipkan modul baru dalam program, dan
sebagainya.
Pemrograman berorientasi objek hadir untuk menjadi solusi kelemahan
yang terdapat pada pendekatan prosedural biasa. Dalam pemrograman
berorientasi objek, pendekatan yang dilakukan adalah dengan memodelkan
sistem menjadi objek - objek. Objek dapat didefinisikan sebagai suatu
entitas yang memiliki data dan method. Dalam bab ini akan dibahas konsep
- konsep dasar yang merupakan inti dari pemrograman berorientasi objek.
62
63
Beberapa hal yang merupakan keuntungan dari konsep pemrograman

berorientasi objek adalah sebagai berikut :
- Objek – objek yang dibuat bersifat reusable, sehingga dapat digunakan
untuk program – progam lain.
- Struktur program lebih jelas, trackable, dan mudah untuk
dikembangkan.
- Lebih natural dan alami, karena pendekatan berorientasi objek lebih
dekat dengan realitas yang ada di sekitar kita.
4.2.2 Apa Itu Kelas?
Kelas merupakan inti dari pemrograman Java karena Java adalah Bahasa
pemrograman yang mendukung dan mengimplementasikan konsep
pemrograman berorientasi objek sepenuhnya. Setiap program java
merupakan kelas, sehingga setiap konsep atau kasus pemrograman yang
akan diimplementasikan dengan java harus dibungkus ke dalam sebuah
kelas.
Kelas dapat didefinisikan sebagai cetak biru (blueprint) atau prototype/
kerangka yang mendefinisikan variabel - variabel (data) dan method -
method (perilaku) umum dari sebuah objek tertentu. Sebagai contoh, kita
ambil objek Mahasiswa. Mahasiswa memiliki data seperti nim, nama,
alamat, IPK, jenis kelamin, jurusan, dan sebagainya. Selain data atau ciri-
ciri fisik tersebut, mahasiswa juga memiliki perilaku - perilaku spesifik yang
dapat membedakan antara mahasiswa yang satu dengan yang lainnya,
seperti cara presentasi, cara belajar, cara mengerjakan tugas dan sebagainya.
Dalam dunia pemrograman, sebenarnya kelas tidak jauh berbeda dengan
tipe data sederhana seperti integer, char, boolean, dan sebagainya.
Perbedaannya, tipe data sederhana digunakan untuk mendeklarasikan
variabel ‘normal’, sedangkan kelas digunakan untuk mendeklarasikan
sebuah variabel yang berupa objek. Variabel yang berupa objek ini sering
disebut dengan referensi objek (object reference).
64
4.2.3 Mendefinisikan Kelas

Dalam Java, kelas didefinisikan dengan menggunakan kata kunci class.
Berikut ini bentuk umum yang digunakan untuk mendefinisikan sebuah
kelas.
Class NamaKelas{
Tipe data1;
Tipe data2;
…
Tipe dataN;
Tipe method1(daftar-parameter){
//kode untuk method1
}
Tipe method2(daftar-parameter){
}
…
Tipe method(daftar-parameter){
//kode untuk method
}
}
Data atau variabel yang didefinisikan di dalam sebuah kelas sering
disebut dengan instance variable yang selanjutnya akan diakses melalui
method - method yang ada. Data dan method yang tergabung dalam suatu
kelas sering dinamakan sebagai class members.
65
4.2.4 Contoh Kasus Sederhana

Pada bagian ini akan diberikan pembahasan terkait dengan pembuatan
sebuah kelas sederhana. Disini kita akan membuat kelas Karyawan, yang
memiliki data - data : ID, nama, divisi, dan gaji. Untuk saat ini, belum
ditambahkan method ke dalam kelas tersebut. Method akan dibahas terpisah
pada bagian selanjutnya dalam bab ini. Perhatikan kode berikut :
public class Karyawan{
string id, nama, divisi;
double haji;
}
Melalui kode di atas, berarti kita telah mendefinisikan sebuah tipe data
baru dengan nama Karyawan. Penting untuk diingat bahwa pendefinisian
kelas hanya akan membuat sebuah pola atau template, bukan membuat
objek. Objek aktual dari kelas tersebut harus dibuat sendiri melalui kode
berikut:
Karyawan aurel = new Karyawan();
Di sini, Karyawan adalah kelas dan Aurel adalah objek atau instance
dari kelas Karyawan. Melalui objek Aurel, kita dapat mengakses dan
memanipulasi data - data yang terdapat pada kelas Karyawan, dengan cara
menggunakan operator titik (.), seperti yang tampak pada kode di bawah ini.
aurel.id = “K001”;
aurel.nama = “Aurel Dian”;
aurel.divisi = “Marketing”;
aurel.gaji = “2500000”;
kode tersebut digunakan untuk mengisikan nilai ke dalam data id, nama,
divisi, dan gaji yang dimiliki oleh objek Aurel masing - masing dengan nilai
“K001”, “Aurel Dian”, “Marketing” dan 2500000.
Perlu diketahui bahwa setiap objek atau instance dari suatu kelas akan
memiliki salinan data sendiri - sendiri. Ini artinya, antara objek yang satu
dengan yang lainnya, nilai data – datanya bisa berbeda.
66
4.2.5 Instansiasi Objek

Untuk membuat objek baru dari tipe kelas yang telah didefinisikan,
secara eksplisit kita perlu melakukan dua tahap. Pertama, kita perlu
mendeklarasikan variabel yang digunakan sebagai referensi ke objek dari
kelas bersangkutan. Kedua, kita perlu menginstansiasi kelas dengan
menggunakan operator new dan memasukan instance-nya ke dalam variabel
referensi yang baru saja dideklarasikan. Operator new secara dinamis akan
mengalokasikan ruang memori untuk menyimpan suatu objek tertentu dan
mengembalikan nilai berupa referensi ke objek bersangkutan.
Berikut ini kode yang mengilustrasikan dua tahapan proses yang
dimaksud di atas. Untuk mempermudah pembahasan, di sini masih
menggunakan kelas karyawan yang telah dibuat sebelumnya.
// mendeklarasikan variabel Aurel bertipe Karywan
Karyawan aurel;
// instansiasi & memasukkan referensi ke variabel Aurel
aurel = new Karyawan();
pada praktiknya, dua tahap di atas biasanya ditulis dala satu baris, seperti
berikut :
Karyawan arena = new Karyawan();
4.2.6 Mengisi Nilai Pada Referensi Objek
Terdapat satu buah catatan penting yang perlu diperhatikan pada saat
kita memasukan nilai pada sebuah variabel referensi. Sebelumnya,
perhatikan terlebih dahulu kode berikut :
Karyawan Karyawan001, karyawan002;
Karyawan001 = new Karyawan();
Karyawan002 = Karyawan001;
Baris pertama digunakan untuk mendeklarasikan variabel referensi ke
objek Karyawan dengan nama karyawan001 dan karyawan002. Baris kedua
berfungsi untuk membuat objek Karyawan dan menyimpan referensinya ke
dalam variabel karyawan001. Dan baris ketiga digunakan memasukan
karyawan001 ke dalam karyawan002. Ini artinya, variabel karyawan002
berperan sebagai referensi ke objek yang sedang ditunjuk oleh
67
karyawan001. Dengan demikian, variabel karyawan001 dan karyawan002

masing-masing menunjuk ke objek Karyawan yang sama. Maka dari itu,
setiap perubahan yang terjadi pada objek yang bersangkutan melalui
karyawan001 akan berpengaruh juga pada objek yang ditunjuk oleh
karyawan002, karena keduanya sebenarnya adalah objek yang sama, begitu
juga sebaliknya.
4.2.7 Method
Dalam Java, kelas berisi kumpulan data dan method, yang selanjutnya
akan saling bekerja sama dalam melakukan tugas - tugas spesifik tertentu
sesuai dengan perilaku objek yang dimodelkan.
Berikut ini bentuk umum dari pembuatan method di dalam kelas.
Tipe namaMethod(daftar-parameter){
//kode yang akan dituliskan
}
Pada bentuk umum di atas, tipe adalah tipe data yang akan dikembalikan
oleh method. Sebagai catatan, dalam Java method terbagi menjadi dua, void
dan non-void. Method void adalah method yang tidak mengembalikan nilai,
sedangkan method non-void adalah method yang mengembalikan nilai. Jika
method yang kita buat ditujukan untuk mengembalikan suatu nilai tertentu,
maka di dalam method tersebut harus terdapat statement return, yang diikuti
dengan nilai yang akan dikembalikan, seperti berikut :
return nilaiKembalian;
nilaiKembalian dapat berupa konstanta maupun variabel, yang
digunakan untuk menandakan nilai yang akan dikembalikan oleh method
4.2.8 Mendefinisikan Method
Setelah mengetahui bentuk umum yang digunakan, di sini kita akan
langsung mendefinisikan sebuah contoh method ke dalam kelas yang
sebelumnya kita buat, yaitu kelas LapanganFutsal. Kita akan menambahkan
method cetakPengelola() untuk mencetak nama pengelola dari objek
LapanganFutsal. Method ini merupakan method yang tidak mengembalikan
nilai. maka dari itu, kita harus mengganti tipe kembalian dengan kata kunci
void. Berikut ini kode program yang dimaksud.
68
Pemanggilan method dalam suatu kelas dilakukan dengan menuliskan

objek pemiliknya dan diikuti oleh operator titik (.) beserta nama method
yang akan dieksekusi. Berikut ini contoh kode yang digunakan untuk
memanggil method cekData() yang telah dideklarasikan di dalam kelas
Karyawan.
//memanggil method cetakData
Karyawan001.cetakData();
Hasil yang diberikan oleh method cetakData() akan menyesuaikan

dengan data - data yang tersimpan pada objek di mana method cetakData()
tersebut dideklarasikan.
4.2.9 Pengembalian Nilai di Dalam Method
Method yang mengembalikan nilai akan menghasilkan nilai ketika
method ini dipanggil. Untuk mengembalikan nilai harus menggunakan
keyword return. Yang perlu diperhatihan tipe data yang dikembalikan harus
sama dengan tipe data nilai yang dikembalikan. Cara kerja method non-void
sama seperti method void.
4.2.10 Method Berparameter
Pada kenyataannya sebagian besar method yang ditulis dalam program
memiliki satu atau beberapa parameter. Dengan adanya parameter, sebuah
method dapat bersifat dinamis dan general. Artinya, method tersebut dapat
mengembalikan nilai yang beragam sesuai dengan nilai parameter yang
dilewatkannya. Coba perhatikan terlebih dahulu pendefinisian method tanpa
parameter berikut ini.
double volumeTabung() {
return (3.14 * 7 * 7 * 10);
}
Secara sintaks, method di atas benar dan akan mengembalikan nilai
1538.5. Namun, dilihat dari sisi desain program, method di atas dikatakan
tidak fleksibel atau tidak bersifat general. Pasalnya, method tersebut hanya
dapat digunakan untuk tabung yang memiliki jari-jari alas 7 dan tinggi 10.
Bagaimana jika terdapat tabung dengan jari-jari alas 10 dan tinggi 12?
Method di atas tidak dapat kita gunakan untuk menghitung volume dari
69
tabung dengan ukuran tersebut. Untuk mengatasi hal semacam ini, maka
Java mengizinkan kita untuk menempatkan parameter di dalam sebuah
method agar method di atas dapat digunakan untuk segala ukuran tabung.
Berikut ini kode yang seharusnya dituliskan untuk mendefinisikan method
di atas.
double volumeTabung(int jejari, int tinggi) {
return (3.14 * jejari * jejari * tinggi);
}
Melalui cara seperti ini, kita dapat memasukan nilai berapapun ke dalam
method tersebut. Sebagai contoh, perhatikan kode berikut :
int volume1, volume2, volume3;
//menghasilkan nilai 1538.6
volume1 = volumeTabung(7, 10);
//menghasilkan nilai 3768
//menghasilkan nilai 4019.2
Seperti kita lihat, volume1 merupakan variabel penampung untuk
perhitungan volume tabung dengan jari - jari alas 7 dan tinggi 10, volume2
dengan jari - jari alas 10 dan tinggi 12, dan volume3 dengan jari - jari alas 8
dan tinggi 20, padahal method yang didefinisikan hanya satu (bukan tiga
buah method).
4.2.11 Constructor
Constructor adalah method khusus yang didefinisikan di dalam kelas
dan akan dipanggil secara otomatis tiap kali terjadi instansiasi objek.
Constructor itu sendiri berfungsi untuk melakukan inisialisasi nilai terhadap
data - data yang terdapat pada kelas yang bersangkutan. Jika kita tidak
mendefinisikan constructor pada kelas yang kita buat, maka secara otomatis
Java akan membuatkannya untuk kita. Constructor semacam ini dinamakan
dengan default constructor. Default constructor akan menginisialisasi
semua data yang ada dengan nilai nol. Sama halnya seperti method,
constructor juga dapat memiliki parameter dan juga dapat di-overload.
70
4.2.12 Kata Kunci This

Pada kasus - kasus tertentu, terkadang method perlu mengacu ke objek
yang memilikinya. Untuk mengizinkan hal ini, Java menyediakan kata
kunci this. this sebenarnya merupakan referensi ke objek yang sedang aktif.
this digunakan di dalam method atau constructor untuk mewakili nama
kelas bersangkutan. Sebagai contoh, perhatikan kode berikut ini.
//constructor kelas Karyawan
Karyawan (String kode, String Nama, String Div, double Gaji)
{
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;}
Sebenarnya kode di atas juga dapat ditulis menggunakan referensi this,
seperti berikut :
Karyawan(String kode, String Nama, String Div, double Gaji){
this.ID = kode;
this.nama = Nama;
this.divisi = Div;
this.gaji = Gaji;
}
Untuk kasus di atas, kehadiran kata kunci this memang justru akan
sedikit merepotkan dan bisa dikatakan tidak perlu. Meskipun demikian,
dalam konteks lain, penggunaan kata kunci this ini justru diharuskan.
Seperti yang telah kita ketahui bersama, Java tidak mengizinkan kita untuk
mendeklarasikan variabel dengan nama sama di dalam satu blok tertentu. Di
sisi lain, Java memperbolehkan kita untuk mendeklarasikan nama parameter
yang sama dengan nama data yang terdapat di dalam kelas dengan resiko
variabel yang digunakan sebagai parameter akan menimpa nama data yang
terdapat di dalam kelas bersangkutan. Untuk menghindari proses
penimpaan variabel ini, maka kita harus menggunakan kata kunci this,
seperti yang tampak pada kode berikut :
71

Karyawan(String ID, String nama, String divisi, double gaji){
this.ID = ID;
this.nama = nama;
this.divisi = divisi;
this.gaji = gaji;
}
Di sini, this.ID, this.nama, this.divisi, dan this.gaji menunjuk
ke data ID, nama, divisi, dan gaji yang terdapat dalam kelas Karyawan;
bukan parameter yang terdapat pada constructor.
4.2.13 Melakukan Overload Terhadap Method
Kita dapat mendefinisikan lebih dari satu method dengan nama yang
sama dalam sebuah kelas, dengan syarat parameter yang terdapat pada
method - method tersebut berbeda. Parameter dalam suatu method dikatakan
berbeda dari method yang lainnya apabila :
- Jumlahnya berbeda, meskipun tipe datanya sama.
- Tipe datanya berbeda, meskipun jumlahnya sama.
- Jumlah dan tipe data berbeda.
Proses pendefinisian method dengan nama sama ini disebut dengan
overload. Perhatikan dua buah contoh method berikut ini :
int tambah(int a, int b){
return a + b;
}
double tambah(double a, double b){
return a + b;
}
Kode di atas legal untuk didefinisikan di dalam sebuah kelas. Pada
contoh tersebut, kita mendefinisikan dua buah method dengan nama yang
sama, tapi parameternya berbeda.
72
4.2.14 Overload Pada Constructor

Selain pada method, proses overload juga dapat diaplikasikan ke dalam
constructor suatu kelas. Hal ini disebabkan karena sebenarnya constructor
juga adalah sebuah method yang mengembalikan tipe kelas (dirinya
sendiri). Pada kenyataannya, suatu kelas pada umumnya justru memiliki
lebih dari satu constructor.
4.2.15 Menentukan Tingkat Akses Data dan Method
Seperti yang telah dibahas pada bab - bab sebelumnya, dalam
pembungkusan (encapsulation), sebenarnya kita menggabungkan data dan
kode (method) menjadi satu. Pada situasi semacam ini, kita dapat
menentukan tingkat akses dari data dan method tersebut menggunakan kata
kunci private, public, maupun protected.
Dalam pemrograman berorientasi objek, data pada umumnya didesain
untuk bersifat private atau hanya dapat diakses oleh kelas yang memilikinya
saja. Pengaksesan data dari bagian luar hanya dapat dilakukan melalui
method - method yang ada. Ini artinya, method berperan sebagai antarmuka
(interface). Maka dari itu, method pada umumnya bersifat public. Meskipun
demikian, apabila kita ingin mendefinisikan method yang hanya dapat
diakses oleh kelas itu sendiri, maka kita pun harus mendeklarasikannya
dengan kata kunci private. Dan jika kita menginginkan data dan method
yang kita definisikan di dalam kelas hanya dapat diakses oleh kelas - kelas
turunan dari kelas yang bersangkutan, maka data dan method tersebut harus
dideklarasikan dengan kata kunci protected.
Secara umum, pembungkusan data dan method dari suatu kelas dapat
dituliskan seperti berikut :
class NamaKelas {
tingkat-akses data1;
tingkat-akses data2;
….
tingkat-akses dataN;
tingkat-akses method1(daftar-parameter) {
73
}
tingkat-akses methodN(daftar-parameter) {
//kode untuk methodN
}
….
tingkat-akses methodN(daftar-parameter) {
//kode untuk methodN
}
}
Dalam hal ini tingkat akses adalah salah satu dari kata kunci private,
public, maupun protected. Apabila kita tidak mencantumkan salah satu kata
kunci tersebut pada saat mendeklarasikan data maupun method, maka secara
default Java akan menganggapnya sebagai data atau method dengan sifat
default.
Berikut ini contoh program yang akan menunjukkan pengaruh dari
tingkat akses public dan private di dalam suatu kelas. Tingkat akses
protected akan dijelaskan lebih lanjut pada bab lain di modul ini, yaitu yang
membahas mengenai pewarisan sifat terhadap kelas turunan (inheritance).
4.2.16 Kata Kunci Static
Secara normal, suatu anggota kelas (baik data maupun method) hanya
dapat diakses melalui objek referensinya. Meskipun demikian, Java
mengizinkan kita untuk mengakses suatu anggota kelas tanpa harus
membuat objek atau instance-nya terlebih dahulu. Untuk membuat anggota
kelas semacam ini, kita harus menjadikan data atau method tersebut dengan
sifat statis, yaitu dengan membubuhkan kata kunci static pada awal
deklarasi. Berikut ini contoh pendeklarasian sebuah data dan method statis
dalam suatu kelas.
class ContohDeklarasiStatik {
//mendeklarasikan data statis
static int dataStatis1;
….
//mendeklarasikan method statis
Static methodStatis1() {….}
….
74
}
Melalui cara ini, variabel dataStatis1 dan methodStatis1() dapat
dipanggil secara langsung tanpa harus membuat objek atau instance dari
kelas ContohDeklarasiStatik terlebih dahulu. Sama halnya seperti data
dan method normal (non-statis), data dan method statis juga dapat dipanggil
melalui operator titik (.). Perbedaannya, pemanggilan data atau method
statis tidak perlu menggunakan objek referensi, melainkan nama kelas yang
memilikinya.
Bentuk umum dari pengaksesan data dan method statis dapat dituliskan
sebagai berikut:
NamaKelas.data
Atau
NamaKelas.method()
4.2.17 Kata Kunci Final
Dalam java, kata kunci final dapat user gunakan untuk mendeklarasikan
sebuah konstanta. Jika user ingin menggunakan kata kunci final untuk
mendeklarasikan suatu variabel sebagai konstanta, maka user perlu
mengisikan nilai ke dalam variabel tersebut. nilai tersebut akan bersifat tetap
atau tidak dapat diubah selama eksekusi program berlangsung. Berikut ini
bentuk umum dari pendeklarasikan sebuah konstanta di dalam Java.
tingkat-akses final tipe-data nama-konstanta = nilai;
Seperti halnya pada bahasa C/C++, dalam Java, konstanta pada
umumnya ditulis dengan huruf kapital. Berikut ini beberapa contoh
pendeklarasian konstanta.
final double PHI = 3.14;
private final int ERROR = -1;
private final String NEGARA = “INDONESIA”;
4.2.18 Kelas di Dalam Kelas (inner class)
Java mengizinkan user untuk mendefinisikan suatu kelas di dalam kelas
lainnya. Kelas semacam ini dinamakan sebagai inner class (kelas bagain
dalam). Inner class dapat mengakses data dan method dari kelas yang berada
di bagian luarnya, meskipun data dan method tersebut bersifat private.
75
4.3 Latihan
1. Instansiasi objek dan pengaksesan data pada objek
a. Kode program
// class Karyawan
public class Karyawan {
String ID, nama, divisi;

double gaji;
}
// class Main atau class pemanggil
public class Main {

Karyawan aurel = new Karyawan();
aurel.ID = "K001";
aurel.divisi = "Marketing";
aurel.nama = "Aurel Dian";
aurel.gaji = 2500000;
System.out.println("Data Karyawan :");

System.out.println("ID\t: "+aurel.ID);
System.out.println("Nama\t: "+aurel.nama);
System.out.println("Divisi\t: "+aurel.divisi);
System.out.println("Gaji\t: "+aurel.gaji);
}
}
76
b. Output program

c. Penjelasan
Program di atas adalah contoh program pembuatan class dan
instansiasi objeknya. Dimana pada class Karyawan memiliki
properti ID, nama, divisi, dan gaji. Untuk mengakses properti
tersebut kita menggunakan operator titik (.) setelah objek yang kita
buat, kemudian diinisialisasi sesuai tipe datanya. Sehingga, akan
menghasilkan output seperti pada gambar di atas.
2. Instansiasi lebih dari satu objek
a. Kode program
// class Karyawan

double gaji;
// class Main atau pemanggil

public class Main {

77

Karyawan Aurel = new Karyawan();
Karyawan Dhennis = new Karyawan();
Aurel.ID = "K001";
Aurel.nama = "Marketing";
Aurel.divisi = "Aurel Dian";
Aurel.gaji = 2500000;
Dhennis.ID = "K002";
Dhennis.nama = "Keuangan";
Dhennis.divisi = "Muhamad Dhennis";
Dhennis.gaji = 2250000;
System.out.println("Data Karyawan Pertama :");

System.out.println("ID\t: " + Aurel.ID);
System.out.println("Nama\t: " + Aurel.nama);
System.out.println("Divisi\t: " + Aurel.divisi);
System.out.println("Gaji\t: " + Aurel.gaji);
System.out.println("Data Karyawan Kedua :");

System.out.println("\nID\t: " + Dhennis.ID);
System.out.println("Nama\t: " + Dhennis.nama);
System.out.println("Divisi\t: " + Dhennis.divisi);
System.out.println("Gaji\t: " + Dhennis.gaji);
}
78
b. Output program

c. Penjelasan
Program di atas sama halnya sengan program latihan 1, tetapi
yang membedakan pada program di atas kita menginstansiasi 2
objek. terlihat pada output di atas data yang dimasukan tidak saling
menimpa, karena setiap objek memiliki alokasi memorinya sendiri.
3. Referensi objek
a. Kode program
// class Karyawan

double gaji;
}
public class Main {

79

Karyawan Karyawan001 = new Karyawan();

Karyawan Karyawan002 = Karyawan001;
Karyawan001.nama = "Mischella";
Karyawan001.divisi = "HRD";
System.out.println("Data Karyawan001 :");

System.out.println("Nama\t: " + Karyawan001.nama);
System.out.println("Divisi\t: " + Karyawan001.divisi);
System.out.println(" ");
System.out.println("Data Karyawan002 :");
System.out.println("Nama\t: " + Karyawan002.nama);
System.out.println("Divisi\t: " + Karyawan002.divisi);
}
}
b. Output program

80
c. Penjelasan
Pada program di atas tampak bahwa kita hanya memasukan nilai
untuk objek karyawan001, namun pada saat kita mencetak data pada
karyawan002, hasil yang diberikan adalah sama seperti yang
dihasilkan oleh karyawan001. Ini disebabkan karena karyawan001
dan karyawan002 sebenarnya menunjuk ke objek Karyawan yang
sama. Saat dieksekusi, program tersebut di atas akan memberikan
hasil yang sama.
Sebagai catatan penting, meskipun keduanya menunjuk ke objek
yang sama, akan tetapi tidak terdapat hubungan antara variabel
karyawan001 dan karyawan002. Artinya, kita bisa saja melepas
salah satu variabel tersebut untuk menunjuk ke objek lain, tanpa
berpengaruh terhadap variabel lainnya.
4. Referensi Objek (2)
a. Kode program
// class Karyawan

double gaji;

public class Main {

81
Karyawan karyawan001 = new Karyawan();

Karyawan karyawan002 = karyawan001;
karyawan001.nama = "Mischella";
karyawan001.divisi = "HRD";
System.out.println("Data Karyawan001");
System.out.println("Nama\t: " + karyawan001.nama);
System.out.println("Divisi\t: " + karyawan001.divisi);
karyawan002 = new Karyawan();

karyawan002.nama="Yahya Al-Mahandis";
karyawan002.divisi="Produksi";
System.out.println("Setelah Perubahan Referensi");
}
82
b. Output program

c. Penjelasan
Program di atas merupakan program pengaruh referensi objek.
Pada program tersebut terdapat class Karyawan yang berisi variabel
ID, nama, divisi yang bertipe data string dan variabel gaji yang
bertipe data double. Lalu program diinstansiasi 2 objek referensi
yang mengacu pada 1 objek Karyawan. Setelah itu program akan
mengisi data objek Karyawan melalui objek referensi. Setelah itu
program akan memindahkan objek referensi ke 2 untuk mengacu
pada objek baru. Kemudian program akan mencetak data objek
setelah di referensi
Dari hasil tersebut dapat terlihat bahwa pada saat variabel
karyawan002 dipindahkan untuk menunjuk ke objek lain (terjadi
perubahan referensi objek), data - data karyawan002 yang dicetak
akan berbeda dengan data - data dari karyawan001.
83
5. Method void
a. Kode program
// class Karyawan

double gaji;
void cetakData() {
System.out.println("Data Karyawan ");
System.out.println("ID\t: " + ID);
System.out.println("Nama\t: " + nama);
System.out.println("Divisi\t: " + divisi);
System.out.println("Gaji\t: " + gaji);
}
}
public class Main {

Karyawan001.ID = "K001";
Karyawan001.nama = "Agus Ramadhan";
Karyawan001.divisi = "Keuangan";
Karyawan001.gaji = 1850000;
84
}
b. Output program

c. Penjelasan
Program di atas adalah program untuk memanggil method. Pada
program tersebut terdapat class Karyawan yang berisi variabel ID,
nama, divisi, yang bertipe data String dan variabel gaji bertipe data
double. Pada class Main program akan membuat objek
karyawan001. Lalu program akan mengisi data kedalam objek
karyawan001 seperti ID, nama, divisi, dan gaji. Setelah itu program
akan menjalankan method void yaitu cetakData(); yang ada pada
class Karyawan. Void berarti method tersebut tidak memiliki nilai
kembalian. Sehingga akan menampilkan output seperti pada gambar
di atas.
6. Method non-void
a. Kode program
// class Karyawan

double gaji;
85
void cetakData() {
}
double hitungSumbanganZakat() {
double zakat = gaji * 0.025;
return zakat;
}
}

public class Main {

Karyawan001.ID = "K001";
Karyawan001.nama = "Agus Ramadhan";
Karyawan001.divisi = "Keuangan";
Karyawan001.gaji = 1850000;
System.out.println("Sumbangan Zakat\t: " +

Karyawan001.hitungSumbanganZakat());
}
}
86
b. Output program

c. Penjelasan
Program di atas adalah program untuk memanggil method. Pada
program tersebut terdapat class Karyawan yang berisi method void
cetakData() dan juga method non-void hitungSumbanganZakat().
Pada class Main, kita buat objek baru bernama karyawan001. Lalu
program akan mengisi data kedalam objek karyawan001 seperti ID,
nama, divisi, dan gaji. Setelah itu program akan memanggil method
void cetakData() yang ada pada class Karyawan. Pada class
Karyawan, method void cetakData() akan menampilkan data
karyawan seperti ID, nama, divisi, dan juga gaji. Sedangkan pada
method hitungSumbanganZakat() program akan menghitung zakat
berdasarkan nilai kembaliannya yang bertipe data double, yaitu
zakat = gaji * 0,025. Sehingga, akan menampilkan output seperti
87
7. Method berparameter
a. Kode program
// class Karyawan

double gaji;
void cetakData() {
}
return zakat;
}
void isiData(String kode, String Nama, String Div,
double Gaji) {
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;
}
}

public class Main {

88


karyawan001.isiData("k001", "Rommy", "Marketing",
2350000);
karyawan001.cetakData();
}
b. Output program

c. Penjelasan
Pada program di atas kita membuat method bernama
isiData(String kode, String Nama, String Div, String
Gaji) yang memiliki 4 parameter. Dengan adanya parameter ini
kita bisa menginisialisasi propertinya secara lebih singkat, tanpa
perlu mengakses propertinya satu – satu. Setelah memanggil method
isiData(), kita panggil method cetakData() untuk menampilkan
hasilnya. Sehingga, akan menghasilkan output seperti pada gambar
di atas.
89
8. Constructor
a. Kode program
// class Karyawan

double gaji;
Karyawan() {
ID = "k001";
nama = "Budi";
divisi = "Produksi";
gaji = 1750000;
}
void cetakData() {
}
return zakat;
}
double Gaji) {
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;
}
}
90

public class Main {

}
b. Output program

c. Penjelasan
Program di atas adalah program yang menerapkan penggunaan
constructor. Dimana di dalam blok state constructor, kita lakukan
inisialisasi pada semua propertinya. Sehingga, saat membuat objek,
blok state di dalam constructor akan dieksekusi. Kemudian kita
langsung panggil method cetakData() untuk menampilkan
hasilnya. Sehingga, outputnya akan seperti pada gambar di atas.
91
9. Constructor dinamis
a. Kode program
// class Karyawan

double gaji;
Karyawan(String kode, String Nama, String Div, double

Gaji) {
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;
}
void cetakData() {
}
return zakat;
}
double Gaji) {
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;
}
}
92

public class Main {

Karyawan karyawan001 = new Karyawan("k005", "Bella",

"HRD", 2150000);
}
}
b. Output program

c. Penjelasan
Program di atas adalah contoh penerapan constructor dinamis.
Dimana saat pembuatan constructor kita tambahkan paremeter
sesuai dengan jumlah propertinya, kemudian masing – masing
properti diinisialisasi dengan parameternya. Ketika membuat objek,
kita harus menginputkan parameternya sesuai dengan jenis dan
banyaknya parameter yang kita buat di class Karyawan. Lalu kita
tampilkan datanya dengan method cetakData(). Sehingga, akan
93
10. Overload method

a. Kode program
// class Pembagian
public class Pembagian {
int bagi(int a, int b) {

return a / b;
}
double bagi(double a, double b) {

return a / b;
}
// class Caller atau pemanggil

public class Caller {

Pembagian b = new Pembagian();

int x = b.bagi(10, 4);
double y = b.bagi(10.0, 4.0);
System.out.println("Hasil bagi tipe int\t= " + x);

System.out.println("Hasil bagi tipe double\t= " + y);
}
}
94
b. Output program

c. Penjelasan
Program di atas adalah program yang menerapkan overload
method. Pada class Pembagian, saya membuat dua method dengan
nama yang sama, tetapi tipe kembalian dan tipe parameternya
berbeda. saat dipanggil di class Caller, saya bisa memasukan 2
inputan dengan tipe data integer atau double. Sehingga, akan
11. Overload constructor
a. Kode program
// class Karyawan

double gaji;
Karyawan(String ID, String nama) {

this.ID = ID;
this.nama = nama;
}
Karyawan(String ID, String nama, String divisi, double

gaji) {
this.ID = ID;
this.nama = nama;
this.divisi = divisi;
95
this.gaji = gaji;
}
void cetakData() {
}
return zakat;
}
double Gaji) {
ID = kode;
nama = Nama;
divisi = Div;
gaji = Gaji;
}
}

public class Main {

Karyawan karyawan001 = new Karyawan("k006", "Zaky");

96
Karyawan karyawan002 = new Karyawan("k007", "Deva",

"Keuangan", 2250000);
}
b. Output program

c. Penjelasan
Program di atas adalah contoh penerapan overload constructor.
Konsepnya hampir mirip dengan overload method, yang
membedakan adalah paremeter diinputkan saat pembuatan objek.
sehingga, akan menghasilkan output seperti pada gambar di atas.
97
12. Acces modifier

a. Kode program
// class Mahasiswa
public class Mahasiswa {
public String nama, nim;

private double ipk;
public void setIpk(double ipk){

this.ipk = ipk;
}
public double getIpk(){

return this.ipk;
}


Mahasiswa udin = new Mahasiswa();
udin.nim = "32601900026";
udin.nama = "Nur Muhammad Syaifuddin";
//Error karena hak aksesnya private

//udin.ipk = 3.80;
98
udin.setIpk(3.81);
System.out.println("Nama\t: " + udin.nama);
System.out.println("NIM\t: " + udin.nim);
System.out.println("IPK\t: " + udin.getIpk());
}
}
b. Output program

c. Penjelasan
Program di atas adalah contoh program yang menggunakan hak
akses pada properti dan methodnya. Jika hak aksesnya public, maka
bisa diakses di semua class dan package. Jika hak aksesnya
protected, maka bisa di akses di semua class yang packagenya sama
dan turunan classnya di package yang berbeda. Jika hak aksesnya
default, maka bisa diakses di semua class yang packagenya sama.
Jika hak aksesnya private, maka hanya bisa diakses di classnya itu
sendiri. Sehingga output yang dihasilkan akan seperti pada gambar
di atas.
99
13. Kata kunci static

a. Kode program
public class ContohStatic {
static int dataA = 10, dataB = 7, dataC;
static void test(){

dataC = dataA + dataB;
System.out.println("dataA + dataB = " + dataC);

}

test();
}
}
b. Output program

c. Penjelasan
Program di atas adalah contoh program yang menerapkan kata
kunci static pada properti dan methodnya. Kata kunci static
dituliskan sesudah acces modifiernya dan sebelum tipe datanya.
Static berfungsi agar kita dapat mengakses properti atau method
secara langsung tanpa harus menginstansiasi objeknya. Sehingga,
bisa kita lihat hasil output dari program di atas.
100
14. Pemanggilan properti dan method static

a. Kode program
// class RobotStatic
public class RobotStatic {
static String nama;

static String asalNegara;
static void test() {

System.out.println("Hello..");
System.out.println("Saya adalah robot " + nama);
System.out.println("Saya berasal dari " + asalNegara);
}
}


RobotStatic.nama = "GATOTKACA";
RobotStatic.asalNegara = "Indonesia";
RobotStatic.test();
}
}
101
b. Output program

c. Penjelasan
Program di atas diperlihatkan bagaimana cara memanggil
properti dan method static. Yaitu kita tidak perlu melakukan
instansiasi objek untuk mengaksesnya. Cukup tuliskan nama
kelasnya kemudian diikuti operator titik(.) nama properti atau
methodnya. Sehingga, akan menghasilkan output seperti pada
gambar di atas.
15. Kata kunci final
a. Kode program
// class Pegawai
public class Pegawai {
String nama;
final double bonusLembur = 50000;
double hitungBonusLembur(double jumlahLembur){

return jumlahLembur * bonusLembur;
}
}


102

Pegawai Dhennis = new Pegawai();

Dhennis.nama = "Dhennis Al-MAhandiz";
System.out.println("Data Karyawan");
System.out.println("Nama\t\t: " + Dhennis.nama);
System.out.println("Bonus lembur\t: " +
Dhennis.hitungBonusLembur(7));
}
}
b. Output program

c. Penjelasan
Program di atas adalah program yang menerapkan kata kunci
final. Properti, method, atau class yang kita beri kata kunci final,
maka nilai di dalamnya tetap atau tidak dapat berubah, dan apabila
pada class, maka class itu tidak dapat diturunkan (inheritance). Pada
program di atas kita memberi kata kunci final pada properti
bonusLembur yang bernilai 50.000. Maka properti tersebut tidak
dapat diubah nilainya. Sehingga, akan menampilkan output seperti
103
16. Inner class

a. Kode program
// class Notebook
public class Notebook {

private String merk = "Lenovo";
class SistemOperasi{
private String namaOs = "Windows 10";
void cetakData(){
System.out.println("merk Notebook\t: " + merk);
System.out.println("Sistem operasi\t: " + this.namaOs);
}
}
void cetakData(){
SistemOperasi os = new SistemOperasi();
os.cetakData();
}
}


Notebook notebook = new Notebook();

notebook.cetakData();
}
}
104
b. Output program

c. Penjelasan
Program di atas adalah program yang menerapkan konsep inner
class. Yaitu class di dalam class. Inner class dapat mengakses
member outer class dengan bebas, tetapi outer class, harus
menginstansiasi inner class terlebih dahulu jika ingin mengakses
membernya. Sehingga, program di atas akan menghasilkan output
4.4 Tugas
1. Buatlah sebuah program sederhana untuk menghitung IPK Mahasiswa
untuk 5 Mata Kuliah. Anda harus mengimplementasikan method
berparameter, constructor, object dan inner class pada aplikasi Anda.
Jawab:
a. Kode program
// class Mahasiswa

private static String nama, nim;
Mahasiswa(String nama, String nim){

this.nama = nama;
this.nim = nim;
}
105
class MataKuliah{
void mk(int jumlahMk){

String mataKuliah[] = new String[jumlahMk];
int sks[] = new int[jumlahMk];
float tugas[] = new float[jumlahMk];
float uts[] = new float[jumlahMk];
float uas[] = new float[jumlahMk];
float nilai [] = new float[jumlahMk];
int angka[] = new int[jumlahMk];
char huruf[] = new char[jumlahMk];
float total = 0;
float total2[] = new float[jumlahMk];
int totalSks = 0;
for (int i = 0 ; i < jumlahMk ; i++){

System.out.print("\nMata Kuliah ke - " + (i+1) + "\t=
");
mataKuliah[i] = input.next();
System.out.print("SKS\t\t\t= ");
sks[i] = input.nextInt();
System.out.print("Nilai tugas\t\t= ");
tugas[i] = input.nextFloat();
System.out.print("Nilai UTS\t\t= ");
uts[i] = input.nextFloat();
System.out.print("Nilai UAS\t\t= ");
uas[i] = input.nextFloat();
nilai[i]= (tugas[i] + uts[i] + uas[i]) / 3;
if (nilai[i] < 40){

angka[i] = 0;
huruf[i] = 'E';
}else if(nilai[i] >= 40 && nilai[i] <= 54){
angka[i] = 1;
huruf[i] = 'D';
106

angka[i] = 2;
huruf[i] = 'C';
angka[i] = 3;
huruf[i] = 'B';
}else if (nilai[i] >= 85 && nilai[i] <= 100){
angka[i] = 4;
huruf[i] = 'A';
}
total2[i] =sks[i] * angka[i];

total +=total2[i];
totalSks += sks[i];
}
float ipk = total / totalSks;
System.out.println(Mahasiswa.nama);
System.out.println(Mahasiswa.nim);
System.out.println("==================================
======================================================
=========");
System.out.println("MatKuliah || SKS ||
Tugas || UTS || UAS || Nilai Akhir || Huruf || Angka ||
Total");
======================================================
=========");
for (int i = 0 ; i < jumlahMk ; i++){
System.out.println(mataKuliah[i] + " || " + sks[i] + "
|| " + tugas[i] + " || " + uts[i] + " || " + uas[i] +
" || " + nilai[i] + " || " + huruf[i] + " || " + angka[i]
+ " || " + total2[i]);
}
System.out.println("\nIPK = " + ipk);
107
}
}
}
// class Caller


=======");
System.out.println(" SIM AKADEMIK
");
=======\n");
System.out.print("Nama\t= ");
String nama = input.nextLine();
System.out.print("NIM\t= ");
String nim = input.nextLine();
System.out.print("\nMasukan Jumlah Mata Kuliah yang
diambil\t= ");
int jumlahMk = input.nextInt();
Mahasiswa mahasiswa = new Mahasiswa(nama, nim);

Mahasiswa.MataKuliah mataKuliah = mahasiswa.new
MataKuliah();
mataKuliah.mk(jumlahMk);
}
}
108
b. Output program

109

c. Penjelasan
Program di atas adalah program menghitung IPK mahasiswa.
User diminta untuk memasukan nama, nim, dan jumlah mata kuliah
yang diambil. Kemudian user akan memasukan nama mata kuliah,
SKS, nilai tugas, UTS, dan UAS sebanyak jumlah makul yang
dinputkan tadi. Kemudian data yang dimasukan akan ditampilkan
pada console dan menghasilkan IPK sesuai dengan perhitungan nilai
dan SKS yang diinputkan.
110
4.5 Kesimpulan
Pada BAB IV ini kita telah mempelajari konsep dasar dari pemrograman
Java. Mulai dari pengenalan class, member, dan bagaimana cara membuat
objek. Objek adalah entitas dasar saat runtime. Pada saat kode program
dieksekusi, objek berinteraksi satu sama lain tanpa harus mengetahui detail
data atau kodenya. Interaksi antara objek ini dilakukan menggunakan suatu
message. Pada pemrograman berbasis objek, objek dijadikan sebagai
komponen utama dalam program, objek menggabungkan data dan fungsi
sebagai satu kesatuan. Dalam Pemrograman berbasis objek terdapat dua
istilah yang sangat terkenal yaitu class dan objek. Class adalah cetak biru
dari sebuah objek, jadi kita dapat membuat banyak objek dari sebuah class,
atau kita dapat analogikan, class itu adalah cetakan puding, sedangkan objek
adalah puding. Method didefinisikan pada class akan tetapi dipanggil
melalui objek. Metode menentukan perilaku objek, yaitu apa yang terjadi
ketika objek itu dibuat serta berbagai operasi yang dapat dilakukan oleh
objek. class sendiri terdiri dari 3 member yaitu properti, constructor, dan
method.
BAB V
PEWARISAN (INHERITANCE)
5.1 Tujuan
1. Praktikan mampu menerjemahkan UML ke dalam bentuk pemograman
2. Praktikan dapat membedakan pemakaian overloading dan overriding
3. Praktikan mampu menerapkan konsep pewarisan, overloading,
overriding dalam pemrograman dengan Java.
5.2 Dasar Teori

5.2.1 Pewarisan
Pewarisan (inheritance) adalah suatu cara pembuatan class baru dengan
menggunakan kembali class yang sudah didefinisikan sebelumnya dengan
menambahkan atribut dan method baru. Sehingga dengan demikian class
baru tersebut tetap memiliki variabel dan fungsi yang dimiliki oleh class
sebelumnya. Pada konsep pewarisan ada beberapa istilah yang perlu
diketahui,yaitu : (Baldasaro, 2018)
- Subclass, digunakan untuk menunjukan class anak atau turunan secara
hirarkis dari superclass.
- Superclass, digunakan untuk menunjukan class induk secara hirarkis
dari subclass (class anak).
- Extends, digunakan untuk menunjukkan bahwa suatu class merupakan
turunan dari class lain. Misal A extends B, berarti class A adalah turunan
dari class B. A merupakan subclass, sedangkan B merupakan
superclass.
- Super, digunakan untuk memanggil konstruktor dari superclass atau
memanggil variabel atau method yang mengacu pada superclass. Misal
super(x,y,z), berarti atribut x, y, dan z diambil dari atribut pada class
induk.
111
112
Gambar 5. 1 Hirarki class dosen

Gambar di atas menunjukan hirarki class dosen. Class dosen tersebut
memiliki turunan berupa class rector, class dekan, dan class kalab.
Gambar 5. 2 Class diagram untuk hirarki dosen

Gambar di atas menunjukan class induk (class dosen) memiliki atribut
nama, nik dan jurusan. Method yang dimiliki oleh class dosen adalah
view(). Class turunan dari class dosen ada tiga class. Pada class rektor,
terdapat tambahan atribut berupa th_mulai dan jabatan_ke, serta method
viewRektor(). Pada class dekan terdapat tambahan atribut fakultas, dan
method viewDekan(). Pada class kalab terdapat tambahan atribut
laboratorium, dan method viewKalab().
113
5.2.2 Overriding
Overriding adalah suatu cara untuk mendefinisikan ulang method yang
ada pada class induk apabila class anak menginginkan adanya informasi
yang lain. Overriding dilakukan dengan cara menulis ulang method yang
ada pada class induk dengan syarat bahwa nama dan parameter fungsi
tersebut harus sama (tidak boleh diubah). Meskipun fungsi telah ditulis
ulang oleh class anak, fungsi yang asli pada class induk masih dapat
dipanggil di class anak dengan menggunakan class super.
5.2.3 Overloading
Overloading fungsi adalah penulisan beberapa fungsi (dua atau lebih)
yang memiliki nama yang sama. Pada bahasan overloading dikenal istilah
signature. Signature sebuah fungsi adalah parameter lengkap dengan tipe
datanya yang terdapat dalam fungsi tersebut. Misal terdapat fungsi :
public int jumlahMahasiswa (int laki2, int perempuan, String
kelas);
maka signature dari fungsi tersebut adalah (int, int, String).
Suatu fungsi dikatakan di-overload manakala terdapat beberapa fungsi
dengan nama yang sama namun memiliki signature yang berbeda-beda,
sebagai contoh :
Public void infoMahasiswa (int laki2, int perempuan, string
kelas)
{
...
}
public void infoMahasiswa (int mhsLama, int mhsBaru, int
mhsCuti, int angkatan)
{
...
}
114
Overloading fungsi ditentukan oleh signature nya, tidak ditentukan oleh

nilai balikan fungsi. Dalam satu class, apabila ada dua atau lebih fungsi
yang memiliki nilai balikan yang berbeda namun memiliki signature yang
sama, maka fungsi tersebut tidak dapat dikatakan sebagai overloading.
5.3 Latihan
1. Pewarisan
a. Kode program
// class Dosen
public class Dosen {

String nama, nik, jurusan;
Dosen(String nama, String nik, String jurusan){

this.nama = nama;
this.nik = nik;
this.jurusan = jurusan;
}
void view(){
System.out.println("Nama\t= " + this.nama);
System.out.println("NIK\t= " + this.nik);
System.out.println("Jurusan\t= " + this.jurusan);
}
}
// class Rektor
public class Rektor extends Dosen{

private int tahub_mulai, jabatan_ke;
Rektor(String nama, String nik, String jurusan, int

tahun_mulai, int jabatan_ke){
super(nama, nik, jurusan);
115
this.tahub_mulai = tahun_mulai;
this.jabatan_ke = jabatan_ke;
}
void viewRektor(){
System.out.println("Tahun mulai jabatan = " +
this.tahub_mulai);
System.out.println("Jabatan Rektor ke = " +
this.jabatan_ke);
}
}
// class Dekan
public class Dekan extends Dosen{
private String fakultas;

Dekan(String nama, String nik, String jurusan, String
fakultas){
this.fakultas = fakultas;
}
void viewDekan(){
System.out.println("Fakultas = " + this.fakultas);
}
// class Kalab
public class Kalab extends Dosen{
private String laboratorium;

116
Kalab(String nama, String nik, String jurusan, String

laboratorium){
this.laboratorium = laboratorium;
}
void viewKalab(){
System.out.println("Laboratorium = " +
this.laboratorium);
}

public class Main {

Rektor rektor = new Rektor("Andi", "885230202",

"informatika", 2006, 2);
Dekan dekan = new Dekan("Ahmad", "995230101",
"T.Kimia", "TI");
Kalab kalab = new Kalab("Indah", "035230302",
"informatika", "KSC");
rektor.view();
rektor.viewRektor();
dekan.view();
dekan.viewDekan();
kalab.view();
kalab.viewKalab();
}
}
117
b. Output program

c. Penjelasan
Gambar di atas merupakan hierarki class dosen, dimana class
dosen memiliki turunan class Rektor, class Dekan, dan class
Kalab. Kemudian semua method di superclass dan subclassnya
dipanggil di class Main. Sehingga, akan menghasilkan output
2. Overriding
a. Kode program
// class Dosen
public class Dosen {

String nama, nik, jurusan;
Dosen(String nama, String nik, String jurusan){

this.nama = nama;
this.nik = nik;
this.jurusan = jurusan;
}
void view(){
118
System.out.println("Nama\t= " + this.nama);

System.out.println("NIK\t= " + this.nik);
System.out.println("Jurusan\t= " + this.jurusan);
}
}
// class Rektor
public class Rektor extends Dosen{

private int tahub_mulai, jabatan_ke;
Rektor(String nama, String nik, String jurusan, int

tahun_mulai, int jabatan_ke){
this.tahub_mulai = tahun_mulai;
this.jabatan_ke = jabatan_ke;
}
@Override
void view(){
super.view();
System.out.println("Tahun mulai jabatan = " +
this.tahub_mulai);
System.out.println("Jabatan Rektor ke = " +
this.jabatan_ke);
}
}
// class Dekan
public class Dekan extends Dosen{
private String fakultas;

Dekan(String nama, String nik, String jurusan, String
fakultas){
this.fakultas = fakultas;
119
@Override
void view(){
super.view();
System.out.println("Fakultas = " + this.fakultas);
}
// class Kalab
public class Kalab extends Dosen{
private String laboratorium;
Kalab(String nama, String nik, String jurusan, String

laboratorium){
this.laboratorium = laboratorium;
}
@Override
void view(){
super.view();
System.out.println("Laboratorium = " +
this.laboratorium);
}
}
public class Main {

120
Rektor rektor = new Rektor("Andi", "885230202",

"informatika", 2006, 2);
Dekan dekan = new Dekan("Ahmad", "995230101",
"T.Kimia", "TI");
Kalab kalab = new Kalab("Indah", "035230302",
"informatika", "KSC");
rektor.view();
dekan.view();
kalab.view();
}
}
b. Output program

c. Penjelasan
Program di atas adalah contoh penerapan dari konsep overriding
yaitu menulis kembali method yang ada di superclass ke dalam
subclass. Untuk menandai bahwa method tersebut adalah
overriding, kita gunakan kata kunci @Override tepat di atas method
tersebut. Sehingga, saat dipanggil akan menghasilkan output seperti
gambar di atas.
121
3. Overloading
a. Kode program
// class Mahasiswa
void infoMahasiswa(int laki, int perempuan, String

kelas){
int jumlah = laki + perempuan;
System.out.println(kelas + ", jumlah mahasiswa = " +
jumlah);
void infoMahasiswa(int mhsLama, int mhsBaru, int

mhsCuti, int angkatan){
int jumlah = mhsLama + mhsBaru + mhsCuti;
System.out.println("Sampai tahun " + angkatan + "

jumlah mahasiswa = " + jumlah);
}
}
// class Main atau class pemanggil
public class Main {

Mahasisiwa mahasiswa = new Mahasiswa();
mahasiswa.infoMahasiswa(60, 18, "kelas A angkatan

2008");
mahasiswa.infoMahasiswa(1000, 400, 25, 2008);
}
}
122
b. Output program

c. Penjelasan
Program di atas adalah contoh konsep penerapan dari
overloading method. Yaitu dalam satu class memiliki dua atau lebih
method yang sama, namun jumlah atau tipe data parameternya
berbeda. Program di atas memiliki dua method infoMahasiswa()
di dalam class Mahasiswa yang memiliki jumlah dan tipe data
parameter yang berbeda. Kemudian, method tersebut dipanggil di
class Main. Sehingga, saat program di atas dijalankan akan
4. Overloading (2)
a. Kode program
// class Penjumlahan
public class Penjumlahan {
int jumlah(int a, int b){

return a + b;
}
double jumlah(double a, double b){
return a + b;
}

123
public class Main {

int a = 10, b = 15;

double x = 10.5, y = 15.8;
Penjumlahan penjumlahan = new Penjumlahan();

System.out.println(a + " + " + b + " = " +
penjumlahan.jumlah(a, b));
System.out.println(x + " + " + y + " = " +
penjumlahan.jumlah(x, y));
}
}
b. Output program

c. Penjelasan
Program di atas kita membuat program dengan konsep
overloading method. Yaitu ada dua method jumlah() di class
Penjumlahan dengan jumlah parameter yang sama namun tipe
datanya berbeda. Kemudian method tersebut dipanggil di class
Main. Sehingga, saat dijalankan akan menghasilkan output seperti
gambar di atas.
124
5.4 Tugas
1. Buatlah sebuah class kendaraan dengan turunannya kendaraan darat,
kendaraan laut, kemudian diturunkan lagi menjadi sepeda motor dan
perahu layar. Kemudian buatlah fungsi-fungsi untuk menampilkan data
kendaraan berupa: kecepatan, kapasitas_tangki, tahun_keluar, warna,
daya_angkut_barang, daya_angkut_manusia dan total_daya_angkut.
Jawab:
a. Kode program
//abstract class Kendaraan
public abstract class Kendaraan {
float kecepatan, kapasitasTangki, dayaAngkutBarang,

dayaAnkutManusia, totalDayaAngkut;
int tahunKeluar;
String nama, warna;
Kendaraan(String nama, float kecepatan, float

kapasitasTangki, float dayaAngkutBarang, float
dayaAnkutManusia, int tahunKeluar, String warna){
this.nama = nama;
this.kecepatan = kecepatan;
this.kapasitasTangki = kapasitasTangki;
this.dayaAngkutBarang = dayaAngkutBarang;
this.dayaAnkutManusia = dayaAnkutManusia;
this.tahunKeluar = tahunKeluar;
this.warna = warna;
abstract void displaySpesifikasi();
}
125
//class kendaraan darat

public abstract class KendaraanDarat extends Kendaraan

{
KendaraanDarat(String nama, float kecepatan, float

super(nama, kecepatan, kapasitasTangki,
dayaAngkutBarang, dayaAnkutManusia, tahunKeluar,
warna);
}
//class kendaraan laut

public abstract class KendaraanLaut extends Kendaraan

{
KendaraanLaut(String nama, float kecepatan, float
warna);
}
}
//class sepeda motor

public class SepedaMotor extends KendaraanDarat {
SepedaMotor(String nama, float kecepatan, float

126

warna);
@Override
void displaySpesifikasi() {
this.totalDayaAngkut = this.dayaAngkutBarang +
this.dayaAnkutManusia;
System.out.println("\n============================SEPE
DA MOTOR============================");
System.out.println("\nSepeda Motor ini bermerk " +
this.nama + ", saya beli tahun " + this.tahunKeluar +
" berwarna " + this.warna);
System.out.println( "yang memiliki kecepatan maksimal
" + this.kecepatan + " km/jam");
System.out.println("dengan maksimum tangki sebesar " +
this.kapasitasTangki + " liter");
System.out.println("daya angkut barangnya sebesar " +
this.dayaAngkutBarang + " kg dan daya angkut manusia
maksimum " + this.dayaAnkutManusia + " kg");
System.out.println("sehingga total daya angkut
kendaraan keseluruhan " + this.totalDayaAngkut + "
kg");
}
}
127
//class perahu layar

public class PerahuLayar extends KendaraanLaut{

PerahuLayar(String nama, float kecepatan, float
warna);
}
@Override
void displaySpesifikasi() {
this.totalDayaAngkut = this.dayaAngkutBarang +
this.dayaAnkutManusia;
System.out.println("\n============================PERA
HU LAYAR============================");
System.out.println("\nPerahu layar ini bermerk " +
this.nama + ", saya beli tahun " + this.tahunKeluar +
" berwarna " + this.warna);
System.out.println( "yang memiliki kecepatan maksimal
" + this.kecepatan + " km/jam");
System.out.println("dengan maksimum tangki sebesar " +
this.kapasitasTangki + " liter");
System.out.println("daya angkut barangnya sebesar " +
this.dayaAngkutBarang + " kg dan daya angkut manusia
maksimum " + this.dayaAnkutManusia + " kg");
System.out.println("sehingga total daya angkut
kendaraan keseluruhan " + this.totalDayaAngkut + "
kg");
}
}
128
//class caller
System.out.println("Nama\t: Nur Muhammad Syaifudin");

SepedaMotor sepedaMotor = new SepedaMotor("Vario CBS",
120, 10, 50, 150, 2015, "merah");
PerahuLayar perahuLayar = new PerahuLayar("ELVIS", 80,
30, 100, 300, 2012, "putih");
sepedaMotor.displaySpesifikasi();
perahuLayar.displaySpesifikasi();
}
}
b. Output program

129
c. Penjelasan
Program di atas adalah program yang menerapkan konsep
inheritance. Dimana saya membuat abstract class “Kendaraan”
sebagai parent class yang memiliki member property, constructor,
dan abstract method, kemudian saya turunkan ke abstract class
“KendaraanDarat” dan “KendaraanLaut” sebagai sub class.
Kemudian saya turunkan lagi abstract class “KendaraanDarat” dan
“KendaraanLaut” ke class “SepedaMotor” dan “PerahuLayar”.
Kemudian saya override method yang ada pada parent classnya di
sub class “SepedaMotor” dan “PerahuLayar”. Kemudian saya
instasiasi dan panggilnya fungsi pada class “Caller”. Sehingga akan
menghasilkan output seperti gambar di atas.
5.5 Kesimpulan
Pada BAB V ini kita telah mempelajari tentang apa itu inheritance.
Yaitu kemampuan superclass mewarisi atribut, method, dan constructornya
kepada subclass. Artinya, class anak (subclass) dapat memiliki kemampuan
yang dimiliki class induknya (superclass). Subclass pun dapat melakukan
tambahan member, seperti atribut dan methodnya sendiri. Kita juga telah
belajar tentang apa itu overriding dan overloading. Overriding yaitu
membuat kembali method yang ada di superclass ke dalam subclass.
Sedangkan overloading yaitu kemampuan memiliki dua atau lebih
constructor atau method dengan nama yang sama dalam satu class, namun
harus memiliki jumlah atau tipe data parameter yang berbeda.
BAB VI
POLIMORFISME
6.1 Tujuan
1. Praktikan mampu menerapkan konsep polimorfisme dalam
pemrograman dengan Java
6.2 Dasar Teori

Polimorfise digunakan untuk menyatakan suatu nama yang merujuk
pada beberapa fungsi yang berbeda. Pada polimorfisme, rujukan dapat
dilakukan pada berbagai tipe objek. hal ini dilakukan karena setiap objek
dimungkinkan memiliki instruksi yang berbeda. Dalam
mengimplementasikan polimorfisme, perlu diperhatikan hal – hal sebagai
berikut : (Rizki, 2017)
1. Method yang dipanggil harus melalui variabel dari superclass.
2. Method yang dipanggil juga harus merupakan method yang ada pada
superclass.
3. Signature method harus sama baik yang ada pada superclass maupun di
subclass.
4. Method acces atribut pada subclass tidak boleh lebih terbatas daripada
yang ada pada superclass.
6.3 Latihan
a. Kode program
// class Kendaraan
public class Kendaraan {
private String model;
Kendaraan(String model){
130
131
this.model = model;
}
void informasi(){}
// class Pesawat
public class Pesawat extends Kendaraan{

private String nama, jenis;
Pesawat(String nama){
super("Pesawat");
this.nama = nama;
jenis = "belum teridentifikasi";
}
Pesawat(String nama, String jenis){

super("Pesawat");
this.nama = nama;
this.jenis = jenis;
}
void informasi(){
System.out.println("Nama pesawat adalah\t: " + this.nama);
System.out.println("Jenis pesawat adalah\t: " +
this.jenis);
}
}
// class Mobil
public class Mobil extends Kendaraan{

132
Mobil(String nama){
super("Mobil");
this.nama = nama;
}
Mobil(String nama, String jenis){

super("Mobil");
this.nama = nama;
this.jenis = jenis;
}
void informasi(){
this.jenis);
}
}
// class Kapal
public class Kapal extends Kendaraan{

Kapal(String nama){
super("Kapal");
this.nama = nama;
}
Kapal(String nama, String jenis){

super("Kapal");
this.nama = nama;
this.jenis = jenis;
}
133
void informasi(){
this.jenis);
}
}

public class Main {

Kendaraan P;
Pesawat psw =new Pesawat ("Boeing","Pesawat Komersial");
Mobil mbl1 = new Mobil("Toyota Kijang", "Jeep");
Mobil mbl2 = new Mobil("Suzuki Baleno", "Sedan");
Mobil mbl3 = new Mobil("VW Combi");
Kapal kpl = new Kapal ("Queen Mary 2","Kapal Pesiar");
P = psw;
P.informasi();
P = mbl1;
P.informasi();
P = mbl2;
P.informasi();
P = mbl3;
P.informasi();
P = kpl;
P.informasi();
}
}
134
b. Output program
Gambar 6. 1 Output latihan polimorfisme

c. Penjelasan
Program di atas merupakan contoh program polimorfisme, dimana
terdapat sebuah superclass dan superclass tersebut di-extends ke kelas
- kelas extends-nya. Pada program tersebut terdapat beberapa class
dalam satu package. Class Main merupakan main class (kelas utama)
pada program tersebut. Class main ini juga nantinya yang akan
digunakan untuk me-run program dan dari class lain tidak bisa. Pada
class Main terdapat syntax untuk memasukan data ke dalam class mobil,
pesawat dan kapal. Salah satu syntax-nya yaitu Pesawat psw = new
Pesawat("Boeing 737","Pesawat komersial"); yang merupakan
syntax untuk menginputkan informasi ke class pesawat. Class
kendaraan merupakan superclass yang bertugas mendeklarasikan
method yang akan dipakai di class - class extend-nya. Class mobil,
pesawat dan kapal merupakan class extend dari kendaraan dan terdapat
syntax pada masing-masing class tersebut untuk menampilkannya.
135
6.4 Tugas
1. Buatlah semua program yang mengimplemtasikan konsep polimorfisme
dari sebuah class dengan nama class hewan.
Jawab:
a. Kode program
//class Hewan
public abstract class Hewan {
String nama, jenis;
Hewan(String nama, String jenis){

this.nama = nama;
this.jenis = jenis;
}
abstract void info();
// class Karnivora
public class Karnivora extends Hewan{
Karnivora(String nama){
super(nama, "yang sudah punah");
}
Karnivora(String nama, String jenis){

super(nama, jenis);
}
@Override
void info() {
System.out.println("\nHewan ini adalah " + this.nama);
136
System.out.println("dia termasuk jenis hewan " +

this.jenis);
}
//class Herbivora
public class Herbivora extends Hewan{
Herbivora(String nama){
super(nama, " PESUGIHAN");
}
Herbivora(String nama, String jenis){

super(nama, jenis);
}
@Override
void info() {
this.jenis);
}
}
//class Omnivora
public class Omnivora extends Hewan{
Omnivora(String nama){
super(nama, "MITOS");
}
Omnivora(String nama, String jenis){

super(nama, jenis);
137
@Override
void info() {
this.jenis);
}
}
//class Caller
Hewan hewan;
Karnivora macan = new Karnivora("Macan", "Karnivora");
Karnivora tirex = new Karnivora("Tirex");
Herbivora wedus = new Herbivora("Wedus", "Herbivora");
Herbivora babiNgepet = new Herbivora("Babi Ngepet");
Omnivora monyet = new Omnivora("Monyet", "Omnivora");
Omnivora naga = new Omnivora("Naga");
hewan = macan;
hewan.info();
hewan = tirex;
hewan.info();
hewan = wedus;
hewan.info();
hewan = babiNgepet;
hewan.info();
hewan = monyet;
hewan.info();
hewan = naga;
hewan.info();
}
}
138
b. Output program

c. Penjelasan
Program di atas adalah program yang menerapkan konsep
polimorfisme. Dimana saya membuat abstract class “Hewan”
sebagai parent class yang memiliki member property, constructor,
dan abstract method, kemudian saya turunkan ke class “Karnivora”,
“Herbivora”, dan “Omnivora” sebagai sub class. Kemudian saya
override method yang ada pada parent classnya di sub class
“Karnivora”, “Herbivora”, dan “Omnivora” dan saya membuat
overload constructor di masing – masing sub class. Kemudian saya
instasiasi, dan lakukan perubahan bentuk pada parent class menjadi
semua sub classnya, dan panggil fungsinya pada class “Caller”.
Sehingga akan menghasilkan output seperti gambar di atas.
139
6.5 Kesimpulan
Pada BAB VI ini, kita telah belajar tentang Polyforfisme. Polyforfisme
merupakan salah satu konsep penting dalam Object Oriented Programming
(OOP) khususnya di bahasa pemrograman Java setelah abstraction dan
inheritance. Polymorphism berarti banyak bentuk. Ada beberapa definisi
berbeda tentang polymorphism yang berkaitan dengan pemrograman
berorientasi objek. Sedangkan apa yang dimaksud dengan polymorphism
sendiri, sebenarnya sulit untuk didefinisikan. Sejalan dengan contoh yang
diberikan, Anda diharapkan dapat mengerti dan memahami konsep
polymorphism itu sendiri. Polyforfisme sering dikaitkan dengan penggunaan
lebih dari satu metoda dengan nama sama. Penggunaan metoda dengan
nama sama dapat diterapkan dengan method overloading dan method
overriding. Peran polymorphism sebenarnya tidak terbatas hanya pada hal
tersebut. Ada keterkaitan antara polymorphism dan inheritance (turunan).
BAB VII
PENANGANAN EKSEPSI
7.1 Tujuan
1. Praktikan mampu menangani berbagai kesalahan dengan penanganan
eksepsi dalam pemrograman dengan Java
7.2 Dasar Teori

7.2.1 Eksepsi
Saat kita membuat program, sebisa mungkin program kita terhindar dari
kesalahan. Namun, yang lebih penting adalah bagaimana dalam program
kita dapat mengantisipasi kemungkinan munculnya kesalahan pada saat
program kita dieksekusi. Java menyediakan sebuah mekanisme penanganan
kesalahan yang biasa disebut dengan exception-handling. Dalam hal ini
setiap kesalahan akan dibentuk menjadi objek.
Dalam Java, runtime error (kesalahan - kesalahan yang terjadi pada saat
program sedang berjalan) direpresentasikan denga eksepsi. Eksepsi adalah
suatu objek yang dibuat pada saat program mengalami suatu kondisi yang
tidak wajar (abnormal). Eksepsi dapat dibangkitkan secara otomatis oleh
Java runtime maupun secara manual oleh kita sendiri melalui kode yang kita
tulis.
Java menyediakan lima buah kata kunci untuk menangani eksepsi, yaitu:
try, catch, throw, throws, dan finally. Kata kunci try digunakan untuk
membuat blok yang berisi statement - statement yang mungkin
menimbulkan eksepsi. Jika dalam proses eksekusi runtunan statement
tersebut terjadi sebuah eksepsi, maka eksepsi akan dilempar ke bagian blok
penangkap yang dibuat dengan kata kunci catch. Pada kasus - kasus tertentu,
terkadang kita juga ingin melempar eksepsi secara manual. Untuk itu, kita
harus menggunakan kata kunci throw. Jika kita ingin membangkitkan
sebuah eksepsi tanpa menuliskan blok try, maka kita perlu menambahkan
kata kunci throws pada saat pendeklarasian method. Dalam mendefinisikan
140
141
blok try, kita dapat menuliskan statement tambahan, yaitu menggunakan

kata kunci finally. Statement tambahan ini pasti akan dieksekusi baik terjadi
eksepsi maupun tidak.
Berikut ini bentuk umum penanganan eksepsi di Java.
try {
//kumpulan statemen yang mungkin menimbulkan eksepsi
} catch (TipeEksepsi1 objekEksepsi1) {
//penanganan untuk tipe eksepsi1
} catch (TipeEksepsi2 objekEksepsi2) {
//penanganan untuk tipe eksepsi2
} finally {
//statemen tambahan yang pasti akan dieksekusi
}
Di sini, TipeEksepsi adalah tipe dari eksepsi yang terjadi. Tipe tersebut
direpresentasikan dengan sebuah kelas, misalnya: NullPointerException,
ArithmeticException, ArrayIndexOutOfBounds- Exception, dan sebagainya.
7.2.2 Menggunakan Kata Kunci Try dan Catch
Pada bagian sebelumnya telah dicontohkan bagaimana Java mencegah
eksepsi secara default. Namun, pada umumnya, pencegahan eksepsi
dilakukan oleh kita sendiri, sebagai programmer. Untuk melakukan hal
tersebut, kita dapat menggunakan blok try-catch.
7.2.3 Penjebakan Beberapa Tipe Eksepsi
Pada kenyataan di lapangan, sebuah blok try-catch biasanya terdiri atas
beberapa bagian blok penangkap. Hal tersebut bertujuan agar dalam satu
blok try-catch, kita dapat mengatasi beberapa kemungkinan eksepsi yang
terjadi.
142
7.2.4 Menggunakan Kata Kunci Throw

Kita dapat membangkitkan eksepsi secara manual dengan menggunakan
kata kunci throw. Berikut ini penggunaan umum kata kunci tersebut.
throw eksepsi;
eksepsi yang dimaksud harus berupa objek Throwable maupun objek
dari kelas - kelas turunannya. Kita tidak dapat melempar objek non-
Throwable, misalnya objek String. Sebagai contoh, Jika kita ingin
membangkitkan eksepsi NullPointerException, maka kita dapat menuliskan
kodenya sebagai berikut :
throw nullpointerexception();
7.2.5 Menggunakan Kata Kunci Throws
Jika kita tidak menyertakan blok try-catch di dalam method yang
mengandung kode - kode yang mungkin menimbulkan eksepsi, maka kita
harus menyertakan klausa throws pada saat pendeklarasian method yang
bersangkutan. Jika tidak, maka program akan membangkitkan eksepsi.
Berikut ini bentuk umum dari penggunaan kata kunci throws.
tipe nama-method(daftar-parameter) throws tipeeksepsi1, tipe-
eksepsi2, …, tipe-eksepsiN {
//badan-method
}
143
7.2.6 Menggunakan Kata Kunci Finally

Terkadang kita ingin menempatkan kode yang pasti akan dieksekusi,
baik terjadi eksepsi maupun tidak. Untuk melakukan hal itu, kita perlu
menempatkan kode tersebut di dalam bagian finalisasi dari blok try-catch.
Blok finalisasi ini dibuat dengan menggunakan kata kunci finally. Bentuk
umum pendefinisian blok finally ini sebagai berikut :
try {
//statemen yang mungkin menimbulkan eksepsi A, B, danC
} catch (A ea) {
//blok penangkap untuk eksepsi A
} catch (B eb) {
//blok penangkap untuk eksepsi B
} catch (C ec) {
//blok penangkap untuk eksepsi C
} finally {
//statemen yang pasti akan dieksekusi, baik terjadi //eksepsi
maupun tidak
}
7.3 Latihan
1. Contoh program yang menimbulkan eksepsi
a. Kode pogram
public class Main {

int arrayInteger [] = new int[5];

arrayInteger [7] = 9;
}
}
144
b. Output program

c. Penjelasan
Program di atas merupakan contoh program yang menimbulkan
eksepsi. Pada program tersebut terdapat variabel int[]
arrayInteger = new Int[5]. Jika dijalankan, program akan

membangkitkan dengan tipe ArrayIndexOutOfBoundsException
karena kita mengakses indeks yang tidak terdapat dalam
arrayInteger. arrayInteger terdiri dari 5 elemen dengan indeks
0 sampai 4.
2. Try dan catch
a. Kode program
public class Main {

int pembilang = 7;
int penyebut = 0;
try{
int hasil = pembilang / penyebut;
System.out.println("Hasil = " + hasil);
}catch(Exception e){
System.out.println("Kesalahan terdapat pembagian
dengan nol");
}
System.out.println("Statement setelah blok try catch");
}
}
145
b. Output program

c. Penjelasan
Program di atas merupakan contoh program try dan catch. Pada
program tersebut terdapat variabel pembilang dan penyebut yang
masing - masing memiliki nilai 7 dan 0. Apabila dijalankan
program akan langsung menjalankan kondisi catch pada saat terjadi
eksepsi yaitu program akan menampilkan tampilan “KESALAHAN
Terdapat pembagian dengan nol”. Namun bagian statement yang
dituliskan setelah blok try-catch tetap akan dieksekusi oleh
program yaitu menampilkan tampilan statement setelah blok try
catch.
3. Menangkap beberapa tipe eksepsi
a. Kode program
public class Main {
public static void cobaEksepsi(int pembilang, int

penyebut) {
try {
System.out.println("Hasil bagi: " + hasil);
int[] Arr = {1, 2, 3, 4, 5};
// array dengan 5 elemen
Arr[ 10] = 23; // mengakses indeks ke-10
} catch (ArithmeticException eksepsi1) {
System.out.println("Terdapat pembagian dengan 0");
146
} catch (ArrayIndexOutOfBoundsException eksepsi2) {

System.out.println("Indeks di luar rentang");
}
}

cobaEksepsi(4, 0);
cobaEksepsi(12, 4);
}
}
b. Output program

c. Penjelasan
Program di atas merupakan contoh program penjebakan
terhadap beberapa eksepsi. Pada program tersebut terdapat method
cobaEksepsi() yang di dalamnya terdapat try dan catch. Ketika
program melewatkan argumen ke dalam method cobaEksepsi()
dengan nilai 4 dan 0, program akan membangkitkan eksepsi
ArithmeticException. Sedangkan Jika argumen bernilai 12 dan 4,
maka program akan melakukan pembagian dengan benar dan
menghasilkan nilai 3 (hasil dari 12/4).
147
4. Throw
a. Kode program
// class Mahasiswa

private String nim, nama;
void setNim(String nim){
try{
this.nim = nim;
if(nim == null){
throw new NullPointerException();
}
}catch(NullPointerException e){
System.out.println("KESALAHAN: NIM tidak boleh null");
}
}
String getNim(){
return this.nim;
}
void setNama(String nama){
try{
this.nama = nama;
if(nama == null){
throw new NullPointerException();
}
}catch(NullPointerException e){
System.out.println("KESALAHAN: Nama Mahasiswa tidak
boleh null");
}
}
String getNama(){
return this.nama;
}
}
148
public class Main {

Mahasiswa mahasiswa = new Mahasiswa();

mahasiswa.setNim(null);
mahasiswa.setNama("Nadilla");
System.out.println("NIM\t: " + mahasiswa.getNim());

System.out.println("Nama\t: " + mahasiswa.getNama());
}
}
b. Output program

c. Penjelasan
Program di atas merupakan contoh program kata kunci throw.
Pada program tersebut terdapat class Mahasiswa dan class Main. Di
dalam class Mahasiswa terdapat 3 method yaitu method setNIM(),
method getNIM() dan juga method setNama(). Tampak seperti
pada gambar di atas, ketika program melewatkan nilai null ke
dalam method setNIM() dari kelas Mahasiswa, program akan
membangkitkan eksepsi NullPointerException yang di lempar atau
di bangkitkan secara manual dengan menggunakan kata kunci
throw. Bagian statement yang dituliskan setelah blok try-catch tetap
akan dieksekusi oleh program.
149
5. Throws
a. Kode program
public class Main {
public static void cobaEksepsi() throws

IllegalAccessException {
throw new IllegalAccessException(
"KESALAHAN: illegal access");
}

try {
cobaEksepsi();
} catch (Exception e) {
System.out.println("Eksepsi ditangkap disini...");
System.out.println(e.getMessage());
}
System.out.println("Statemen setelah blok try catch");
}
}
150
b. Output program

c. Penjelasan
Program di atas merupakan contoh program kata kunci throws.
Pada program tersebut terdapat class Main dan juga method
cobaEksepsi() yang berada di dalam class Main. Pada deklarasi
method cobaEksepsi() di atas, program menambahkan klausa
throws yang diikuti dengan nama eksepsi yang akan dilempar/
dibangkitkan. Melalui teknik seperti ini, compiler akan mengetahui
bahwa method tersebut dapat membangkitkan eksepsi
IllegalAccessException sehingga program dapat dikompilasi dengan
sukses. Bagian statement yang dituliskan setelah blok try-catch
tetap akan dieksekusi oleh program.
6. Finally
a. Kode program
public class Main {
public static void cobaEksepsi(int pembilang, int
penyebut) {
try {
System.out.println("Hasil bagi: " +hasil);
int[] Arr = {1, 2, 3, 4, 5};
Arr[10] = 23;
} catch (ArithmeticException eksepsi1) {
System.out.println("Terdapat pembagian dengan 0");
} catch (ArrayIndexOutOfBoundsException
eksepsi2) {
151
System.out.println("Indeks di luar rentang");

} finally {
System.out.println("Ini adalah statemen dalam blok
finally");
}
}
cobaEksepsi(4, 0);
cobaEksepsi(12, 4);
}
}
b. Output program

c. Penjelasan
Program di atas merupakan contoh program kata kunci finally.
Pada program tersebut terdapat class Main dan di dalamnya
terdapat method cobaEksepsi(). Di dalam method
cobaEksepsi() terdapat try dan catch. Meskipun terjadi eksepsi
atau tidak pada program, program akan tetap menjalankan
statement yang ada di dalam blok finally sehingga di setiap terjadi
eksepsi maupun tidak blok finally akan tetap dijalankan. Bagian
statement yang dituliskan setelah blok finally tetap akan
dieksekusi oleh program.
152
7.4 Tugas
1. Buatlah program penyusupan array dan gunakan blok try-catch untuk
menangani kesalahannya.
Jawab:
a. Kode program
public class Main{
static void printArray(int [] array){

System.out.println(Arrays.toString(array));
}

int [] array = new int[2];
for (int i = 0 ; i < 2 ; i++){

System.out.print("indek ke - " + i + " = ");
array[i] = input.nextInt();
}
printArray(array);
System.out.print("Masukan nilai sisipan = ");

int sisipan = input.nextInt();
System.out.print("Masukan indeks sisipan = ");
int indeksSisipan = input.nextInt();
153
int [] arraySisipan = Arrays.copyOf(array, 2);
try{
if (indeksSisipan == 0){
arraySisipan[0] = sisipan;
arraySisipan[1] = array[0];
}else if (indeksSisipan == 1){
}else{
}
}catch (Exception e){
System.err.println("Melampaui RENTANG");
}
printArray(arraySisipan);
}
}
b. Output program

154
c. Penjelasan
Progam di atas adalah program untuk menangani eksepsi dalam
penyisipin array. Saya membuat array satu dimensi yaitu [1, 2].
Kemudian saya coba sisipkan nilai 3 di indeks ke – 1, sehingga
hasilnya adalah [1, 3]. Hasilnya demikian karena panjang arraynya
hanya 2, sehingga nilai 2 yang seharusnya berada di indeks ke – 2,
tidak dimasukan. Seandainya saya tidak melakukan penanganan
eksepsi, maka program di atas akan membangkitkan
ArrayIndexOutOfBoundsException.
7.5 Kesimpulan
Pada BAB VII ini kita telah belajar tentang eksepsi, yaitu error yang
terjadi saat runtime. Untuk mengatasi error tersebut kita bisa
menggunakan kata kunci throw, throws, try, catch, dan finally. Kata kunci
try digunakan untuk membuat blok yang berisi statement - statement yang
mungkin menimbulkan eksepsi. Jika dalam proses eksekusi runtunan
statement tersebut terjadi sebuah eksepsi, maka eksepsi akan dilempar ke
bagian blok penangkap yang dibuat dengan kata kunci catch. Pada kasus -
kasus tertentu, terkadang kita juga ingin melempar eksepsi secara manual.
Untuk itu, kita harus menggunakan kata kunci throw. Jika kita ingin
membangkitkan sebuah eksepsi tanpa menuliskan blok try, maka kita perlu
menambahkan kata kunci throws pada saat pendeklarasian method. Dalam
mendefinisikan blok try, kita dapat menuliskan statement tambahan, yaitu
menggunakan kata kunci finally. Statement tambahan ini pasti akan
dieksekusi baik terjadi eksepsi maupun tidak.
BAB VIII
INPUT DAN OUTPUT
8.1 Tujuan
1. Praktikan mampu mengenali dan memahami input dan output (I/O)
dalam pemrograman Java
8.2 Dasar Teori

8.2.1 Pengertian Stream
Program Java melakukan proses I/O melalui stream. Stream adalah
sebuah abstraksi yang dapat memberikan atau mendapatkan informasi.
Stream dapat dihubungkan dengan peralatan fisik yang terdapat dalam
sistem I/O Java, seperti: keyboard, file, layar console, dan yang lainnya.
Cara kerja stream selalu sama, meskipun jenis peralatan yang terhubung
dengan stream tersebut berbeda. Ini artinya, sebuah stream input dapat
mengabstraksikan beberapa tipe peralatan fisik, seperti: keyboard, file, atau
socket jaringan. Begitu pula dengan stream output, yang dapat dihubungkan
dengan layar console, file, maupun koneksi jaringan. Dengan demikian,
stream akan memudahkan kita dalam melakukan proses I/O, karena kode
program yang kita tulis akan sama untuk masing - masing peralatan fisik
yang dihubungkan dengan stream bersangkutan. (Abdillah, 2018)
8.2.2 Tipe Stream
Terdapat dua buah tipe stream yang dapat digunakan, yaitu: stream byte
dan stream karakter. Sesuai dengan namanya, stream byte digunakan untuk
memberikan atau menyimpan informasi data dalam bentuk byte, misalnya
untuk menulis dan membaca file biner. Sedangkan stream karakter
digunakan untuk melakukan proses I/O yang melibatkan data - data dalam
bentuk karakter, misalnya pada saat kita melakukan proses baca/ tulis ke file
teks. Dalam Java, stream didefinisikan dengan menggunakan empat kelas
abstrak, yaitu: InputStream, OutputStream, Reader, dan Writer. Kelas
InputStream dan OutputStream merupakan kelas abstrak yang dirancang
155
156
sebagai kelas induk atau superclass untuk kelas - kelas yang termasuk ke
dalam kategori stream byte. Adapun kelas Reader dan Writer merupakan
kelas abstrak yang akan diturunkan menjadi kelas - kelas baru yang
termasuk ke dalam kategori stream karakter.
Melalui proses pewarisan (inheritance), semua kelas yang diturunkan
dari InputStream maupun Reader akan memiliki method read(), yang akan
digunakan untuk proses pembacaan data. Adapun semua kelas yang
diturunkan dari OutputStream maupun Writer akan memiliki method
write(), yang akan digunakan untuk proses penulisan data. Kedua method
tersebut dideklarasikan sebagai method abstrak sehingga harus
diimplementasi oleh setiap kelas turunannya.
8.2.3 Melakukan Input
Dalam Java, input console dilakukan melalui pembacaan terhadap
stream System.in. Untuk mendapatkan karakter - karakter yang
dimasukkan melalui keyboard ke dalam layar console, kita perlu
membungkus System.in di dalam objek BufferedReader. Hal ini,
dilakukan untuk membentuk stream karakter, karena System.in
sebenarnya merupaka stream byte. Adapun bentuk constructor dari
BufferedReader sebagai berikut :
BufferedReader(Reader inputReader);
InputReader adalah stream yang akan dihubungkan dengan instance
atau objek dari kelas BufferedReader yang dibuat. Karena Reader berupa
kelas abstrak, maka kita perlu mencari kelas turunannya yang berupa kelas
konkrit. Salah satunya adalah kelas InputStreamReader, yang dapat
mengkonversi byte ke karakter. Sekarang, agar objek dari
InputStreamReader dapat dihubungkan dengan System.in, kita perlu
menggunakan bentuk constructor sebagai berikut :
InputStreamReader(InputStream inputStream);
157
Di sini, inputStream dapat kita isi dengan System.in. Dengan demikian,

untuk membuat objek BufferedReader yang dapat terhubung dengan
keyboard, kita perlu menggunakan kode berikut :
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
Sampai tahap ini, objek br sudah siap digunakan untuk melakukan
proses input, yaitu dengan melakukan pemanggilan terhadap method
read() maupun readline(), yang akan kita bahas lebih lanjut.
8.2.4 Membaca Input Data Karakter
Untuk membaca input berupa karakter, kita bisa menggunakan method
read() yang terdapat pula pada kelas BufferedReader.
8.2.5 Membaca Input Data String
Untuk membaca input berupa string, kita bisa menggunakan method
readLine(), bukan method read().
8.2.6 Membaca Input Data Numerik
Untuk membaca input berupa data numerik, kita bisa menggunakan
method readLine() seperti pada saat menangani input data string, dan
selanjutnya string hasil input tersebut dikonversi ke tipe numerik.
8.2.7 Dasar – dasar Baca Tulis File
Java menyediakan dua buah stream yang paling sering digunakan untuk
melakukan proses pembacaan/ penulisan data dari/ ke dalam file, yaitu :
FileInputStream (untuk membaca data) dan FileOutputStream (untuk
menulis data). Keduanya akan membentuk stream byte yang terhubung ke
sebuah file. Untuk membuka file, kita harus membentuk objek dari salah
satu kelas stream tersebut dengan menyertakan nama file sebagai argumen
pada constructor-nya. Bentuk secara umum adalah sebagai berikut :
FileInputStream(String filename) throws
FileNotFoundException
FileOutputStream(String filename) throws
FileNotFoundException
158
Di sini, fileName menunjukkan nama file yang akan dibuka. Pada saat
menggunakan stream input, jika file tidak ditemukan maka kedua
constructor akan membangkitkan eksepsi FileNotFoundException,
sedangkan pada saat menggunakan stream output, eksepsi tersebut akan
muncul jika file output tidak dapat terbentuk.
Selanjutnya akan dibahas tentang proses penulisan data ke dalam file.
Untuk melakukan hal ini, kita perlu menggunakan method write(). Bentuk
umum dari method write() sebagai berikut :
void write(int nilaiByte)
8.3 Latihan
1. Membaca input data karakter
a. Kode program
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {

public static void main(String[] args) throws
IOException{
System.out.print("Masukkan sebuah karakter: ");

char KarakterInput;
InputStreamReader isr = new
InputStreamReader(System.in);
KarakterInput = (char) br.read();
System.out.println("Karakter yang dimasukan adalah \'"
+ KarakterInput + "\'");
}
}
159
b. Output program

c. Penjelasan
Program di atas merupakan contoh program membaca input
data karakter. Pada program tersebut pertama akan mengimport
package agar program dapat dijalankan. Pada program tersebut
mula - mula program akan menampilkan tampilan masukan sebuah
karakter yang nantinya akan di simpan di dalam variabel char
KarakterInput. Setelah itu program akan menangkap data yang di
inputkan dengan perintah KarakterInput = (char) br.read().
Setelah itu program akan menampilkan karakter yang telah di
inputkan sebelumnya.
2. Membaca input data String
a. Kode program
public class Main {

IOException{
System.out.print("Masukkan nama Anda: ");

String namaInput;
160

namaInput = br.readLine();
System.out.println("Halo " + namaInput + "...");
System.out.println("Semoga Anda Sukses Selalu..");
}
}
b. Output program

c. Penjelasan
Program di atas merupakan contoh program membaca input
data string. Pada program tersebut pertama program akan
mengimport package agar program dapat dijalankan dan tidak
terjadi error. Pada program tersebut mula - mula program akan
menampilkan tampilan Masukan Nama Anda : yang nantinya akan
disimpan di dalam variabel char namaInput. Setelah itu program
akan menangkap inputan data yang telah dimasukan sebelumnya
dengan perintah setelah itu program akan menampilkan data
yang telah di inputkan sebelumnya.
161
3. Membaca input data numerik

a. Kode program
public class Main {

IOException{
System.out.print("Masukkan sebuah bilangan bulat : ");

String temp;
int bilanganInput = 0;
temp = br.readLine();
try{
bilanganInput = Integer.parseInt(temp);
}catch (NumberFormatException nfe) {
System.out.println("Nilai yang dimasukkan" + "bukan
bilangan bulat");
System.exit(1);
}
System.out.println("Bilangan yang anda masukkan adalah
" + bilanganInput);
}
}
162
b. Output program

c. Penjelasan
Program di atas merupakan contoh program input data numerik.
Pada program tersebut pertama program akan mengimport package
agar program dapat dijalankan dan tidak terjadi error. Pada
program tersebut mula - mula program akan menampilkan tampilan
Masukan sebuah bilangan bulat : yang nantinya akan disimpan di
dalam variabel bilanganInput. Data tersebut kemudian akan
dianggap sebagai string. Setelah itu program akan menangkap data
yang telah diinputkan sebelumnya menggunakan perintah temp =
br.readLine(). Kemudian program akan mengkonversi data dari
string ke integer.
4. Pembacaan data dari file
a. Kode program
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Main {

IOException{
163
FileInputStream finput=null;
int data;
try{
finput = new
FileInputStream("G:\\Project\\PRAKTIKUM\\OOP\\BAB
8\\Latihan 1\\src\\com\\prakpbo\\input.txt");
}catch(IOException e){}
try{
while((data = finput.read())!=-1){
System.out.print((char) data);
}
try{
finput.close();
}
}
b. Output program
Gambar 8. 5 Isi file input.txt

164
c. Penjelasan
Program di atas merupakan contoh program dasar - dasar baca
tulis file pada program java. Pada program tersebut pertama akan
mengimport package agar program dapat dijalankan dan tidak
terjadi error. Pada program tersebut terdapat statemen try dan
catch. Mula - mula program akan membaca dan membuka file
input.txt. Apabila file yang ada di dalam direktori tersebut ada, maka
program akan menjalankan statement try dan jika tidak ada maka
program akan menjalankan statement catch. Kemudian program
akan membuka dan membaca file tersebut dan menampilkanya ke
dalam layar console.
5. Menulis data ke dalam file
a. Kode program
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Main {

IOException{
FileOutputStream foutput = null;

String data = "Hello Guys ! \n Semoga \nSukses
selalu..";
try {
foutput = new
165
FileOutputStream("G:\\Project\\PRAKTIKUM\\OOP\\BAB
8\\Latihan 1\\src\\com\\prakpbo\\output.txt");
} catch (FileNotFoundException fnfe) {
System.out.println("File tidak dapat terbentuk.");
return;
}
try {
for (int i = 0; i < data.length(); i++) {
foutput.write((int) data.charAt(i));
}
} catch (IOException ioe) {
System.out.println(ioe.getMessage());
return;
}
try {
foutput.close();
} catch (IOException ioe) {
}
}
}
b. Output program
Gambar 8. 6 Isi file output.txt yang telah dibuat

166
c. Penjelasan
Program di atas merupakan contoh program untuk membuat file.
Pada program tersebut pertama akan mengimport package agar
program dapat dijalankan dan tidak terjadi error. pada program
tersebut terdapat statement try dan catch. Pada program tersebut
mula - mula program akan menginisialisasi String data =
"Hello Guys ! \n Semoga \n Sukses selalu..". Setelah

itu program akan membuka file, apabila terjadi kesalahan maka
program akan menjalankan statement try dan jika terjadi kesalahan
maka program akan menjalankan statement catch. Setelah itu
program kemudian akan menulis data String sebelunya ke dalam
file. Kemudian file akan tercreate dengan nama output.txt.
8.4 Tugas
1. Buatlah program aplikasi file yang bisa melakukan beberapa operasi
berikut :
- Buat file dengan dua extensi .txt dan .dat
- Mengecek file dalam direktori tertentu
- Mengisi file
- Menampilkan isi file
- Merename nama file
- Menghapus file
Jawab:
a. Kode program
// class Main
import java.io.*;
public class Main {

static Scanner input = new Scanner(System.in);
167
static InputStreamReader inputUser = new

static BufferedReader br = new
BufferedReader(inputUser);
static void cekFile(String file){
System.out.print("\nIngin mengecek file? (ya/tidak) =

");
String cek = input.next();
if (cek.equals("ya")){
File fileInput = new File(file + ".txt");
File fileInputUser = new File(file + ".dat");
if (fileInput.exists() || fileInputUser.exists()){
System.out.println("File ditemukan");
}else{
System.out.println("File tidak ditemukan");
}
}
}
static void isiFile(BufferedWriter

bufferedCharOutput){
try {
System.out.print("\nIsi file? (ya/tidak) = ");
String isi = input.next();
if (isi.equals("ya")) {
System.out.print("Masukan isi file = ");
String name = br.readLine();
bufferedCharOutput.write(name);
bufferedCharOutput.flush();
}
System.out.println("File gagal diisi");
}
168
}
static void tampilkanFileTxt(String namaFile){
try {
System.out.print("\nTampilkan isi file? (ya/tidak) =
");
FileReader fileReader = new FileReader(namaFile +

".txt");
BufferedReader bufferedReader = new
BufferedReader(fileReader);
System.out.println("isi file " + namaFile + ".txt = "
+ bufferedReader.readLine());
}
System.out.println("isi file gagal ditampilkan");
}
}
static void tampilkanFileDat(String namaFile){
try {
System.out.print("\nTampilkan isi file? (ya/tidak) =
");
FileReader fileReaderUser = new FileReader(namaFile +

".dat");
BufferedReader bufferedReader = new
BufferedReader(fileReaderUser);
System.out.println("isi file " + namaFile + ".dat = "
+ bufferedReader.readLine());
}
169

System.out.println("isi file gagal ditampilkan");
}
}
IOException {

String nameFile;
try {
System.out.println("Buat file ");
System.out.println("1. .txt ");
System.out.println("2. .dat");
System.out.print("Pilih opsi = ");
int pilih = input.nextInt();
if (pilih == 1){
System.out.print("Masukan nama file = ");
nameFile = input.next();
FileWriter charOutput = new FileWriter(nameFile +

".txt");
BufferedWriter bufferedCharOutput = new
BufferedWriter(charOutput);
cekFile(nameFile);
isiFile(bufferedCharOutput);
tampilkanFileTxt(nameFile);
}else if(pilih == 2){

System.out.print("Masukan nama file = ");
nameFile = input.next();
FileWriter charOutput = new FileWriter(nameFile +

".dat");
170
BufferedWriter bufferedCharOutput = new

BufferedWriter(charOutput);
cekFile(nameFile);
isiFile(bufferedCharOutput);
tampilkanFileDat(nameFile);
}

System.out.println(e);
}
}
}
// class RenameFile
import java.io.File;
public class RenameFile{
static void renameFileTxt(String namaFile){

try{
System.out.print("\ningin mengganti nama file?
(ya/tidak) = ");
File file = new File(namaFile + ".txt");
System.out.print("Nama Baru file : ");
String name = input.next();
File fileNew = new File(name + ".txt");
if(file.renameTo(fileNew)){
System.out.println("Nama file berhasil diubah");
171
}else{
System.out.println("Nama file gagal diubah");
}
}
System.out.println("nama file gagal diubah");
}
}
static void renameFileDat(String namaFile){

try{
System.out.print("\ningin mengganti nama file?
(ya/tidak) = ");
File file = new File(namaFile + ".dat");
System.out.print("Nama Baru file : ");
String name = input.next();
File fileNew = new File(name + ".dat");
if(file.renameTo(fileNew)){
System.out.println("Nama file berhasil diubah");
}else{
System.out.println("Nama file gagal diubah");
}
}
System.out.println("nama file gagal diubah");
}
}

172
System.out.print("Masukan nama file yang ingin diganti

= ");
String nameFile = input.next();
System.out.println("\n1. .txt ?");

System.out.println("2. .dat ?");
System.out.print("pilih satu opsi = ");
int opsi = input.nextInt();
if (opsi == 1){
renameFileTxt(nameFile);
}else if (opsi == 2){
renameFileDat(nameFile);
}
}
}
// class DeleteFile
import java.io.File;
public class DeleteFile {
static void deleteTxt(String nameFile){

File file = new File(nameFile + ".txt");
if (file.delete()){
System.out.println("File berhasil dihapus");
}else{
System.out.println("File gagal dihapus");
}
}
static void deleteDat(String nameFile){

File file = new File(nameFile + ".dat");
173
if (file.delete()){
System.out.println("File berhasil dihapus");
}else {
System.out.println("File gagal dihapus");
}
}

System.out.print("Masukan nama file yang ingin dihapus

= ");
String nameFile = input.next();
System.out.println("\n1. .txt ?");

System.out.println("2. .dat ?");
System.out.print("pilih satu opsi = ");
int opsi = input.nextInt();
if (opsi == 1){
deleteTxt(nameFile);
}else if (opsi == 2){

deleteDat(nameFile);
}
}
}
174
b. Output program
Gambar 8. 7 Membuat file input.txt, mengecek, mengisi, dan menampilkan file
Gambar 8. 8 File input.txt
Gambar 8. 9 Merename nama file input.txt
Gambar 8. 10 Nama file yang telah direname

175
Gambar 8. 11 Menghapus file inputUser.txt
Gambar 8. 12 File inputUser.txt berhasil dihapus
Gambar 8. 13 Membuat file output.dat, mengecek, mengisi, dan menampilkan

file
176
Gambar 8. 14 File output.dat
Gambar 8. 15 Merename file output.dat
Gambar 8. 16 Nama file yang telah direname
Gambar 8. 17 Menghapus file outputUser.dat
Gambar 8. 18 File outputUser.dat berhasil dihapus

177
c. Penjelasan
Program di atas adalah program untuk membuat file, mngecek,
mengisi, menampilkan, merename, dan menghapus file. Yaitu file
yang bisa dibuat adalah extensi .txt dan .dat. Sehingga, saat
dijalankan akan menghasilkan output seperti pada gambar di atas.
8.5 Kesimpulan
Pada BAB VIII kita telah mempelajari proses input dan Output. Program
Java melakukan proses I/O melalui stream. Stream adalah sebuah abstraksi
yang dapat memberikan atau mendapatkan informasi. Stream dapat
dihubungkan dengan peralatan fisik yang terdapat dalam system I/O Java,
seperti: keyboard, file, layar console, dan yang lainnya. Sesuai dengan
namanya, stream byte digunakan untuk memberikan atau menyimpan
informasi data dalam bentuk byte, misalnya untuk menulis dan membaca
file biner. Sedangkan stream karakter digunakan untuk melakukan proses
I/O yang melibatkan data - data dalam bentuk karakter, misalnya pada saat
kita melakukan proses baca/ tulis ke file teks. Cara kerja stream selalu sama,
meskipun jenis peralatan yang terhubung dengan stream tersebut berbeda.
Ini artinya, sebuah stream input dapat mengabstraksikan beberapa tipe
peralatan fisik, seperti: keyboard, file, atau socket jaringan. Begitu pula
dengan stream Output, yang dapat dihubungkan dengan layar console, file,
maupun koneksi jaringan. Terdapat dua buah tipe stream yang dapat
digunakan, yaitu: stream byte dan stream karakter.
DAFTAR PUSTAKA
Abdillah, A. M. (2018). input dan Output Pada Java.

https://www.slideshare.net/ewinrosseneriaxl/modul-java-io
Baldasaro, M. M. (2018). PEWARISAN. 7, 219–232.
Primakara, S. (2015). Modul praktikum praktikum pemrograman berorientasi
objek. 20.
Rizki, I. (2017). Makalah_Polimorfisme_di_Java.
Sudarso, I. (2016). Tipe data, Variabel, Operator.
Zakaria, A. (2017). ARRAY Pada JAVA.
LEMBAR ASISTENSI
PRAKTIKUM : Pemrograman Berorientasi Objek
NAMA : Nur Muhammad Syaifuddin
NIM : 32601900026
KELOMPOK : -
No KETERANGAN TANDA TANGAN
1 ……………..
2 ……………..
PRETEST
1 ……………..
2 ……………..
ASISTENSI LAPORAN
1 28 November BAB 1 dan 2,

2020 kesimpulan ditambahi
jangan terlalu sedikit
2 28 November BAB 1 dan 2 ACC
2020
3 7 Desember BAB 3 dan 4 ACC
2020
4 12 Desember BAB 5, 6, 7, dan 8
2020 ACC
5 ……………..
6 ……………..
7 ……………..
8 ……………..
9 ……………..
10 ……………..
11 ……………..
12 ……………..
13 ……………..
14 ……………..
15 ……………..
16 ……………..
17 ……………..
18 ……………..
19 ……………..
20 ……………..
LAMPIRAN

(Acc) 32601900026-Nur Muhammad Syaifuddin (Pemrograman Berorientasi Objek)

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

(Acc) 32601900026-Nur Muhammad Syaifuddin (Pemrograman Berorientasi Objek)

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN PRAKTIKUM

PEMROGRAMAN BERORIENTASI OBJEK

PRODI TEKNIK INFORMATIKA

Telah disetujui sebagai syarat untuk memenuhi mata kuliah Pemrograman

Laboran Dosen Praktikum

WerdhaWilubertha H, S.Kom Sam Farisa Chaerul Haviana, ST., M.Kom

Tanpa lupa penulis mengucapkan terima kasih kepada :

Penulis menyadari bahwa dalam penyusunan laporan ini masih terdapat

Semarang, 13 Desember 2020

Nur Muhammad Syaifuddin

HALAMAN JUDUL .............................................................................................. i

Gambar 1. 1 Tampilan awal netbeans IDE ............................................................. 3

Tabel 1. 1 Operator relasi ...................................................................................... 13

1.2 Dasar Teori

8. JCreator ditulis dalam C/C++ sehingga lebih cepat dan menggunakan

1.3.3 Nebeans IDE 8

Gambar 1. 1 Tampilan awal netbeans IDE

Gambar 1. 2 Membuat projek baru

Gambar 1. 3 Memilih kategori projek

Gambar 1. 4 Memberi nama projek

menambahkan .Main atau .Java, NetBeans akan secara otomatis

Gambar 1. 5 Tampilan awal projek hello_word

1.3.4 Program Sederhana

Gambar 1. 6 Program utama hello_word

Gambar 1. 7 Hasil eksekusi program hello_word

1.3.5 Penambahan Komentar

Gambar 1. 8 Penambahan komentar pada program

public class Main {

System.out.println("Nama\t: Nur Muhammad Syaifuddin");

Scanner input = new Scanner(System.in);

Gambar 1. 9 Output tugas 1

2.2 Dasar Teori

2.2.2 Tipe Data

public class Main {

System.out.println("Nama\t: Nur Muhammad Syaifuddin");

int A = 100, B = 30;

System.out.println("penjumlahan " + A + " + " + B + "

Gambar 2. 1 Output latihan 1 operasi aritmatika

System.out.println("Nama\t: Nur Muhammad Syaifuddin");

int A = 100, B = 30;

System.out.println(A + " > " + B + " => " + lb);

Gambar 2. 2 Output latihan 2 operasi relasi

Gambar 2. 3 Output latihan 3 operasi logika

public class Main {

static void displayHasil(float a, String operator,

public static void main (String[]args){

Scanner udin = new Scanner (System.in);

calculate(a, operator, b);

Gambar 2. 4 Output tugas 1 operator tambah

Gambar 2. 5 Output tugas 1 operator kurang

Gambar 2. 6 Output tugas 1 operator kali

Gambar 2. 7 Output tugas 1 operator bagi

Gambar 2. 8 Output tugas 1 jika operator tidak ada

public class Main {

static void displayOperasiLogika(String operator){

static void operasiOr(boolean a, boolean b){

static void operasiAnd(boolean a, boolean b){

static void operasiNot(boolean a){

public static void main(String [] args){

Scanner input = new Scanner(System.in);

System.out.print("Pilih Operator Logika = ");

Gambar 2. 9 Output tugas 2 operator AND

Gambar 2. 10 Output tugas 2 operator OR