Pembelajaran Java Dasar

Modul Pelatihan Java Dasar
2022
Java Dasar
Mata Kuliah : Pemrograman Berorientasi Objek
Kelas : IT-301
Program Studi : PJJ Informatika
Nama : Hendro Gunawan
NIM : 200401072103
Dosen : Catur Nugroho, S.Kom., M.Kom

i
Kata Pengantar
Alhamdulillah...,puji syukur penulis panjatkan kepada Allah SWT. Makalah dengan judul Java
Dasar ini telah berhasil diselesaikan. Makalah ini merupakan tugas 1 untuk mata kuliah
Pemrograman Berorientasi Objek (PBO) khususnya yang menggunakan bahasa pemrograman
berbasis Java. Konsep dari makalah ini berisi tentang pemahaman OOP (Objek Oriented
Programing) seperti persiapan peralatan dalam mempelajari Java yang meliputi peralatan-
peralatan yang diperlukan, Java Development Kit, serta NET Bean IDE guna kelancaran dalam
mengeksekusi program Java dibutuhkan aplikasi terbaru dari vendor penyedia yang dapat
diunduh secara gratis di internet. Pemahaman Dasar-dasar Pemrograman Java yang meliputi
Program Hello World, Tipe data yang digunakan oleh Java , Variabel yang digunakan untuk
menampung sebuah data, kemudian Operator yang di dalamya terdiri dari operator aritmetika,
operator penugasan, operator pembanding dan lain sebagainya, Pemrograman Berorientasi
Objek yang mencakup Objek, Class, Paket, Interface, Iner Class dan Kelas POJO/Java Bean,
kemudian Penanganan Kesalahan, yang di dalamnya mencakup antara lain Penanganan
Kesalahan menggunakan metode try and catch kemudian metode try and catch serta finally
dengan contoh-contoh kode program Java, Membuat Penanganan Secara Bertingkat untuk
mengatasi error pada Java, Melontarkan Exception, membuat kelas exception, membuat kelas
runtime exception serta blok finally yang semua itu merupakan cara penanganan kesalahan
yang kerap terjadi di dalam pemrograman bahasa Java. Di bab ini sangat menarik karena kita
diajak untuk dapat mengatasi segala macam error exception handling sehingga apabila ada
program yang tidak bisa berjalan dengan baik kita dapat menggunakan metode-metode dalam
Java untuk memecahkan masalah tersebut. Dijelaskan juga bahwa sebelum mengenal Java
lebih dalam kita diharuskan untuk memahami terlebih dahulu apa itu objek dan apa itu class
sebagai dasar dalam membuat program yang berhubungan dengan kehidupan di sekitar kita
seperti class Student, class Vehicle, class Mahasiswa dan Dosen, class Komputer dan Laptop
class Hewan, class Manusia dan lain sebagainya, semua itu dapat diimplementasikan ke dalam
bahasa Java. Untuk membuat program Java diperlukan tipe data-tipe data yang dibutuhkan
dalam pendeklarasian suatu objek sehingga kelas dapat berjalan sebagaimana yang diharapkan
supaya tidak terjadi error. Di dalam Pemrograman Berorientasi Objek terdapat pewrisan atau
inheritance yang berfungsi untuk mencegah terjadinya reuse atau kerangkapan data dan serta
pembuatan class-class baru. Di dalam Java juga terdapat encapsulasi yang merupakan
penggabungan atribut dan method kedalam sebuah kelas. Biasanya atribut dan method
dideskripsikan secara terpsah pada pemrograman prosedural. Selain itu enkapsulasi juga
dihubungkan dengan pemberian hak akses pada kelas ataupun anggota dari sebuah kelas
(atribut dan method). Selain itu pemberian hak akses juga merupakan bagian penting dari
proses enkapsulasi. Hak akses diberikan pada tiga hal yaitu pada kelas, atribut, dan method.
Ada tiga jenis hak akses yang bisa digunakan di Java, yaitu: Public yang mana hak akses ini
digunakan apabila atribut atau method ingin bisa diakses di kelas yang lain. Private, Hak akses
ini digunakan apabila atribut atau method hanya ingin diakses pada kelas pemilik. Protekted,
hak akses ini digunakan pada konsep pewarisan. Demikian sekelumit penjelasan mengenai
makalah yang saya buat semoga meberikan manfaat dan faedah bagi kita semua dan atas
perhatiannya saya ucapkan terima kasih.
Gresik, 20 November 2022
Penulis,
Hendro Gunawan

ii
Daftar Isi
Kata Pengantar............................................................................................................................i
Daftar Isi....................................................................................................................................ii
1. Persiapan................................................................................................................................1
1.1 Peralatan yang diperlukan................................................................................................1
1.2 Java Development Kit......................................................................................................1
1.3 Java Runtime Environtment.............................................................................................1
1.4 NetBeans IDE...................................................................................................................1
2. Dasar-Dasar Pemrograman Java............................................................................................2
2.1 Program Hello World.......................................................................................................2
2.2 Tipe Data..........................................................................................................................2
2.3 Variabel....................................................................................................................... ....3
2.4 Operator............................................................................................................................3
2.5 Percabagan........................................................................................................................6
2.6 Perulangan........................................................................................................................9
2.7 Array...............................................................................................................................14
3. Pemrograman Berorientasi Objek........................................................................................15
3.1 Object.............................................................................................................................16
3.2 Class...............................................................................................................................17
3.3 Paket...............................................................................................................................36
3.4 Interface..........................................................................................................................37
3.5 Inner Class......................................................................................................................39
3.6 Kelas POJO/ Java Bean..................................................................................................42
4. Penanganan Kesalahan.........................................................................................................43
4.1 Menangkap Kesalahan...................................................................................................44
4.2 Penanganan Secara Bertingkat.......................................................................................46
4.3 Melontarkan Exception..................................................................................................46
4.4 Membuat Kelas Exception.............................................................................................47
4.5 Membuat Kelas Runtime Exception..............................................................................48
4.6 Blok Finally....................................................................................................................49
5. Kelas-Kelas..........................................................................................................................51
5.1 String..............................................................................................................................51
5.2 Date................................................................................................................................53
5.3 Calendar.........................................................................................................................53
Tentang Penulis........................................................................................................................56

1
1. Persiapan
1.1 Peralatan Yang Diperlukan
Pada Pelatihan Java Dasar ini, peralatan yang diperlukan adalah:
1. Java Development Kit versi 1.6 ke atas.
2. Java Runtime Environtment versi 1.6 ke atas.
3. Net Beans IDE versi 6.9 ke atas, Notepad, Notepad ++, Eclipse, EditPlus, Jcreator
Lite/Pro, IntType,Visual Studio.
1.2 Java Development Kit
Java Development Kit merupakan perangkat lunak yang digunakan untuk melakukan proses
kompilasi dari dari kode Java menjadi bytecode yang dapat dimengerti dan dapat dijalankan
oleh Java Runtime Environtment.
Java Development Kit wajib terinstal pada komputer yang akan melakukan proses pembuatan
aplikasi berbasis Java. Namun Java Development Kit tidak wajib terinstal di komputer yang
akan menjalankan aplikasi yang dibangun menggunakan Java. Java Development Kit (JDK)
dapat diunduh secara gratis di http://www.oracle.com/java/technologies/downloads/#java8
Di sini kita bisa mendownload JDK untuk versi Linux, MaxOS, dan Windows versi terbaru.
Saat penulis menulis makalah ini versi yang digunakan adalah versi JDK-19, mungkin setelah
ini ada versi terbaru yang dikeluarkan oleh Oracle.
1.3 Java Runtime Environtment
Java Runtime Environtment perangkat lunak yang digunakan untuk menjalankan aplikasi yang
dibangun menggunakan Java. Versi JRE harus sama atau lebih tinggi dari JDK yang digunakan
untuk membangun aplikasi agar aplikasi dapat berjalan sesuai dengan yang diharapkan.
1.4 NetBeans IDE merupakan perangkat lunak yang digunakan untuk membangun perangkat
lunak yang lain. NetBeans IDE dapat digunakan untuk membangun perangkat lunak berbasis
Java Standard Edition, Java Enterprise Edition, Java Micro Edition, Java FX, PHP, C/C++,
Ruby, Groovy dan Pyton.

2
2. Dasar-Dasar Bahasa Pemrograman Java
2.1 Pemrograman Hello World
1 public class HelloWorld {
2 public static void main(String[]args) {
3 System.out.println("Hello World");
4 }
5 }
Hasil setelah di Compile:
Pada kode di atas, kita telah membuat sebuah program sederhana yang menampilkan tulisan
“Hello World” pada console. Terdapat beberapa aturan dalam membuat program dalam Java
yaitu:
1. Nama file harus sama dengan kelas program. Misal pada kode di atas nama kelasnya
adalah HelloWorld, maka nama file harus HelloWorld.java.
2. Hanya boleh terdapat satu kelas public pada sebuah file.
3. Kelas yang menjadi program harud memiliki metode public static void main(String[ ]args).
4. Terminal pada Java menggunakan tanda ; (titik koma).
2.2 Tipe Data
Terdapat beberapa tipe data primitive yang ada di Java yaitu:
Tipe Data Keterangan
Boolean True atau False
Char Jarakter
Byte -128 - 127
Short -32768 - 32767
Int -2147483648 - 2147483647
Long -9223372036854775808 - 9223372036854775807

