Yang Maha Kuasa atas limpahan Rahmat-Nya sehingga buku saduran dengan
selesaikan.
Buku ini disusun hanya untuk kalangan sendiri yaitu UPT Balai Latihan
Penulis juga mengucapkan banyak terima kasih atas dukungan semua pihak yang
telah mendukung pembuatan buku ini sehingga buku ini dapat terselesaikan.
Penulis,
KATA PENGANTAR.............................................................................................i
DAFTAR ISI..........................................................................................................ii
BAB I PENDAHULUAN.......................................................................................1
1.1 Latar Belakang..........................................................................................1
1.2 Tujuan........................................................................................................1
BAB II PENGENALAN JAVA.............................................................................2
2.1 Sejarah Singkat Perkembangan JAVA......................................................2
2.2 Kriteria “Kertas Putih” Java......................................................................3
2.3 JAVA dan C++..........................................................................................5
2.4 Tata Bahasa.............................................................................................10
2.5 Tipe Data.................................................................................................14
2.6 Operator...................................................................................................16
2.7 Control Flow............................................................................................18
2.7.1 Percabangan.........................................................................................18
2.7.2 Perulangan (Looping)..........................................................................20
2.8 Class dan Object......................................................................................22
2.9 Pendefinisian Class..................................................................................23
2.10 Inheritance...............................................................................................26
2.11 Method overiding....................................................................................27
2.12 This..........................................................................................................28
2.13 Abstract...................................................................................................30
2.14 Static method...........................................................................................32
2.15 Final.........................................................................................................33
2.16 Interface...................................................................................................33
2.17 Polymorphism.........................................................................................36
2.18 Operator Instanceof.................................................................................37
2.19 Package....................................................................................................38
2.20 Penanganan Eksepsi................................................................................41
2.20.1 Dasar-dasar penanganan Eksepsi.....................................................42
2.20.2 Tipe Eksepsi.....................................................................................42
I.2 Tujuan
Keharusan untuk membuat bahasa yang kecil , dan kode yang ketat
mendorong mereka untuk menghidupkan kembali model yang pernah dicoba oleh
bahasa UCSD Pascal, yaitu mendesain sebuah bahasa yang portable yang
menghasilkan kode intermediate. Kode intermediate ini kemudian dapat
digunakan pada banyak komputer yang interpreternya telah disesuaikan.
Sederhana (Simple)
Syntax untuk Java seperti syntax pada C++ tetapi syntax Java tidak
memerlukan header file, pointer arithmatic (atau bahkan pointer syntax), struktur
union, operator overloading, class virtual base, dan yang lainnya. Jika anda
mengenal C++ dengan baik, maka anda dapat berpindah ke syntax Java dengan
mudah tetapi jika tidak, anda pasti tidak berpendapat bahwa Java sederhana.
Terdistribusi (Distributed)
Java memiliki library rutin yang luas untuk dirangkai pada protokol
TCP/IP sepetrti HTTP dan FTP dengan mudah. Aplikasi Java dapat membuka dan
mengakses objek untuk segala macam NET lewat URL sama mudahnya seperti
Kuat (Robust)
Aman (Secure)
Portabel (Portable)
Tidak seperti pada C dan C++, di Java terdapat ketergantungan pada saat
implementasi (implement dependent). ukuran dari tipe data primitif ditentukan,
sebagaimana kelakuan aritmatik padanya. Librari atau pustaka merupakan bagian
dari sistem yang mendefinisikan interface yang portabel.
Multithreaded
Dinamis
Variabel Global
Pada Java, ruang penamaan global hanya hirarki class. Tidak mungkin
menciptakan variabel global diluar semua class. Setidaknya penentuan keadaan
global dibuat lebih jelas dengan enkapsulasi dalam class. Contoh,
system.out.println() sering digunakan dalam program Java. Ini adalah cara
mengakses output standar global untuk interpreter Java.
Goto
Java tidak memiliki pernyataan goto. Java menyediakan kata goto hanya
untuk menjaga agar programmer tidak bingung menggunakannya. Java memiliki
bagian break yang diberi label dan pernyataan continue yang merupakan bagian
dimana goto boleh dipergunakan. Penanganan eksepsi yang ampuh dan terdefinisi
dengan baik pada Java menghilangkan kebutuhan perintah goto.
Pointer atau address pada memori adalah kemampuan C++ yang paling
ampuh juga paling berbahaya. Biasanya kesalahan terjadi karena “kurang satu
tempat” atau rusaknya data yang disimpan karena lokasi memori terakhir
hancur.kesalahan ini merupakan salah satu kesalahan yangterburuk yang susah
untuk diperiksa dan ditelusuri.
Alokasi Memori
Java tidak memiliki fungsi malloc dan free, karena setiap struktur data
yang rumit adalah objek, maka mereka dialokasikan dengan operator new, yang
mengalokasikan ruang untuk objek pada ‘heap’ memori. Memori yang disediakan
disebut ‘heap’ karena kita tidak perlu lagi memikirkannya sebagai penambahan
address yang berstruktur linier. Jadi hanya berupa kumpulan instan objek. Yang
didapat dari fungsi new bukanlah address memori, melainkan hanya ‘pegangan’
untuk objek dalam heap.
Penggunaan ini, walaupun tidak baik, tetapi cukup aman. Tentu saja
dengan menganggap blok memori yang ditunjuk oleh p sekurang0kurangnya
sepanjang sizeof (struct p).ini harus digunakan dengan sangat hati-hati karena
tidak ada syarat untuk memeriksa apakah kita telah memilih tipe dengan benar.
Peng-hacker-an Preprocessor
QED
Spasi
Java adalah bahasa bebas bentuk. Tidak perlu mengatur tata letaknya
agar dapat bekerja. Asalkan ada sekurang-kurangnya satu spasi, tab, atau baris
baru diantara setiap token sebelum disisipi operator atau pemisah lain.
Komentar
/*
* komentar…….
* komentar……
*/
3. Komentar terdokumentasi
/**
* komentar….
* komentar…..
*/
Kata kunci simpanan adalah identifier khusus yang disimpan oleh bahasa
Java untuk mengendalikan bagaimana program didefinisikan. Kata kunci ini
digunakan untuk mengenali tipe-tipe, pengubah, dan mekanisme pengaturan aliran
program. Kata kunci ini hanya dapat digunakan untuk fungsi tertentu dan tidak
dapat digunakan sebagai identifier nama suatu variabel, class dan method. Sampai
denga Versi 1.0 terdapat 59 kata kunci seperti terlihat dalam tabel :
Identifier
Digunakan untuk nama class, method, dan variabel. Suatu variabel dapat
berupa urutan tertentu huruf (besar atau kecil), angka, garis bawah, dan tanda
dolar. Tidak boleh diawali oleh angka dan bersifat case sensitive.
Untuk variabel provate dan lokal identifier akan berupa huruf kecil
semua dikombinasikan dengan garis bawah, misalnya next_val, temp_val. Untuk
variabel final yang mewakili suatu konstanta, digunakan huruf besar semua,
misalnya TOK_BRACE, DAY_FRIDAY.
Literal
Separator (Pemisah)
Variabel
Java merupakan contoh bahasa yang strongly typed language. Hal ini
berarti bahwa setiap variabel harus memiliki tipe yang sudah dideklarasikan.
Terdapat 8 tipe primitif, 6 diantaranya adalah tipe bilangan ( 4 tipe integer, 2 tipe
floating point), 1 tipe karakter char, digunakan mengawa-sandi (encode) Unicode,
dan 1 tipe boolean.
Integer
Floating Point
Char
\b backspace \u0008
\t tab \u0009
\n linefeed \u000a
\r carriage return \u000d
\” double quote \u0022
\’ single quote \u0027
\\ a backslash \u005c
Boolean
Tipe boolean memiliki nilai true dan false. Tipe ini digunakan untul
logical testing dengan menggunakan operator relasional.
Operasi biner apapun pada variabel numerik dengan tipe yang berbeda
dapat diterima dan diperlakukan dengan cara seperti dibawah ini :
1. Jika tipe operand adalah double, maka yang lain juga akan
diperlakukan sebagai double pada lingkup operasi tersebut.
2. Jika operand adalah float, maka yang lain juga akan diperlakukan
sebagai float.
3. Jika operand adalaha long, maka yang lain juga akan diperlakukan
sebagai long.
I.8 Operator
Assignment Operator ( = )
Arithmetic Operator
Operator Operation
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulo
Bitwise Operator
Operator Operation
& AND
| OR
^ XOR
Unary Operator
Operator Operation
~ Unary NOT
- Minus
++ Increment
-- Decrement
Relational Operator
Operator Operation
== Equal To
!= Not Equal To
> Greater Than
< Less Than
>= Greater or Equal To
<= Less or Equal To
Logical Operator
Operator Operation
! Short-circuit NOT
&& Short-circuit AND
|| Short-circuit OR
?: Operator ternary if-then-
Preseden Operator
Tertinggi
() [] .
++ -- ~ !
* / %
+ -
>> >>> <<
> >= < <=
== !=
&
^
|
&&
||
?:
= op=
Terendah
I.9.1 Percabangan
if – else
break
switch (expression)
{ case value1 :
Statement;
break;
case value2 :
Statement;
break;
case valueN :
Statement;
break;
default;
}
return
while
do-while
[initialization;]
do
{ body program;
[iteration;]
}
while [termination];
for
Pernyataan koma
continue
/*
Di sini kita mendefinisikan sebuah class bernama NiceGuy.
Simpan sebagai file NiceGuy.java dan compile file
Tersebut. Anda akan mendapatkan file bernama
NiceGuy.class
*/
/*
Di sini, kita membuat sebuah java application yang
bernama OurFirstCode.
Simpan source ini dalam file bernama OurFirstCode.java,
di direktori yang sama dengan tempat anda menyimpan
NiceGuy.java. Kemudian compile file tersebut, Anda akan
Mendapatkan file OurFirstCode.class.
Lalu jalankan aplikasi ini dengan mengetikan java
OurFirstCode pada command line
*/
public class OurFirstCode {
public static void main(String[] args) {
NiceGuy ng= new NiceGuy (“ButtHead”);
ng.sayHello();
ng.sayHelloOutLoud();
class Useless {
//….mmm….
Tidak ada yang bisa kita harapkan dari objek diatas. Contoh yang lebih
baik adalah Gambar 1. Disana kita mendeklarasikan 1 field dan 3 method. Pada
baris 8 kita mendeklarasikan field yang bernama name yang bertipe string. Secara
umum sintaks untuk mendeklarasikan field adalah :
type namafield;
Tipe dari field bisa primitif (seperti int, boolean, float, dan sebagainya),
dan bisa juga Object (seperti String, Vector, Hashtable, dan sebagainya).
Tipe Return bisa void, tipe data primitif, atau tipe data object. Method
dengan tipe return non-void harus mencantumkan statement return <something>
pada akhir deklarasi method itu (seperti pada baris 21 class NiceGuy) kita juga
dapat menggunakan kata return pada method void untuk keluar dari method
tersebut.
Hal lain yang perlu dicatat tentang constructor adalah, nama constructor
harus sama dengan classnya. Constructor tanpa parameter disebut default
constructor. Kalau kita sama sekali tidak mendeklarasikan constructor, compiler
secara otomatis akan membuatkan sebuah default constructor.
I.12 Inheritance
Salah satu topik penting dalam OOP adalah inheritance (pewarisan sifat).
Dengan inheritance, pengembangan software dapat bekerja lebih efisien dan lebih
cepat. Berkat inheritance dapat menggunakan definisi class yang pernah dibuat
sebelumnya untuk membuat class-class lain yang menyerupai class tersebut.
Perhatikan contoh berikut :
class Katt {
public Katt() {
system.out.println(“Katt Constructor”);
}
public void speak() {
system.out.println(“Miaww…”);
}
Kita membuat varian baru lain dari Katt dengan cara mengeong
Murr….Murr…Murr…. Kita namai varian itu Siam. Kita definisikan Siam
sebagai subclass dari Katt, tapi kini kita melakukan metode overiding, kita
mendefinisikan ulang method speak() didalam definisi class Siam. Jika dijalankan
akan menghasilkan output :
Katt constructor
Miaww…
Katt constructor
Miaww…
Crash…Boom…
Katt constructor
Siam constructor
Mmurrr…mmurrr…
I.14 This
class DivineBeing {
private String name;
private DivineBeing baddDivineBeing;
public DivineBeing (String name) {
this.name = name ;
}
public void messWith (DivineBeing anotherDivineBeing) {
anotherDivineBeing.kapow(this);
}
public void kapow (DivineBeing baddDivineBeing) {
system.out.println(baddDivineBeing.getName()+”!!!!Damn
You!!”);
//forgive but not forget…
this.baddDivineBeing = baddDivineBeing;
}
public void makeRevenge() {
of (baddDivineBeing != null) {
baddDivineBeing.kapow(this);
}
}
public String getName() {
return name;
}
}
Penggunaan lain dari this dapat dilihat pada baris 15 dan 23. Pada baris
15, kita bermaksud menetapkan variabel name yang di deklarasikan pada baris 12,
tapi sekarang timbul konflik dalam penamaan variabel. Didalam daftar argumen
pada constructor kita juga mendefinisikan variabel lain yang juga bernama name
(baris 14). Jangkauan variabel name pada baris 12 mencakup semua ruang pada
class DivineBeing, sedangkan variabel name pada baris 14 mempunyai jangkauan
terbatas didalam constructor itu. Untuk mengatakan saya menginginkan name
yang global bukan name yang lokal, kita menerobos keluar dengan keyword this.
Dapat dilihat pada gambar 5.
class DivineBeing {
private String name;
this.name = name ;
I.15 Abstract
Contoh:
I.17 Final
Final juga bisa diberlakukan bagi class, kita tidak dapat membuat turunan
dari class final. Bentuk umum final class :
import java.awt.*;
import java.awt.event.*;
public AustinPower() {
behave = new Button (“I Am a Button”);
behave.addMouseListener(this);
add(behave);
}
package java.awt.event;
import java.util.EventListener;
/**
* The listener interface for receiving mouse event on a
* Component.
* @version 1.7 07/01/98
* @author Carl Quinn
*/
public interface MouseListener extends EventListener {
public void mouseClicked (MouseEvent e);
public void mousePressed (MouseEvent e);
public void mouseReleased (MouseEvent e);
public void mouseEntered (MouseEvent e);
public void mouseExited (MouseEvent e);
}
Disetiap iterasi pada loop diatas, pada dasarnya kita mengirimakan pesan
yang sama ke objek-objek yang bertipe sama (yaitu Katt, sesuai dengan definisi
array pada baris 3), speak(). Walaupun begitu, ternyata masing-masing bereaksi
dengan caranya sendiri-sendiri.
Tentunya untuk kasus ini, tidaklah tepat jika, secara static kita
mengasosiasikan k dengan class Siam (misal dengan pendeklarasian Siam k =
null). Pada kode diatas, pengasosiasian k dengan clas spesifik (Anggora, Siam
atau lainnya) dilakukan pada saat run-time, yaitu ketika return Value dari
pemanggilan receive() di-assign ke k. Itulah yang disebut dynamic/late binding.
Evaluasi juga akan bernilai benar jika B adalah nama interface dan A
mengimplementasikan B. Begitu pula jika
parent/grandparent/greatgrandparent/seterusnya dari class objek A
mengimplementasi B.
I.21 Package
package com.drawworks.threedee;
import com.raka.geoms.*;
……
package com.drawworks.threedee;
import com.raka.geoms.*;
import java.awt.*;
……
Eksepsi adalah keadaan tidak normal yang muncul pada suatu bagian
program pada saat dijalankan. Penanganan eksepsi pada java membawa
pengelolaan kesalahan program saat dijalankan kedalam orientasi-objek. Eksepsi
java adalah objek yang menjelaskan suatu keadaan eksepsi yang muncul pada
suatu bagian program.
Saat suatu keadaan eksepsi muncul, suatu objek exception dibuat dan
dimasukkan ke dalam method yang menyebabkan eksepsi. Method tersebut dapat
dipilih untuk menangani eksepsi berdasarkan tipe tertentu. Method ini juga
menjaga agar tidak keluar terlalu dini melalui suatu eksepsi, dan memiliki suatu
blok program yang dijalankan tepat sebelum suatu eksepsi menyebabkan
metodenya kembali ke pemanggil.
Eksepsi dapat muncul tidak beraturan dalam suatu method, atau dapat
juga dibuat secara manual dan nantinya melaporkan sejumlah keadaan kesalahan
ke method yang memanggil.
Penanganan eksepsi pada java diatur dengan lima kata kunci : try, catch,
throw, throws dan finally. Pada dasarnya try digunakan untuk mengeksekusi suatu
bagian program, dan jika muncul kesalahan, sistem akan melakukan throw suatu
eksepsi yang dapat anda catch berdasarkan tipe eksepsinya, atau yang anda
berikan finally dengan penangan default.
try {
// Block of Code
}
catch (ExceptionType1 e) {
// Exception Handler for ExceptionType1
} catch (ExceptionType2 e) {
// Exception Handler for ExceptionTYpe2
throw (e); // re-throw the Exception…
class Exc0 {
public static void main (Stinr args[]) {
int d = 0;
int a = 42 / d;
}
}
class Exc1 {
static void subroutine() {
int d = 0;
int a = 42 / d;
}
Output-nya :
java.lang.ArithmeticException : / by zero
at Exc1.subroutine(Exc1.java :4)
at Exc1.main(Exc1.java : 7)
Kata kunci try digunakan untuk menentukan suatu blok program yang
harus dijaga terhadap semua eksepsi, setelah blok try masukkan bagian catch,
yang menentukan tipe eksepsi yang akan ditangkap. Perhatikan contoh berikut:
class Exc2 {
public static void main (String args[]) {
try {
I.22.5 Throw
throw ThrowableInstance;
class throwDemo {
static void demoProc() {
try {
throw new NullPointerException(“demo”);
}
catch (NullPointerException e) {
System.out.println(“caught inside demoproc…”);
throw e;
}
}
Output :
caught inside demoproc
recaught : java.lang.NullPointerException : demo
I.22.6 Throws
Contoh :
class ThrowsDemo {
static void procedure () thorws IllegalAccessException {
System.out.println(“Inside Procedure”);
throw new IllegalAccessException(“demo”);
}
Output :
I.22.7 Finally
Output :
Inside procA..
procA is finally
Inside procB..
procB is finally
I.23 Multithreading
Sebuah
Thread
Sebuah Program
Thread
lainnya
Dua program yang dijalankan secara terpisah ( dari command line secara
terpisah ), berada pada dua address space yang terpisah. Sebaliknya, kedua thread
pada gambar diatas berada pada address space yang sama (address space dari
program dimana kedua thread tersebut dijalankan).
Concurrency Parallelism
Time Time
Task I Task 2
T
a
s
k
T
a
1
s
k
Blocked stop()
suspend()
sleep()
Dead
New wait()
Born
stop()
resume()
notify()
start() stop()
Runnable Running
yield()
Sebuah thread berada pada state ini ketika dia di instantiasi. Sebuah
ruangan dimemori telah dialokasikan untuk thread itu,dan telah menyelesaikan
tahap inisialisasinya.
………
Runnable
Pada state ini, sebuah thread berada dalam skema penjadwalan, akan
tetapi dia tidak sedang beraksi. Kita bisa membuat timerThread yang kita buat
sebelumnya masuk ke state runnable dengan :
…..
timerThread.start();
……
Kapan tepatnya timerThread beraksi, ditentukan oleh thread scheduler.
Running
Pada state ini, thread sedang beraksi. Jatah waktu beraksi bagi thread ini
ditentukan oleh thread scheduler. Pada kasus tertentu, thread scheduler berhak
meng-interupsikegiatan dari thread yang seddang beraksi (misalnya ada thread
lainnya dengan prioritas yang lebih tinggi).
Thread dalam keadaan running bisa juga lengser secara sukarela, dan
masuk kembali ke state runnable, sehingga thread lain yang sedang menunggu
giliran(runnable) memperoleh kesempatan untuk beraksi. Tinddakan thread yang
lengser secara sukarela itu biasanya disebut yield-ing.
public void run() {
…….
Thread.yield();
…….
}
Blocked
Pada tahap inii thread sedang tidak beraksi dan diabaikan dalam
penjadwalan thread scheduler. Thread yang sedang terblok menunggu sampai
syarat-syarat tertentu terpenuhi, sebelum ia kembali masuk kedalam skema
penjadwalan thread scheduler (masuk state runnable lagi). Suatu thread menjadi
terblok karena hal-hal berikut :
b. Thread itu di- suspend(). Thread yang ter-suspend() itu bisa masuk kembali ke
state runnable bila ia resume(). seperti hal berikut:
……
//timerThread akan segera memasuki state blocked
timerThread.suspend();
………
timerThread.resume();
//timerThread kembali masuk state runnable
……
c. Bila thread tersebut memanggil method wait() dari suatu object yang sedang ia
kunci. Thread tersebut bisa kembali memasuki state runnable bila ada thread
lain yang memanggil method notify() atau notifyAll() dari object tersebut.
d. Bila thread ini menunggu selesainya aktifitas yang berhubungan dengan I/O.
Misalnya, jika suatu thread menunggu datangnya bytes dari jaringan komputer
maka secara otomatis thread tersebut masuk ke state blocked.
e. Bila suatu thread mencoba mengakses critical section dari suatu object yang
sedang dikunci oleh thread lain. Critical section adalah method/blok kode yang
ditandai dengan kata synchronized.
Dead
Suatu thread secara otomatis disebut mati bila method run() – nya sudah
dituntaskan (return dari method run() ). Contoh dibawah ini adalah thread yang
akan mengecap state running hanya sekali saat thread scheduler memberinya
kesempatan untuk running, ia akan mencetak “ I’m doing something….something
stupid….but I’m proud of It”… kemudian mati.
- Prasetyo D.D, “Solusi Membuat Aplikasi Java dengan Java Studio”, Elex
Media Komputindo, Jakarta, 2004.