3
Double 4.9E-324 – 1.7976931348623157E308
Float 1.4E-45 – 3.4028235E38
String bukanlah merupakan tipe data di Java, String merupakan Object. Namun string memiliki
keunikan yaitu String dapat langsung dibuat tanpa harus membuat Object.
2.3 Variabel
Variabel merupakan sesuatu yang digunakan untuk menampung sebuah data.
Sebuah variabel harus ada dalam sebuah kelas atau metode. Pembuatan sebuah variabel di Java
terlihat pada kode di bawah ini:
1 Tipevariabel namavariabel;
Tipe variabel dapat berupa tipe data atau kelas, misal:
1 int nilai;
2 char indexNilai;
Untuk menambahkan nilai ke sebuah variabel, maka dapat menggunakan tanda = (sama
dengan), misal jika kita akan menambahkan nilai 100 pada variabel nilai dan A pada variabel
indexNilai, maka dapat terlihat pada kode di bawah ini.
1 int nilai;
2 char indexNilai;
3
4 nilai = 100;
5 indexNilai = 'A'
Atau dapat juga langsung saat pembuatan sebuah variabel.
1 int nilai = 100;
2 char indexNilai = 'A'
Syarat-syarat penamaan variabel adalah:
1. Harus diawali dengan huruf.
2. Tidak boleh terdapat karakter unik seperti @, #, %, dan lain-lain.
3. Tidak boleh mengandung karakter putih (spasi, enter, tab).
2.4 Operator
Operator merupakan sebuah karakter khusus yang digunakan untuk menghasilkan suatu nilai.

4
2.4.1 Operator Aritmatika
Operator Keterangan
+ Penjumlahan
- Pengurangan
* Perkalian
/ Pembagian
% Sisa pembagian
Contoh:
1 int a = 10;
2 int b = 3;
3 int c = a / b;
4
5 System.out.println(c);
Hasil dari kode program di atas adalah 3 bukan 3.333. Hal ini dikarenakan dalam Java jika kita
melakukan operasi pembagian dengan tipe data integer, maka hasilnya pun akan integer, dan
integer tidak dapat mengandung nilai koma dalam Java, sehingga jika akan melakukan
perkalian yang menghasilkan nilai koma, maka harus menggunakan type data double atau float.
2.4.2 Operator Penugasan
Operator Keterangan
= Pemberian nilai
+ = Penambahan bilangan
- = Pengurangan bilangan
* = Perkalian bilangan
/ = Pembagian bilangan
% = Pemerolehan sisa bagi
Contoh
1 int a = 10;
2 a += 5;
3
4 System.out.println(a);
Hasil dari operasi + = tersebut adalah 15. Ini dikarenakan a + = 5 sama dengan a = a + 5,
dikarenakan a sebelumnya adalah 10, maka itu berarti a = 10 + 5.
Jika akan melakukan penambahan atau pengurangan dengan nilai 1, maka dapat dengan mudah
menggunakan karakter + + untuk penambahan atau - - untuk pengurangan, misal:

5
1 int a = 10;
2 a--;
3
Maka hasilnya adalah 9.
2.4.3 Operator Pembanding
Operator Keterangan
= = Sama dengan
! = Tidak sama dengan
> = Lebih dari sama dengan
< = Kurang dari sama dengan
> Lebih dari
< Kurang dari
Hasil dari operasi pembanding adalah boolean. True jika operasi pembanding tersebut benar,
dan false jika operasi pembanding tersebut salah, misal:
1 boolean a = 10 == 100;
2
Hasil dari program di atas adalah false, karena memang 10 tidak sama dengan 100.
2.4.4 Operator Logika
Operator Keterangan
&& Dan
| | Atau
Operator logika digunakan untuk membentuk suatu keadaan dari dua atau lebih kondisi
tertentu, operator logika biasanya digabungkan dengan operator pembanding. Hasil dari
operator logika adalah boolean.
Hasil operasi logika dengan menggunakan && adalah sebagai berikut:
Operasi 1 Operasi 2 Hasil
False False False
False True False
True False False
True True True
Hasil operasi logika dengan menggunakan | | adalah sebagai berikut.

6
Operasi 1 Operasi 2 Hasil
False False False
False True True
True False True
True True True
Contoh
1 boolean hasil = 10 == 100 || 100 == 100;
2
3 System.out.println(hasil);
Maka hasilnya adalah true.
2.5 Percabangan
2.5.1 Percabangan If
Pernyataan if merupakan salah satu bentuk pernyataan yang berguna untuk mengambil
keputusan terhadap sebuah kemungkinan. Bentuk pernyataan if berupa:
1 if (kondisi) {
2 // yang akan dijalankan
3 }
Contoh
1 int nilai = 10;
2
3 if(nilai == 10) {
4 System.out.println("Sepuluh");
5 }
Jika program di atas dijalankan, maka hasil adalah tulisan “Sepuluh” karena kondisi pada if
bernilai true, jika kondisi bernilai salah, misal nilai = = 100, maka program tidak akan
menghasilkan tulisan apa-apa.
2.5.2 Percabangan if-else
Percabangan if-else merupakan percabangan yang sama dengan percabangan if namun
memiliki kondisi false, artinya jika kondisi pada if tidak terpenuhi maka perintah pada else
akan dijalankan. Bentuk pernyataan if-else berupa:
1 if (kondisi) {

7
2 // jalnakan jika kondisi true
3 } else {
4 // jalankan jika kondisi false
5 }
Misal
1 int nilai = 8;
2
3 if(nilai == 10) {
4 System.out.println("Sepuluh");
5 } else {
6 System.out.println("Bukan Sepuluh");
7 }
Jika program di atas dijalankan, maka hasilnya adalah tulisan “Bukan Sepuluh”, hal ini
dikarenakan nilai 8, bukan 10.
2.5.3 Percabangan if bersarang
Percabangan if bersarang merupakan gabungan beberapa if dan dapat pula digabung dengan if-
else. Bentuk pernyataan if bersarang adalah sebagai berikut:
1 if(kondisi1) {
2 // perintah kondisi1
3 } else if(kondisi2) {
5 } else if(kondisi3) {
7 } else {
8 // perintah jika semua kondisi tidak ada yang benar
9 }
Misal
1 public class Nilai {
2 public static void main (String[]args) {
3 int nilai = 9;
4 char index;
5
6 if (nilai >= 8 ) {
7 index = 'A';
8 } else if (nilai >= 7) {
9 index = 'B';
11 index = 'C';

8
13 index = 'D';
14 } else {
15 index = 'E';
16 }
17 System.out.println (index);
18 }
19 }
Jika program di atas dijalankan, maka hasilnya adalah ‘A’
2.5.4 Percabangan switch-case
Percabangan switch-case merupakan percabangan yang kondisinya hanya dapat menggunakan
perbandingan = = (sama dengan). Bentuk pernyataan percabangan switch-case adalah sebagai
berikut:
1 switch (variabel) {
2 case nilai1;
3 // jalankan instruksi
4 break; // hentikan
5 case nilai2;
8 case nilai3;
11 case nilai4;
14 default;
16 break // hentikan
17 }
Pada percabangan switch pertama, diperlukan sebuah variabel, setelah itu bada bagian case
dibandingkan, jika sama, maka instruksi akan dijalankan sampai menemui tanda break.
Misal

9
1 import java.util.Scanner;
2 public class Switch {
3 public static void main (String args[]) {
4
5 int hari = 5;
6
7 switch (hari) {
8 case 1:
9 case 2:
10 case 3:
11 case 4:
12 case 5:
13 case 6:
14 System.out.println("Bukan Hari Libur");
15 break;
16 case 7:
17 System.out.println("Hari Libur");
18 break;
19 default:
20 System.out.println("Hari Tidak Diketahui");
21 break;
22 }
23 }
24 }
Jika program di atas dijalankan, maka akan menghasilkan tulisan “Bukan Hari Libur”.
2.6 Perulangan
2.6.1 Perulangan while
Pernyataan while berguna untuk melakukan proses perulangan untuk sebuah kondisi, selama
kondisi tersebut bernilai benar (true), maka perulangan akan terus berjalan, dan terhenti ketika
kondisi bernilai salah (false). Bentuk pernyataan while seperti berikut ini.
1 while (kondisi) {
2 // isi instruksi
3 }

10
Misal
2 class While {
4
5 int jumlah = 1;
6
7 while (jumlah <= 10) {
8 System.out.println (jumlah);
9 jumlah++; // menaikkan jumlah
10 }
11 }
12 }
Jika program tersebut dijalankan, maka hasilnya adalah tulisan dari no 1 sampai dengan 10.
Dan saat jumlah bernilai 11, maka perulangan akan terhenti dikarenakan kondisi bernilai false
(11 < = 10).
2.6.2 Perulangan do-while
Perulangan do-while merupakan perulangan yang hampir mirip dengan perulangan while
namun perbedaannya, pada perulangan do-while, maka minimal instruksi akan dijalankan
sekali. Bentuk pernyataan do-while sebagai berikut:
1 do {
2 // isi instruksi
3 } while (kondisi);
Misal

11
2 class DoWhile {
4 int jumlah = 100;
5
6 do {
7 System.out.println (jumlah);
8 jumlah ++; // menaikkan jumlah
9 } while (jumlah <= 10);
10 }
11 }
Jika program tersebut dijalankan, maka akan menghasilkan keluaran 100, artinya walaupun
kondisi salah, namun minimal isi instruksi akan dijalankan sekali, hal ini dikarenakan proses
do-while berbeda dengan while, dimana do-while pertama melakukan instruksi baru mengecek
kondisi, sedangkan while pertama mengecek kondisi baru melakukan instruksi.
2.6.3 Perulangan for
Perulangan for merupakan perulangan yang memiliki variabel untuk melakukan
pengkondisian, berbeda dengan while dan do-while yang kita harus membuat sebuah variabel
di luar untuk melakukan pengkondisian, pada perulangan for, ditempatkan sebuah blok untuk
membuat variabel dan melakukan proses pengkondisian. Bentuk pernyataan for seperti berikut:
1 for (inisialisasi; kondisi; penaikan/penurunan) {
2 instruksi
3 }
Misal kita akan menampilkan angka dari 1 = 100, maka dapat menggunakan perulangan for.
2 class For {
4 for (int i = 1; i <= 10; i ++) {
5 System.out.println (i);
6 }
7 }
8 }

12
Hasil compile program adalah sebagai berikut.
2.6.4 Perintah Break
Perintah break merupakan perintah yang dapat digunakan untuk menghentikan proses
perulangan, misal jika kita membuat program seperti berikut:
2 class Break {
4 for (int i = 1; i <=10; i ++) {
5 System.out.println (i);
6 if(i == 5) {
7 break;
8 }
9 }
10 }
11 }
Maka program hanya akan menampilkan angka dari 1 sampai 50, karena pada saat i mencapai
5, program dihentikan oleh perintah break.

13
2.6.5 Perintah Continue
Perintah continue dapat digunakan untuk meloncati sebuah perulangan, maksudnya adalah
instruksi yang seharusnya dapat dilewati, hal ini berarti instruksi tidak akan dijalankan.
Contohnya seperti pada program berikut.
1 class Continue {
3
4 int i;
5 for ( i = 1; i <= 10; i++) {
6 if (i % 2 == 0) {
7 continue;
8 }
9 System.out.println(i);
10 }
11 }
12 }
Jika program di atas dijalankan, maka hasilnya akan menampilkan angka-angka ganjil saja, hal
ini dikarenakan saat nilai i merupakan angka genap, maka perintah continue membuat program
tidak menampilkan angka genap.
2.7 Array
Array merupakan objek yang dapat digunakan untuk menyimpan sejumlah data. Data yang
dapat ditampung pada array dapat berupa tipe data ataupun kelas (objek).
2.7.1 Mendeklarasikan Array
Untuk membuat variabel array pun berbeda dengan membuat variabel biasanya yaitu sebagai
berikut:

14
1 TipeArray namaArray();
Dimana tipe array dapat berupa tipe data biasa seperti int, char, short, atau juga kelas seperti
String dan yang lainnya.
2.7.2 Membuat Array
Setelah mendeklarasikan array, maka perlu dibuat array nya terlebih dahulu, sebelum array
tersebut digunakan, caranya dengan menggunakan perintah new.
1 TipeArray namaArray[];
2
3 namaArray = new TipeArray [jumlah];
Dimana jumlah array merupakan jumlah data yang dapat ditampung oleh array.
2.7.3 Memanipulasi Data dalam Array
Setelah membuat Array, maka untuk melakukan proses manipulasi seperti menambahkan data
ke Array, mengubah data di Array ataupun mengakses data dalam Array, maka diperlukan
sebuah indeks, dimana saat membuat sebuah Array dengan jumlah data 5, maka hasilnya akan
terlihat seperti ini.
No Indeks
1 0
2 1
3 2
4 3
5 4
Artinya data ke 1 dapat diakses menggunakan indeks 0 dan seterusnya. Dan untuk melakukan
proses manipulasi data dalam array menggunakan indeks dapat digunakan dengan perintah:
1 namaArray[indeks];
Misal
1 class Array {
2 public static void main(String args[]){
3
4 int[] nilai;
5
6 nilai = new int[5];
7
8 nilai[0] = 23;
9 nilai[1] = 50;

15
10 nilai[2] = 34;
11 nilai[3] = 78;
12 nilai[4] = 90;
13
14 System.out.println( nilai[0] );
19
20 }
21 }
Berikut adalah hasil dari program di atas:
2.7.4 Array Multidimensi
Java mendukung pembuatan array multidimensi, maksudnya kita dapat menambahkan data
array ke dalam sebuah array, cara pembuatannya adalah sebagai berikut:
TipeArray namaArray[][] = new TipeArray[jumlah][jumlah];
3. Pemrograman Berorientasi Objek
Pemrograman berorientasi objek merupakan pemrograman yang menjadikan objek sebagai
komponen utama dalam sistem. Objek merupakan gabungan data dan fungsi, dimana sebuah
objek dibuat dari sebuah kelas.
Contoh
1 class BelajarJava {
3 class Komputer {
4 String processor = "Intel Core i9";
5 String cekKomputer() {
6 return "Ini berasal dari class Komputer";

16
7 }
8 };
9
10 class Laptop extends Komputer {
11 String merk = "Asus";
12 String cekLaptop() {
13 return "Ini berasal dari class Laptop";
14 }
15 };
16 Laptop laptopAndi = new Laptop();
17
18 System.out.println(laptopAndi.processor);
19 System.out.println(laptopAndi.merk);
20 System.out.println(laptopAndi.cekKomputer());
21 System.out.println(laptopAndi.cekLaptop());
22 }
23 }
Hasilnya setelah di compile adalah sebagai berikut:
3.1 Objek
Objek merupakan hasil dari sebuah kelas, jika diibaratkan objek adalah kue, maka kelas adalah
cetakan kuenya, dimana kue dibuat dengan menggunakan cetakan tersebut. Dan sebuah cetakan
kue dapat membuat beberapa kue, artinya sebuah kelas dapat membuat beberapa objek.
Untuk membuat objek dalam Java diperlukan sebuah perintah new, dimana cara pembuatannya
sama dengan pembuatan variabel.
class objek = new class();
Jika dalam kelas yang dibuat objek tersebut terdapat atribut, maka dapat dipanggil
menggunakan . (titik).
// mengubah atribut
objek.namaAtribut = value;
Jika dalam kelas tersebut memiliki sebuah fungsi (metode), maka dapat dipanggil
menggunakan . (titik) dan diakhiri dengan ().

17
// memanggil fungsi
objek.namaFungsi();
3.2 Class
Dalam Java, kelas didefinisikan menggunakan kata kunci class. Contoh class sederhana adalah
sebagai berikut:
1 class Manusia {
2 String nama;
3 }
Pada kode di atas, kelas yang telah dibuat adalah kelas manusia. Dan nama merupakan atribut
yang dimiliki kelas manusia tersebut. Contoh pembuatan objek untuk kelas manusia adalah
sebagai berikut:
1 // membuat objek manusia
2 Manusia manusia = new Manusia();
3
4 // mengubah nama objek manusia
5 manusia.nama = "Hendro Gunawan";
3.2.1 Metode
Dalam Java terdapat dua buah metode
1. Fungsi, merupakan metode yang memiliki nilai balik jika metode tersebut dipanggil, cara
pembuatan sebuah fungsi adalah dengan cara menentukan nilai baliknya, lalu membuat nama
metodenya.
2. Prosedur, merupakan metode yang tidak memiliki nilai balik, cara pembuatan prosedur sama
denagan fungsi namun bedanya, nilai baliknya menggunakan kata kunci void.
Contoh
1 class Manusia {
2 String nama;
3 // fungsi
4 String ambilNama() {
5 // untuk mengembalikan nilai gunakan kata kunci return
6 return nama;
7 }
8 // prosedur
9 void hapusNama() {
10 nama = "";
11 }
12 }

18
Pada kode di atas, kelas manusia memiliki 2 buah metode yaitu ambilNama() dan
hapusNama( ). Di mana ambilNama( ) merupakan sebuah fungsi karena mengembalikan nilai
String, sedangkan hapusNama() merupakan prosedur karena tidak mengembalikan nilai.
Saat membuat sebuah fungsi maka untuk mengembalikan nilainya, harus menggunakan kata
kunci return, diikuti nilai yang akan dikembalikannya. Untuk mengambil nilai balik dari fungsi
dapat dilihat pada contoh sebagai berikut.
2 manusia.nama = "Hendro Gunawan";
3
4 // mengambil nilai dari fungsi
5 String nama = manusia.ambilNama();
3.2.2 Parameter
Parameter merupakan data yang dapat ditambahkan dari luar metode, misal jika kita membuat
sebuah metode untuk mengubah nama pada kelas Manusia, maka pasti kita memerlukan nama
baru untuk menggantikan nama tersebut. Contoh parameter dapat terlihat pada kelas di bawah
ini:
1 class Manusia {
2
3 String nama;
4
5 // metode dengan parameter
6 void ubahNama (String namaBaru) {
7 nama = namaBaru;
8 }
9
10 String ambilNama () {
11 return nama;
12 }
13
14 void hapusNama () {
15 nama = "";
16 }
17 }
Contoh penggunaannya adalah sebagai berikut:
2 manusia.ubahNama("Hendro Gunawan");
3 String nama = manusia.ambilNama();

19
Saat kode di atas dieksekusi, maka variabel nama akan bernilai “Hendro Gunawan” sesuai
dengan nama baru yang telah ditambahkan lewat metode ubahNama(namaBaru);
Sebuah metode dapat memiliki satu atau lebih parameter, untuk menambahkan parameter,
dipisahkan menggunakan tanda , (koma). Contohnya adalah sebagai berikut:
1 class Manusia {
2
3 String nama;
4 String alamat;
5
6 // metode dengan lebih dari satu parameter
7 void ubahData (String namaBaru, String alamatBaru) {
8 nama = namaBaru;
9 alamat = alamatBaru;
10 }
11
12 // metode dengan satu parameter
13 void ubahNama (String namaBaru) {
14 nama = namaBaru;
15 }
16
17 String ambilNama() {
18 return nama;
19 }
20
21 void hapusNama() {
22 nama = "";
23 }
24 }
Contoh penggunaannya adalah sebagai berikut:
Manusia manusia = new Manusia();
manusia.ubahData("Hendro Gunawan", "Ngawi");
3.2.3. Kata Kunci this
Kata kunci this digunakan dalam sebuah kelas dan digunakan untuk menyatakan objek
sekarang. Contoh misal saat ini kita membuat sebuah parameter yang sama dengan nama atribut
yang ada dalam sebuah kelas, maka jika kita menggunakan parameter tersebut untuk mengubah
atribut pada kelas, maka perubahan tidak akan terjadi.
1 class Manusia {
2
3 String nama;
4 String alamat;
5

20
6 void ubahData (String namaBaru, String alamat) {
7 nama = nama;
8 alamat = alamat;
9 }
10
11 void ubahNama (String nama) {
12 nama = nama;
13 }
14
15 }
Saat kita menggunakan kelas Manusia di atas pada program.
2 manusia.ubahData("Hendro Gunawan", "Ngawi");
3
4 System.out.println(manusia.nama);
5 System.out.println(manusia.alamat);
Setelah dijalankan, maka program tersebut akan menghasilkan nilai null, yang artinya nama
dan alamat objek manusia tidak berubah menjadi “Hendro Gunawan” dan “Ngawi”, mengapa?
Hal ini dikarenakan jika kita membuat sebuah parameter yang sama dengan nama atribut, lalu
saat kita memanggil nama atribut tersebut, maka sebenarnya bukan atribut yang kita panggil
melainkan parameter.
Agar kesalahan tersebut tidak terjadi, maka diperlukan kata kunci this, yang digunakan untuk
menyatakan objek tersebut, jadi untuk mengunah atribut yang namanya sama dengan parameter
haruslah sebagai berikut.
1 class Manusia {
2
3 String nama;
4 String alamat;
5
6 void ubahData (String namaBaru, String alamat) {
7 this.nama = nama;
8 this.alamat = alamat;
9 }
10
11 void ubahNama (String nama) {
12 this.nama = nama;
13 }
14
15 }

21
Saat program sebelumnya dijalankan kembali, maka hasilnya tidak akan null lagi.
3.2.4. Visibilitas Private dan Public
Java mendukung 4 visibilitas yaitu:
Visibilitas Keterangan
private Hanya dapat diakses oleh kelas itu sendiri
public Dapat diakses oleh seluruh kelas
protected Hanya dapat diakses oleh kelas itu sendiri
dan kelas turunannya
Tanpa visibilitas/default Hanya dapat diakses oleh kelas-kelas yang
berada pada satu paket
Saat ini akan kita bahas tentang visibilitas private dan public, untuk visibilitas protected akan
dibahas setelah materi pewarisan dan untuk tanpa visibilitas/private akan dibahas setelah
materi package.
Visibilitas private merupakan visibilitas yang dapat digunakan pada atribut, metode ataupun
kelas. Manfaat visibilitas private adalah berfungsi untuk menyembunyikan atribut, metode atau
kelas. Atribut, metode atau kelas yang menggunakan visibilitas hanya dapat diakses oleh objek
itu sendiri.
Contoh atribut yang menggunakan visibilitas private.
1 package Simplilearn;
2 class Students {
3 private int rank;
4 public int getRank() {
5 return rank;
6 }
7 public void setRank(int rank) {
8 this.rank = rank;
9 }
10
12 Students s = new Students();
13 s.setRank(1022);
14 System.out.println("Students rank is " + s.getRank());
15 }
16 }
Output dari program di atas yaitu:

22
Pada kode, atribut rank menjadi private, sehingga hanya kelas Students itu sendiri yang bisa
mengakses atribut rank, sehingga saat kelas lain mengakses atribut tersebut, maka akan terjadi
error.
Visibilitas public merupakan visibilitas yang dapat diterapkan pada atribut, metode dan
kelas. Dengan visibilitas public, maka atribut, metode atau kelas yang memiliki sifat public
tersebut dapat diakses oleh kelas manapun dan dari package manapun.
Lihat pada contoh program di bawah ini.
2 class vehicle {
3 public int tires;
4 public void display() {
5 System.out.println("I have a vehicle.");
6 System.out.println("It has " + tires + " tires.");
7 }
8
9 public static void main(String[] args) {
10 vehicle veh = new vehicle();
11 veh.tires = 4;
12 veh.display();
13 }
14 }
Output
Penentu akses publik menyediakan spesifikasi akses ke kelas sehingga dapat diakses dari
mana saja dalam program.
3.2.5 Konstruktor

23
Konstruktor merupakan metode yang secara otomatis dipanggil ketika sebuah objek dipanggil,
yakni pada proses instansiasi. Cara membuat metode konstruktor adalah, nama metode harus
sama dengan dengan nama kelas dan tidak mengembalikan nilai balik dan tidak pula
menggunakan kunci void.
Contoh kode program pembuatan constructor Java
1 class Laptop {
2 Laptop() {
3 String pemilik = "Anto";
4 String merk = "Lenovo";
5 System.out.println("Object Laptop " +merk+
6 " milik " +pemilik+" sudah dibuat");
7 }
8
10 Laptop laptopAnto = new Laptop();
11 }
12 }
Hasil kode program:
Di dalam construktor, terdapat pendefinisian 2 property yaitu: pemilik dan merk. Keduanya
langsung diisi nilai awal dan diakses dari perintah System.out.println( ). Pada saat class
Laptop di-instansiasi ke dalam object laptopAnto di baris 10, akan tampil teks yang berasal
dari constructor.
3.2.6 Overloading Konstruktor
Overloading merupakan mekanisme dimana kita dapat membuat lebih dari satu buah
konstruktor pada sebuah kelas. Namun dengan ketentuan, setiap konstruktor harus memiliki
parameter yang berbeda, bisa berbeda jumlah parameternya ataupun bisa berbeda tipe data
parameternya. Di dalam bahasa Java, method overloading adalah membuat beberapa method
dengan nama yang sama, tapi dibedakan dari jumlah dan tipe parameter.
Contoh kode program
1 class Overloading {

24
2
3 static int tambah(int var1, int var2) {
4 return var1 + var2;
5 }
6
7 static int tambah(int var1, int var2, int var3) {
8 return var1 + var2 + var3;
9 }
10
11 static String tambah(String var1, String var2) {
12 return var1 + " tambah " + var2;
13 }
14
16 System.out.println( tambah(1,2) );
17 System.out.println( tambah(5,4,3) );
18 System.out.println( tambah("satu","dua") );
19 }
20
21 }
Hasil kode program
Dalam program ini terdapat 3 buah method dengan nama tambah( ). Ketiga method tersebut
memiliki jenis type data parameter yang berbeda. Pada saat dipanggil, kita harus menulis
method tambah( ) dengan jumlah dan tipe data argument yang sesuai. Di baris 16 terdapat
pemanggilan method tambah(1, 2). Perhatikan bahwa argumen pemanggilan method ini ada 2
dan keduanya bertipe integer. Maka akan cocok dengan definisi method tambah() di baris 3 -
5. Di baris 17 terdapat pemanggilan method tambah(5, 4, 3). Kali ini argumen pemanggilan
method() ada 3 dan ketiganya bertipe integer. Maka ini akan cocok dengan definisi method
tambah() di baris 7 – 9. Terakhir di baris 18 terdapat pemanggilan method
tambah(“satu”,”dua”). Sekarang kedua argumen bertipe string yang akan cocok dengan
definisi method tambah( ) di baris 11 – 13.
Inilah maksud overloading, dimana kita membuat beberapa method dengan nama yang sama.
3.2.7 Overloading Metode
Selain pada konstruktor, overloading juga bisa dilakukan pada metode, misal kita akan
membuat dua buah metode ubah, metode pertama menggunakan parameter nama dan metode
kedua menggunakan parameter nama dan alamat.

25
1 class Manusia {
2 private String nama;
3 privat String alamat;
4
5 public Manusia () {
6 // tanpa parameter
7 }
8
9 publik Manusia (String nama) {
11 }
12
13 public void ubah(String nama) {
15 }
16
17 public void ubah(String nama, String alamat) {
20 }
21 }
Denagn begitu, kita dapat menggunakan metode ubah, untuk mengubah nama ataupun untuk
mengubah alamat.
1 public Class Helloworld {
2
5 manusia.ubah("Andi");
6 manusia.ubah("Andi Kurniawan","Bogor");
7 }
}
3.2.8 Inheritance/Pewarisan Kelas
Inheritance/pewarisan merupakan mekanisme dimana sebuah kelas dapat mewarisi seluruh
atribut atau metode milik kelas lain dengan ketentuan tertentu. Inheritance/pewarisan bisa juga
diartikan sebagai konsep OOP dimana sebuah class dapat menurunkan property dan method
yang dimilikinya kepada kelas lain. Konsep inheritance/pewarisan dipakai untuk
memanfaatkan fitur code reuse, yakni menghindari terjadinya duplikasi kode program. Dalam
bahasa Indonesia, inheritance ini disebut juga sebagai pewarisan atau penurunan.
Konsep inheritance membuat sebuah struktur atau hierarki class dalam kode program. Class
yang akan diturunkan bisa disebut sebagai class induk (parent class), super class, atau base
class. Sedangkan class yang menerima penurunan bisa disebut sebagai class anak (child
class), sub class, derived class atau heir class.

26
Cara Menurunkan Class di Java
Untuk menurunkan sebuah class di bahasa pemrograman Java, tulis nama child class, lalu
perintah extends dan baru tulis nama parent class.
Contoh
1 class Komputer {
2 // kode untuk class Komputer
3 };
4
5 class Laptop extends Komputer {
6 // kode untuk class Laptop
7 };
8
9 class BelajarJava {
11 Komputer komputerAndi = new Komputer();
12 Laptop laptopAndi = new Laptop();
13 }
14 }
Perhatikan perintah di baris 5, itulah cara menurunkan class Komputer kepada class Laptop.
Yakni dengan cara menulis perintah extends, diikuti nama parents class yang ingin kita
turunkan.
Untuk mengimplementasikan kelas , dapat kita lakukan langkah-langkah sebagai berikut:
1. Buat project baru dengan nama sesuai keinginan kita.
2. Setelah membuat project baru, maka langkah berikutnya adalah membuat kelas dimulai dari
Super class terlebih dahulu. Dalam kasus ini berarti kita membuat kelas “Manusia” terlebih
dahulu. Adapun perintahnya adalah sebagaiberikut:
1 public class Manusia {
2 protected String nama;
3 protected int umur;
4
5 public String getNama() {
6 return nama;
7 }
8
9 public void setNama(String nama) {
11 }
12
13 public int getUmur() {
14 return umur;
15 }

27
16
17 public void setUmur(int umur) {
18 this.umur = umur;
19 }
20
21 public void siapaKamu() {
22 System.out.println("Saya manusia");
23 }
24
25 }
3. Setelah membuat Super class maka langkah berikutnya adalah membuat sub class. Garis
“Generalisasi” di dalam Java akan diartikan sebagai perintah “extend”. Isi perintah program
kelas “Dosen” adalah sebagai berikut:
1 public class Dosen extends Manusia {
2 private String nip;
3 private String matakuliah;
4
5 public String getNip() {
6 return nip;
7 }
8
9 public void setNip(String nip) {
10 this.nip = nip;
11 }
12
13 public String getMatakuliah() {
14 return matakuliah;
15 }
16
17 public void setMatakuliah(String matakuliah) {
18 this.matakuliah = matakuliah;
19 }
20
21 public void mengajarApa() {
22 System.out.println("Saya " + nama + " umur " + umur + " mengajar " +
23 matakuliah);
24 }
25
26 }
Dapat dilihat bahwa pada baris 22 di kelas “Dosen” variabel “nama” dan “umur” dapat
digunakan tanpa dideklarasikan kembali di kelas “Dosen”. Dua variabel ini merupakan
pewarisan dari kelas “Manusia”. Dengan adanya perintah “extends” pada baris 1 maka kelas
“Dosen” dinyatakan sebagai sub class dari kelas “manusia”. Secara otomatis, dua atribut dan
satu method yang ada di kelas “Manusia” (karena tidak ada yang memiliki hak akses private)

28
diwariskan ke kelas “Dosen”. Hal ini juga berlaku untuk kelas “Mahasiswa” yang merupakan
sub class dari kelas “Manusia” juga. Sebagai contoh perintah kelas “Mahasiswa” adalah
sebagai berikut:
1 public class Mahasiswa extends Manusia {
2 private String nim;
3 private String kelas;
4
5 public String getNim() {
6 return nim;
7 }
8
9 public void setNim(String nim) {
10 this.nim = nim;
11 }
12
13 public String getKelas() {
14 return kelas;
15 }
16
17 public void setKelas(String kelas) {
18 this.kelas = kelas;
19 }
20
21 public void kelasApa() {
22 System.out.println("Saya " + nama + " umur " + umur + " mahasiswa
23 di kelas " + kelas);
24 }
25
26 }
Proses pewarisan akan lebih terlihat ketika membuat kelas “Tester” untuk kelas “Dosen” dan
kelas “Mahasiswa”. Kita bisa mengakses getter dan setter yang ada di kelas “Manusia”
melalui objek dari kelas “Dosen” dan kelas “Mahasiswa”.
Contoh Kode Program Multilevel Inheritance Java.
1 class Inheritance {
3 class Universitas {
4 String universitas = " Universitas Siber Asia";
5 String nama = "Hendro Gunawan";
6 String nim = "200401072103";
7 String jurusan = "Teknik Informatika";
8 String kelas = "IT-301";
9 int umur = 41;
10
11 String cekUniversitas() {

29
12 return "Ini berasal dari class Universitas";
13 }
14 };
15 class Dosen extends Universitas {
16 String dosen = "Catur Nugroho S.Kom., M.Kom.";
17
18 String cekDosen () {
19 return "Ini berasal dari class Dosen";
20 }
21 };
22 class Mahasiswa extends Dosen {
23 String lihatData() {
24 return "Nama: "+ nama + " NIM: " + nim + " usia: " + umur + " tahun
25 adalah mahasiswa jurusan: " + jurusan + " di kelas: " + kelas + universitas
26 + " Jakarta dengan dosen: matakuliah Pemrograman Berorientasi Objek Bapak "
27 + dosen;
28 }
29 String cekMahasiswa() {
30 return "Ini berasal dari class Mahasiswa";
31 }
32 }
33 Mahasiswa mahasiswaHendro = new Mahasiswa();
34
35 System.out.println(mahasiswaHendro.lihatData());
36 System.out.println(mahasiswaHendro.cekUniversitas());
37 System.out.println(mahasiswaHendro.cekDosen());
38 System.out.println(mahasiswaHendro.cekMahasiswa());
39 }
40 }
Hasil program setelah di compile adalah sebagai berikut:
Kode program ini lumayan panjang karena terdapat 3 class yang masing-masingnya memiliki
property dan method. Sebagai perintah pertama di dalam method main(), terdapat kode
mahasiswaHendro = new Mahasiswa(). Ini adalah proses instansiasi pembuatan object class
mahasiswa yang disimpan ke dalam variabel mahasiswaHendro. Dengan membaca kode ini
kita bisa pastikan bahwa seharusnya ada kode untuk pendefinisian class Mahasiswa.

30
Setelah proses instansiasi, terdapat kode System.out.println(mahasiswaHendro.lihatData(
)). Maka kita akan lihat apa isi dari method lihatData() yang terdapat di dalam class
Mahasiswa. Pendefinisian class Dosen ada di baris 15 – 21. Di baris awal juga terlihat bahwa
class ini ternyata class Mahasiswa adalah turunan dari class Dosen. Maka method lihatData()
bisa saja ada di dalam class ini, atau perent classnya.
Trenyata pendefinisian method lihatData() ada di dalam class Mahasiswa, yang isinya
merangkai sebuah string dari 7 property, yakni nama, nim, umur, jurusan, kelas, universitas,
dan dosen.
Maka lengkap sudah isi dari pemanggilan method mahasiswaHendro.lihatData(), dan
hasilnya adalah “ Nama: Hendro Gunawan NIM: 200401072103 usia:41 tahun adalah
mahasiswa jurusan: Teknik Informatika di kelas: IT-301 Universitas Siber Asia Jakarta dengan
dosen: matakuliah Pemrograman Berorientasi Objek Bapak Catur Nugroho S.Kom., M.Kom.”
3.2.9 Visibilitas Protected
Sebelumnya kita telah membahas tentang visibilitas private dan public, kali ini kita akan
membahas tentang visibilitas protected. Atribut, metode atau kelas yang ditandai dengan
visibilitas protected hanya dapat diakses oleh kelas itu sendiri dan turunannya. Misal pada
kelas Pegawai dan kelas Orang seperti pada contoh di bawah ini..
Pada kelas Orang, visibilitas untuk atribut nama dan alamat adalah private, artinya hanya
kelas Orang tersebut yang dapat mengakses atribut tersebut, walaupun kelas Pegawai
merupakan turunan dari kelas Orang, tetap saja kelas Pegawai tidak dapat mengakses atribut
nama dan alamat dari kelas Orang.
1 public class Pegawai extend Orang {
2
4 public void ubahNip(String nip) {
5 this.nip = nip;
6 }
7 public String ambilNip() {
8 return nip;
9 }
10
11 public void contoh(){
12 String ambilnama = nama;
13 }
14 }
Jika kita menggunakan protected, maka atribut nama dapat diakses oleh kelas keturunannya,
yaitu kelas Pegawai

31
1 ublic class Orang {
2 protected String nama;
3 protected String alamat;
4 public void ubahNama(String nama) {
5 this.nama = nama;
5 }
7 public String ambilNama() {
8 return nama;
9 }
10 public void ubahAlamat(String alamat) {
12 }
13 public String ambilAlamat() {
14 return alamat;
15 }
16 }
1 public class Pegawai extends Orang {
3 public void ubahNip(String nip) {
4 this.nip = nip;
5 }
6 public String ambilNip() {
7 return nip;
8 }
9
11 // berhasil
12 String ambilnama = nama;
13 String ambilalamat = alamat;
14 }
15 }
Contoh Program
2 class Student {
3 protected String stream;
4 protected void display() {
5 System.out.println("Hello, I am a " + stream + " Student");
6 }
7
9 Student s = new Student();
10 s.stream = "Computer Science and Engineering Technology";

32
11 s.display();
12 }
13
14 }
Hasil program adalah sebagai berikut:
3.2.10 Overriding
Overriding tidak sama dengan overloading, overiding merupakan mekanisme dimana sebuah
metode dapat dideklarasikan ulang pada kelas turunannya.
Misal ada kelas yaitu Bayi dan Dewasa, pada kelas bayi tersbut terdapat metode lari( ).
1 public class Bayi {
2 public void lari() {
3 System.out.println("Tidak Bisa :(");
4 }
5 }
Setelah itu kelas Dewasa merupakan kelas turunan dari kelas Bayi.
1 public class Dewasa extends Bayi{
2 }
Setelah itu jika kita coba buat sebuah objek kelas Dewasa dan menyuruhnya lari.
1 public class Test {
3 Dewasa dewasa = new Dewasa();
4 dewasa.lari();
5 }
6 }
Maka hasilnya adalah “Tidak Bisa ☹”, artinya metode lari( ) yang dipanggil sebenarnya milik
kelas yang pastinya tidak dapat berlari. Sekarang jika dianggap kelas Dewasa dapat berlari,
maka kita harus mengubah metode lari( ) tersebut agar dapat berlari, caranya adalah dengan
melakukan pendeklarasian ulang (overriding). Caranya adalah dengan membuat metode yang
sama dengan metode yang diwarisinya.

33
1 public class Dewasa extends Bayi {
3 System.out.println("Lari!!!!");
4 }
5 }
Maka jika program Test sebelumnya dijalankan kembali, maka keluarannya pasti “Lari!!!!”,
artinya metode lari( ) milik kelas dewasa yang dipanggil.
3.2.11 Kata Kunci Super
Kata kunci super merupakan kata kunci yang digunakan untuk mengakses kelas parent (yang
diturunkan), misal jika kita menggunakan kata kunci super pada kelas Dewasa artinya super
tersebut merujuk pada kelas Bayi.
1 public class Dewasa extends Bayi {
2 public void lariBayi() {
3 // mengakses metode lari milik Bayi
4 super.lari();
5 }
7 System.out.println("Lari!!!!");
8 }
9 }
Selain itu, kata kunci super juga dapat digunakan untuk mengakses konstruktor milik kelas
yang diwariskan.
1 public class Bernama {
3 public Bernama() {
4
5 }
6 public Bernama(String nama) {
7 this.nama = nama;
8 }
9
10 public String ambilNama(){
11 return nama;
12 }
13 }
1 public class Berumur extends Bernama{
2
3 private int umur;
4 public Berumur() {

34
5
6 }
7
8 public Berumur(String nama, int umur){
9 super(nama);
10 this.umur = umur;
11 }
12
13 public int ambilUmur(){
14 return umur;
15 }
16 }
3.2.12 Kata Kunci Final
Kata Kunci final merupakan kata kunci yang dapat digunakan untuk menandai bahwa suatu
atribut, metode atau kelas sudah final, artinya tidak dapat diubah lagi.
Lokasi Final Keterangan
Atribut Atribut tidak dapat dideklarasikan lagi.
Variabel Variabel tidak dapat dideklarasikan lagi.
Metode Metode tidak dapat dideklarasikan
(overriding) lagi.
Kelas Kelas tidak dapat diturunkan.
Jika kita m,enambahkan sebuah atribut dengan kata kunci final, maka atribut tersebut harus
langsung dideklarasikan, misal seperti ini.
1 public class Contoh {
2 private final String data = "Data";
3 }
Jika tidak dideklarasikan langsung, maka akan terjadi kesalahan (error). Atau jika kita
melakukan pendeklarasian ulang atribut tersebut maka akan terjadi error.
1 public class Contoh {
2 private final String data = "Data";
3
4 public void ubahData(String data){
5 // error
6 this.data = data;
7 }
8 }
3.2.13 Kelas Abstract

35
Kelas abstract merupakan kelas dimana memiliki metode-metode namun tidak dideklarasikan,
pendeklarasiannya terjadi pada kelas turunannya. Untuk membuat kelas abstract sama dengan
membuat kelas biasa, namun diawali dengan kunci abstract pada kelasnya dan diawali dengan
kata kunci abstract pada metode yang akan dibuat namun tidak akan dideklarasikan. Metode
yang abstract tidak perlu berisikan declarasinya.
Misal kita membuat abstract Hewan, lalu turunannya: Kucing, Kambing, dan Anjing. Kelas
hewan tersebut memiliki metode bicara() yang menyuruh Hewan tersebut bicara(), namun
karena setiap hewan berbeda nada bicaranya, maka kita buat metode bicara() tersebut menjadi
abstract.
1 public abstract class Hewan {
2 public abstract void bicara();
3 }
1 public class Anjing extends Hewan{
2 public void bicara() {
3 System.out.println("Gog gog...");
4 }
5 }
1 public class Kambing extends Hewan{
3 System.out.println("Embe...");
4 }
5 }
1 public class Kucing extends Hewan{
3 System.out.println("Meong...");
4 }
5 }
Jika kelas turunan dari hewan tidak mendeklarasikan metode bicara (), maka akan terjadi error,
kecuali kelas tersebut juga kelas abstract.
3.2.14 Polimorphisme
Polimorphisme merupakan kemampuan untuk sebuah kelas memiliki banyak kelas turunan.
Setiap kelas turunan memiliki deklarasi masing-masing yang unik dan dapat berfungsi
fungsionalitas yang sama dengan kelas parent (yang diturunkan).
Contoh polimorphisme adalah kelas Hewan yang sebelumnya telah dibuat.
1 public class Test {

36
3 Hewan hewan1 = new Anjing();
4 hewan1.bicara();
5 Hewan hewan2 = new Kambing();
6 hewan2.bicara();
7 Hewan hewan3 = new Kucing();
8 hewan3.bicara();
9 }
10 }
3.3 Paket
Dalam Java beberapa kelas dapat digabungkan dalam sebuah unit bernama paket(pakage).
Penggunaan paket sangat dianjurkan agar kelas-kelas tersebut lebih teratur.
Untuk mendeklarasikan paket, hanya perlu menggunakan kunci pakage pada bagian atas file
java diikuti nama paket. Namun paket tidak boleh diawali dengan nomor dan tidak boleh
mengandung karakter unik dan spasi. Paket biasanya bertingkat, untuk memberikan tingkatan
pada paket kita dapat menggunakan tanda . (titik), misal.
Paket Folder
Aplikasi.data /aplikasi/data/
Aplikasi.database /aplikasi/database/
Aplikasi.form /aplikasi/form/
Dianjurkan jika kita membangun sebuah sistem yang besar, maka diperlukan pengelompokan
jenis-jenis kelas dalam paket. Misal untuk kelas-kelas tabel dapat dimasukkan ke paket data,
kelas-kelas form bisa dimasukkan ke paket form, dan lain-lain.
1 package aplikasi.data;
2
3 public class Karyawan {
4
5 public String nip;
6 public String nama;
7 public String alamat;
8
9 }
Jika kita akan menggunakan kelas dengan lokasi paket yang sama, kita dapat menggunakannya
langsung, namun jika kita akan menggunakan kelas dengan paket yang berbeda, maka kita
perlu menggunakan import disertai dengan lokasi paket dan nama kelasnya.
1 package aplikasi.program;
2 import aplikasi.data.Karyawan;
3 public class Program {
5 Karyawan karyawan = new Karyawan();

37
6 }
7 }
3.3.1 Visibility Devault
Sebelumnya telah dibhas tentang visibiliti private, public dan protected. Sebenarnya ada satu
lagi visibility, yaitu default, namun tidak menggunakan kata kunci default, melainkan tidak
perlu menggunakan kata kunci (kosong).
Jika sebuah atribut, metode atau kelas ditandai dengan visibiliti default, maka itu artinya
atribut, metode atau krelas tersebut hanya dapat diakses oleh kelas-kelas yang ada dalam satu
paket. Jika akan diakses dari luar paket, maka akan terjadi error.
Contoh visibiliti default:
2 public class Mahasiswa {
3
4 String nim;
5 String nama;
6
7 }
3.4 Interface
Interface merupakan mekanisme dimana kita dapat menentukan metode-metode yang harus
ada pada kelas. Interface hampir mirip dengan kelas abstrak, namun ada beberapa perbedaan
pada interface dan kelas abstrak.
1. Kelas abstrak bisa mengandung metode abstrak dan metode tidak abstrak, sedangkan pada
interface harus semua metode abstrak.
2. Kelas abstrak dapat memiliki atribut, sedangkan interface tidak boleh memiliki atribut.
3. Kelas abstrak digunakan oleh kelas lain menggunakan pewrisan (extends), sedangkan
interface menggunakan implementasi (implements).
3.4.1 Mendeklarasikan Interface
Interface mirip dengan Kelas, hanya yang membedakan adlah kata kunci yang digunakan
bukan class melainkan interface. Contoh sederhana sebuah interface.
1 package aplikasi.prototype;
2
3 public interface Aksi {
4

38
5 public abstract void beraksi();
6 }
Secara default, seluruh metode yang ada dalam interface itu bersifat abstract dan public,
sehingga kita dapat menghapusnya menjadi lebih sederhana seperti berikut.
2
3 public interface Aksi {
4
5 void beraksi();
6
7 }
Perlu diingat bahwa metode dalam interface tidak dapat private.
3.4.2 Pewarisan Interface
Dalam hal pewarisan interface, sama dengan class, hanya yang membedakan adalah interface
dapat mewarisi lebih dari satu interface, sedangkan class hanya dapat mewarisi satu kelas.
2
3 public interface Tendangan {
4
5 void tendang();
6
7 }
2
3 public interface Pukulan {
4
5 void pukul();
6
7 }
2 public interface Aksi extends Tendangan, Pukulan{
3
4 }
3.4.3 Menggunakan Interface
Sebuah class dapat menggunakan interface melalui kata kunci implements, berbeda dengan
extends, sebuah kelas dapat menggunakan beberapa interface menggunakan implements.

39
2
3 import aplikasi.prototype.Aksi;
4
5 public class ContohAksi implements Aksi{
6
7 public void tendang() {
8 System.out.println("Tendang");
9 }
10 public void pukul() {
11 System.out.println("Pukul");
12 }
13 }
Karena interface aksi merupkan turunan dari interface Tendangan dan Pukulan, maka semua
class yang mengimplementasi interface Aksi, harus mendeklarasikan seluruh metode yang ada
pada interface Aksi, Tendsngsn dan Pukulan.
3.5 Inner Class
Java mendukung pembuatan kelas di dalam kelas. Cara membuat di dalam kelas sama dengan
membuat kelas seperti biasanya, hanya lokasinya berbeda dalam sebuah badan kelas, misal.
2 public class Luar {
3 private String data;
4 public void ubahData(String data) {
5 this.data = data;
6 }
7 public String ambilData() {
8 return data;
9 }
10 public class Dalam {
11 private String contoh;
12 public void ubahContoh(String contoh) {
13 this.contoh = contoh;
14 }
15 public String ambilContoh() {
16 return contoh;
16 }
17 }
18 }
3.5.1 Anonymous Class
Kelas anonimouse merupakan kelas yang dideklarasikan tanda nama, biasanya kelas ini dibuat
ketika mendeklarasikan sebuah variabel. Contoh

40
2 import aplikasi.prototype.Pukulan;
5
6 Pukulan pukulan = new Pukulan() {
7 public void pukul() {
8 System.out.println("Pukul ah...");
9 }
10 };
11 pukulan.pukul();
12 }
13 }
Sekilas pada kode diatas, kita hanya memiliki kelas program. Padahal sebenarnya terdapat dua
kelas, yaitu dengan kelas Anonymous yang merupakan pukulan dari interface Pukulan.
Penggunaan kelas Anonymous ini bisa dilakukan ketika kita hanya akan membuat sebuah kelas
yang hanya sekali pakai saja.
3.5.2 Kata Kunci static
Kata kunci static sebenarnya merupakan penyelewengan dari konsep pemrograman
berorientasi objek. Dengan menggunakan kata kunci static, kita dapat mengakses sebuah
atribut atau metode dari kelas secara langsung tanpa harus membuat objek kelas tersebut.
Sehingga ini menyalahi aturan pemrograman berorientasi objek yang menyatakan bahwa untuk
mengakses sebuah atribut atau metode harus melalui objek.
Kata kunci static biasanya digunakan jika akan membuat sebuah kelas utilitas, sehingga kita
dapat dengan mudah menggunakan metode-metode yang ada dalam kelas tersebut tanpa
membuat objeknya. Misal.
2 public class FungsiMatematika {
3 public static int tambah(int a, int b) {
4 int c = a + b;
5 return c;
6 }
7 public static int kali(int a, int b) {
8 int c = a * b;
9 return c;
10 }
11 }
Denagn begitu kita dapat langsung mengakses metode kali dan tambah tanpa membuat objek
FungsiMatematika, seperti contoh berikut ini:

41
4 int a = 10;
5 int b = 10;
6
7 int c = FungsiMatematika.kali(a, b);
8 }
9 }
Perlu diingat jika metode static hanya dapat memanggil menggunakan atribut atau metode
static, lainnya, artinya jika kita memanggil metode non static dalam metode static secara
langsung, maka akan terjadi error.
2 public class FungsiMatematika {
3 public static int kali(int a, int b) {
4
5 contoh();
6
7 int c = a * b;
8 return c;
9 }
11 // hanya contoh
12 }
13 }
3.6 Kelas POJO/Java Bean
Kelas POJO atau Java Bean merupakan kelas dimana sebuah kelas memiliki atribut dan
memiliki metode getter dan setter. Dimana atributnya bersifat private dan metode getter dan
setternya bersifat public. Metode getter digunakan untuk mendapatkan nilai atribut tersebut,
sedangkan metode setter digunakan untuk mengubah nilai atribut.
Penamaan kelas POJO mirip seperti punuk unta. Misal:
Nama Atribut Penamaan
Nama Depan namaDepan
Nama Belakang namaBelakang
Alamat Alamat
Tanggal Lahir tanggalLahir
Contoh Atribut Panjang Sekali contohAtributPanjangSekali
Sedangkan untuk penamaan getter dan setter nya pun mirip seperti punuk unta, misal:
Atribut Getter Setter

42
namaDepan getNamaDepan setNamaDepan
alamat getAlamat setAlamat
tanggalLahir getTanggalLahir setTanggalLahir
Namun ada beberapa pengecualian, jika type atributnya adalah boolean, maka getter nya bisa
diganti dari get menjadi is. Sehingga seperti ini.
Atribut Tipe Data Getter
sudahMenikah boolean isSudahMenikah
nama *semua tipe* getNama
Contoh POJO Mahasiswa yang memiliki nim, nama, dan alamat.
5 private String alamat;
6 public String getAlamat() {
7 return alamat;
8 }
9 public void setAlamat(String alamat) {
11 }
12 public String getNama() {
13 return nama;
14 }
15 public void setNama(String nama) {
17 }
19 return nim;
20 }
21 public void setNim(String nim) {
22 this.nim = nim;
23 }
24 }
4. Penanganan Kesalahan
Ada dua jenis kesalahan yaitu, pertama kesalahan pada saat kompilasi ada pula kesalahan saat
berjalan. Biasanya kesalahan kompilasi dapat langsung terjadi ketika proses kompilasi
sehingga proses kompilasi akan dibatalkan. Namun jika kesalahannya tersebut adalah
kesalahan saat berjalan, maka program akan berhasil berjalan, namun saat kesalahan tersebut
terjadi, maka program akan menjadi error.

43
Contoh kesalahan misalnya:
1 //mengimpor Scanner ke program
3 class JavaExceptionHandling {
5 String nama,alamat;
6 int usia,telepon;
7 // membuat Scanner baru
8 Scanner keyboard = new Scanner(System.in);
9
10 System.out.println("##Biodata Mahasiswa##");
11 System.out.println("=====================");
12 System.out.println();
13
14 System.out.print("Nama: ");
15 // dengan perintah Scanner
16 nama = keyboard.nextLine();
17 System.out.println("Nama: kamu adalah " + nama);
18
19 System.out.print("Alamat: ");
21 alamat = keyboard.nextLine();
22 System.out.println("Alamat: kamu adalah " + alamat);
23
24 // nextInt digunakan untuk perintah dan mengambil type data integer
25 System.out.print("Usia: ");
26 usia = keyboard.nextInt();
27 System.out.println("Usia: kamu adalah " + usia);
28
30 System.out.print("Telepon: ");
31 telepon = keyboard.nextInt();
32 System.out.println("Telepon: kamu adalah " + telepon);
34
35 // hasil
36 System.out.println(nama + " beralamat di " + alamat);
37 System.out.println(" berusia " + usia + " tahun.");
38 Sytem.out.println();
40 }
41 }
Terlihat seperti tidak ada kesalahan dengan kode di atas, yup dan kode diataspun dapat
dikompile dengan baik. Namun saat program tersebut dijalankan terjadi error, yaitu error
karena salah memasukkan type data pada baris ke 31, dimana seharusnya type data yang
digunakan adalah “String” bukan “integer”, sehingga program saat dikompile menghasilkan

44
output Exception in thread “main” java.util.InputMismatchException: For input string:
“081259640815” seperti tampak pada gambar di bawah ini:
Oleh karena itu perlu dilakukan penanganan kesalahan.
4.1 Menangkap Kesalahan
Agar kesalahan yang terjadi dapat ditangkap, maka kita dapat menggunakan try and cath.
Sintax nya adalah sebagai berikut.
1 try{
2 // isi yang memungkinkan error
3 }catch(jenis error){
4 // dijalankan jika terjadi error
}
Misalkan pada kode sebelumnya kita telah membuat sebuah program yang menyebabkan eror
Exception in thread “main” java.util.InputMismatchException: For input string:
“081259640815” maka kita dapat melakukan penanganan kesalahannya yaitu menjadi sebagai
berikut.
3 class JavaExceptionHandlingTryandCatch {
4
6
8 int usia,telepon;
9
12

45
16
21
26
31
33 try {
34 // pernyataan yang berpotensi mengakibatkan Exception
38 } catch (java.util.InputMismatchException e) {
39 // pernyataan disini akan di eksekusi jika terjadi Exception
40 System.out.println("Maaf tipe data yang Anda masukkan salah !");
41 }
43
44 // hasilnya
45 System.out.println(nama + " beralamat di: " + alamat);
46 System.out.println(" berusia: " + usia + " tahun.");
49 }
50 }
Sehingga hasilnya adalah sebagai berikut.

46
4.3 Penanganan Secara Bertingkat
Try catch tidak hanya dapat ditangani oleh satu kelas Exception, dapat juga ditangani oleh
beberapa kelas Exceptionseperti berikut:
1 try{
2 // blok yang memungkinkan terjadi error
3 }catch(jenis error 1){
4 // jika jenis error 1 terjadi
9 }
Penanganan secara bertingkat harus bertingkat pula jenis kelas errornya, paling bawah haruslah
kelas Exception yang paling tinggi, misal kelas Throwable.
4.3 Melontarkan Exception
Kadang ada kalanya kita perlu membuat kesalahan. Misal saat kita membuat sebuah kelas
Mahasiswa, maka nim wajib dimasukkan, lalu jika nim tidak dimasukkan, maka dianggap
salah.
3
6
7 return nim;
8 }

47
9
10 public void setNim(String nim) throws Throwable {
11
12 if (nim == null) {
13 throw new Throwable("Nim Harus Diisi");
14 }
15
16 this.nim = nim;
17 }
18 }
Untuk melontarkan kesalahan kita harus menggunakan kunci trhow dan metode yang
memungkinkan melontarkan kesalahan harus memiliki throw diikuti dengan kelas Exception
nya.
Dengan begitu jika kita akan mengubah nim, mka harus ditangani kesalahannya menjadi seperti
ini:
2 import aplikasi.data.Mahasiswa;
5 try {
6 Mahasiswa mahasiswa = new Mahasiswa();
7 mahasiswa.setNim(null);
8 } catch (Throwable e) {
9 System.out.print("Ups, terjadi error :");
10 System.out.println(e.getMessage());
11 }
12 }
13 }
4.4 Membuat Kelas Exception
Kelas Exception merupakan kelas error yang dapat digunakan untuk membangun kelas
Exception yang harus ditangani. Error ini bisa dibilang compilation exception artinya wajib
ditangani.
Untuk membuat kelas Exception, kita hanya perlu membuat kelas turunan dari kelas Exception.
1 package aplikasi.error;
2
3 public class ErrorWajib extends Exception {
4
5 public ErrorWajib(String message) {
6 super(message);
7 }

48
8 }
4.5 Membuat Kelas RuntimeException
Kelas RuntimeException merupakan kelas error yang errornya terjadi ketika aplikasi berjalan,
artinya error jenis ini tidak perlu langsung di catch. Mirip dengan pembagian dengan 0. Kita
dapat tidak menangkap error tersebut. Untuk membuat error jenis ini, kita dapat membuat kelas
turunan dari RuntimeException.
1 public class GakBolehKosong extends RuntimeException {
2
3 public GakBolehKosong(String message) {
4 super(message);
5 }
6 }
Misal kita ubah error pada nim kelas Mahasiswa menjadi error tersebut.
2
3 import aplikasi.error.GakBolehKosong;
4
6
8
10
11 return nim;
12 }
13 public void setNim(String nim) throws GakBolehKosong {
14
15 if (nim == null) {
16 throw new GakBolehKosong("Nim Harus Diisi");
16 }
17 this.nim = nim;
18 }
19 }
Dengan demikian, tanpa menangkap error pun, kita dapat langsung memanggil metode
setNim(nim).
2
3 import aplikasi.data.Mahasiswa;
4

49
6
8 Mahasiswa mahasiswa = new Mahasiswa();
9 mahasiswa.setNim("10106031");
10 }
11 }
4.6 Blok Finally
Blok finally merupakan blok yang selalu dijalankan pada proses try catch, baik itu terjadi error
ataupun tidak. Blok finally terdapat pada bagian akhir try catch.
Tadi kita sudah menulis program JavaHandlingExceptionTryandCatch, dimana program
tersebut terjadi error saat dijalankan, selain menggunakan Try dan Catch seperti penanganan
kesalahan sebelumnya, kita juga dapat menggunakan metode finally seperti pada contoh
program berikut ini.
3 class JavaExceptionHandlingFinally {
4
6
8 int usia,telepon;
11
15
20
25
30

50
32 try {
33 // pernyataan yang berpotensi mengakibatkan Exception
37 } catch (java.util.InputMismatchException e) {
38 // pernyataan disini akan di eksekusi jika terjadi Exception
39 System.out.println("Maaf terjadi kesalahan !");
40 } finally {
41 System.out.println("'try and catch' sudah selesai.");
42 }
43
46 }
47 }
Jika program di atas dijalankan, maka akan keluar tulisan “Maaf terjadi kesalahan !” dan
satunya lagi tulisan “try and catch sudah selesai.”.
5. Kelas-kelas
5.1 String
Seperti yang telah dibahas pada materi tipe data, String bukanlah tipe data, String adalah
sebuah kelas. Namun kelas String memiliki keunikan yaitu kita dapat menggunakan String
tanpa mendeklarasikannya terlebih dahulu.
String data = "hehehe";

51
Jadi tidak perlu membuat String terlabih dahulu.
String data = new String();
Dikarenakan String merupakan kelas, sehingga String pun memiliki bnayak metode yang dapat
kita gunakan untuk melakukan proses manipulasi String tersebut, seperti menjadikan seluruh
hurufnya besar (upper), kecil (lower) dan lain-lain.
Contoh:
String data = "hehehe";
String hasil = data.toUpperCase();
System.out.println(hasil);
Hasil perintah di atas adalah upper dari “hehehe” yaitu “HEHEHE”.
5.1.1 Mengabungkan String
String merupakan objek yang unik, bahkan kita dapat menggabung dua buah string atau lebih.
Ada dua cara menggabungkan String, yaitu menggunakan tanda + (tambah)
String hasil = "satu " + "dua " + "tiga " + "empat";
Atau dapat menggunakan menggunakan metode concat agar lebih terlihat berorientasi objek.
String hasil = "satu ".concat("dua ").concat("tiga ").concat("empat");
5.1.2 Membandingkan String
Kadang kalanya kita melakukan perbandingan String, misal:
3
5
6 String data1 = "a" + "b";
7 data1 = data1 + "c";
8
9 String data2 = "abc";
10
11 if (data1 == data2) {
12 System.out.println(data1 + " sama dengan " + data2);
13 } else {
14 System.out.println(data1 + " tidak sama dengan " +

52
15 data2);
16 }
17 }
18 }
Saat dijalankan, maka hasilnya adalah “abc tidak sama dengan abc” Lho kok? Padahal abc
pasti sama dengan abc ☹
Kenyataannya adalah, perbandingan = = hanya dapat digunakan untuk membandingkan tipe
data, tidak dapat digunakan untuk membandingkan kelas. Karena String adalah kelas, maka
tidak dapat dibandingkan menggunakan tanda = =.
Untuk membandingkan objek maka kita harus menggunakan metode equals() milik kelas
tersebut, jadi seharusnya membandingkan String adalah sebagai berikut.
2
4
6
7 String data1 = "a" + "b";
8 data1 = data1 + "c";
9
10 String data2 = "abc";
11
13 if (data1.equals(data2)) {
14
15 System.out.println(data1 + " sama dengan " + data2);
16 } else {
17 System.out.println(data1 + " tidak sama dengan " +
18 data2);
19 }
Jika program di ats dijalankan, mka hasinya “abc” sama dengan “abc”.
5.2 Date
Date merupakan presentasi untuk tunggal dalam Java. Kelas Date berada pada paket java.util.
Contoh membuat tanggal sekarang.
2
3 import java.util.Date;
4

53
6
8
9 Date date = new Date();
10 System.out.println(date);
11
12 }
13 }
Sayangnya walaupun Date merupakan representasi tanggal dalam Java, namun banyak metode-
metode milik kelas date yang sudah deprecated (tidak dianjurkan untuk digunakan), oleh
karena itu diperlukan kelas lain untuk melakukan manipulasi Date, yaitu Calendar.
5.3 Calendar
Calendar hampir mirip dengan Date, kelas ini merupakan representasi tanggal dalam Java. Cara
membuat Calendar tidak melalui sebuah construktor, melainkan menggunakan metode static.
2 import java.util.Calendar;
3
5
7
8 Calendar calendar = Calendar.getInstance();
9
10 }
11 }
5.3.1 Mengubah Calendar
Jika kita akan melakukan pengubahan tanggal atau waktu sebuah Calendar, baik itu menit,
detik, jam, hari, bulan dan tahun, maka kita dapat menggunakan metode set():
calendar.set(field, value);
Dimana fieldnya adalah:
Field Keterangan
Calendar.MILLISECOND Mengubah data milisekon
Calendar.SECOND Mengubah data detik
Calendar.MINUTE Mengubah data menit
Calendar.HOUR Mengubah data jam
Calendar.DAY_OF_MOON Mengubah data hari dalam bulan

54
Calendar.DAY_OF_WEEK Mengubah data hari dalam minggu
Calendar.DAY_OF_YEAR Mengubah data hari dalam tahun
Calendar.MONTH Mengubah data bulan
Calendar.YEAR Mengubah data tahun
Contohnya:
6 calendar.set(Calendar.YEAR, 1988);
7 calendar.set(Calendar.MONTH, Calendar.DECEMBER);
8 calendar.set(Calendar.DAY_OF_MONTH, 29);
9 }
10 }
Untuk bulan, value yang dimasukkan buklanlah angka melainkan bulan yang ada dalam
Calendar, misal Calendar.DECEMBER.
5.3.2 Menambah dan Mengurangi Calendar
Selain mengubah secara manual, mengunakan set(). Calendar juga memiliki metode add()
yang digunakan untuk menambah atau mengurangi data Calendar tersebut, Formatnya adalah
sebagai berikut:
calendar.add(field, value);
Dimana field pada metode add() sama dengan field pada metode set(). Contoh:
2
4
6
8
10 // menambah 10 hari
11 calendar.add(Calendar.DAY_OF_MONTH, 10);
12
13 }
14 }
Jika akan mengurangi data, cukup memasukkan data negatif, misal:

55
2
4
6
8
10 // mengurangi 10 hari
11 calendar.add(Calendar.DAY_OF_MONTH, -10);
12
13 }
14 }

56
Tentang Penulis
Penulis bernama Hendro Gunawan, Lahir di kota Jakarta pada tanggal 1 Januari 1981. Penulis
adalah Lulusan SMA Negeri 1 Muara Enim tamat tahun 1998, dan saat ini sedang menempuh
kuliah di Universitas Siber Asia Jakarta jurusan Teknik Informatika angkatan tahun 2020.
Penulis sangat menyukai bahasa pemrograman terutama yang berbasis objek yaitu diantaranya
bahasa pemrograman Java, Bahasa C, C++ dan Pemrograman WEB.
Selain sebagai mahasiswa penulis juga aktif sebagai karyawan di PT Indospring Tbk, yaitu
perusahaan yang bergerak dibidang Otomotif spring yang operasinya di daerah Gresik Jawa
Timur. Dengan membaca buku ini penulis berharap dapat memberikan kontribusi dalam hal
memperluas pengetahuan dibidang Pemrograman Berorientasi Objek (PBO) menggunakan
Java. Semoga buku ini bermanfaat untuk kita semua. Terima kasih.
Penulis dapat dihubungi di:
Telp:
• 081259640815
Email:
• hendro.gnwn@gmail.com
• hendro.gnwn@ymail.com
• hendro.gnwn@outlook.com
😊

57
Nilai
Tanda Tangan Dosen Pengampu /
Tutor
Tanda Tangan
Mahasiswa
(Catur Nugroho S.Kom., M.Kom) (Hendro Gunawan)
Diserahkan pada Tanggal: Tanggal Mengumpulkan:
20/11/2022

Pembelajaran Java Dasar

Recommandé

Recommandé

Contenu connexe

Similaire à Pembelajaran Java Dasar

Similaire à Pembelajaran Java Dasar (20)

Plus de HendroGunawan8

Plus de HendroGunawan8 (20)

Dernier

Dernier (20)

Pembelajaran Java Dasar