2. Variabel dan Perhitungan
Pada bab ini, Anda akan mempelajari entitas-entitas
non-objek dalam Java---nilai dan karakter. Semuanya adalah elemen-elemen bahasa
yang diperlukan untuk melakukan perhitungan numeris. Di sini Anda mempelajari:
* Bagaimana mendeklarasikan
dan mendefinisikan variabel bertipe integer dan titik-mengambang (pecahan)
* Bagaimana
menuliskan statemen penugasan
* Bagaimana
ekspresi integer dan titik-mengambang dievaluasi
* Bagaimana
menampilkan data dari program konsol
* Bagaimana
ekspresi campuran integer dan titik-mengambang dievaluasi
* Apa itu casting
(konversi tipe data) dan kapan Anda perlu menggunakannya
* Apa itu variabel
boolean
* Bagaimana urutan
eksekusi operator ketika dieksekusi
* Bagaimana
memberikan komentar pada program
Data dan Variabel
Variabel adalah sepotong memori yang memiliki nama
dan dapat digunakan untuk menyimpan informasi pada program Java Anda. Setiap
potongan memori bernama yang Anda definisikan pada program Java hanya dapat
menyimpan data dengan tipe tertentu. Jika Anda mendefinisikan sebuah variabel
untuk menyimpan integer, misalnya, Anda tidak bisa menggunakannya untuk
menyimpan nilai pecahan, seperti 0.45. Jika Anda mendefinisikan sebuah variabel
untuk mereferensi objek Topi, maka
Anda hanya dapat menggunakannya untuk mereferensi objek Topi (atau semua subkelasnya, seperti yang akan Anda pelajari pada
Bab 6). Karena tipe data yang dapat disimpan oleh tiap variabel tidak bisa
berubah, kompiler atau kompilator dapat memverifikasi apakah setiap variabel
yang Anda definisikan pada program Java sesuai atau tidak. Jika metode pada
program Anda ditujukan untuk memproses integer, maka kompilator dapat memeriksa
apakah Anda menggunakan metode itu untuk memproses data dengan tipe data integer
atau tidak.
Nilai
data eksplisit pada program Java dinamakan dengan literal. Setiap literal juga dapat memiliki tipe data tertentu. 25,
misalnya, adalah sebuah literal integer bertipe int. Hal ini akan didiskusikan lebih lanjut nanti.
Sebelum
Anda menggunakan sebuah variabel, Anda perlu menetapkan nama dan tipenya pada
sebuah statemen deklarasi. Sebelum dijelaskan bagaimana Anda menuliskan
deklarasi untuk sebuah variabel, Anda perlu mengetahui fleksibilitas apa yang
Anda miliki dalam memilih nama variabel.
Menamai
Variabel Anda
Nama yang Anda pilih untuk sebuah variabel dalam
Java disebut pula dengan pengenal.
Sebuah pengenal dapat memiliki sembarang panjang, tetapi ia harus diawali
dengan huruf, karakter garis-bawah (_), atau tanda dollar ($). Setelah karakter
awalan tersebut, pengenal dapat memiliki huruf-huruf, dijit-dijit, dan
karakter-karakter lainnya kecuali operator-operator yang dipakai dalam Java
(seperti +, -, atau *).
Java merupakan bahasa yang sangat sensitif dengan
kapital tidaknya karakter. Jadi, nama republik
dan Republik merupakan nama yang
berbeda. Anda tidak bisa menempatkan spasi atau tab di tengah nama variabel,
jadi Anak Bangsa tidak bisa diberikan kepada nama variabel, tetapi Anda bisa
menjadikannya AnakBangsa atau Anak_Bangsa.
Selain
pembatasan-pembatasan yang telah disebutkan, Anda dapat menamai sebuah variabel
sesuka Anda, kecuali dua pembatasan lain berikut: Anda tidak bisa menggunakan
katakunci-katakunci dalam Java sebagai nama variabel; dan Anda tidak bisa menamai
variabel yang dapat diinterpretasikan sebagai nilai konstanta atau literal.
Katakunci adalah sembarang kata yang menjadi bagian penting dalam bahasa Java.
Nama
Variabel dan Unicode
Meskipun Anda
menuliskan program-program Java dalam sebuah lingkungan yang menyimpan
karakter-karakter ASCII, semua kode sumber Java dikodekan dalam Unicode.
Meskipun kode sumber awal yang Anda tuliskan adalah ASCII, kode sumber itu
kemudian dikonversi menjadi karakter-karakter Unicode secara internal, sebelum
ia dikompilasi. Anda menuliskan semua statemen bahasa Java menggunakan ASCII, tetapi
Anda juga bisa menuliskan kode sumber menggunakan Unicode, yang menawarkan
fleksibilitas yang jauh lebih luas. Ini berarti bahwa pengenal-pengenal yang
Anda tuliskan pada program sumber Anda dapat menggunakan semua karakter bahasa
yang didefinisikan dalam himpunan karakter Unicode, jadi program-program Anda
dapat menggunakan nama-nama variabel Rusia, Yunani, atau Perancis.
Variabel
dan Tipe
Seperti
yang telah disebutkan sebelumnya, setiap variabel yang Anda deklarasikan hanya
dapat menyimpan nilai-nilai yang tipe datanya konsisten atau kompatibel dengan
tipe data variabel tersebut. Anda menetapkan tipe dari variabel tertentu
menggunakan nama tipe pada deklarasi variabel. Misalnya, berikut adalah sebuah
statemen yang mendeklarasikan sebuah variabel yang dapat menyimpan nilai-nilai
integer (bilangan bulat):
int banyakOrang;
Tipe data pada kasus ini adalah int dan nama varabelnya adalah banyakOrang.
Tanda titik-koma (semikolon) menandai akhir statemen. Variabel, banyakOrang, hanya dapat menyimpan
nilai-nilai bertipe int. Tentu, int adalah sebuah katakunci dalam Java.
Banyak variabel Anda nantinya akan dipakai untuk
mereferensi objek-objek, tetapi hal ini akan dibiarkan dahulu dan akan dipelajari
nanti dengan cakupan khusus. Ada delapan tipe data fundamental dalam Java dan
dikelompokkan ke dalam tiga kategori berikut:
* Nilai-nilai
numerik, yang dapat berupa nilai integer (bulat) atau nilai mengambang
(pecahan).
* Variabel-variabel
yang menyimpan kode untuk satu karakter Unicode.
* Variabel-variabel
yang dapat menyimpan nilai true atau
false.
Semua nama tipe
fundamental ini adalah katakunci dalam Java, jadi Anda tidak bisa
menggunakannya untuk tujuan lain.
Tipe-Tipe Data Integer
Ada empat tipe data variabel yang dapat dipakai
untuk menyimpan data integer. Semuanya adalah tipe data bertanda; jadi, Anda
dapat menggunakannya untuk menyimpan nilai-nilai negatif maupun positif.
Keempat tipe integer memiliki rentang nilai yang berbeda, sehingga pemilihan
tipe data untuk sebuah variabel bergantung pada rentang nilai yang Anda
perlukan.
Keempat tipe integer dalam Java adalah:
Tipe Data
|
Penjelasan
|
byte
|
Variabel-variabel dengan tipe ini
dapat memiliki nilai dari -128 sampai +127 dan menempati 1 byte (8 bit) dalam
memori.
|
short
|
Variabel-variabel dengan tipe ini
dapat memiliki nilai dari -32768 sampai +32767 dan menempati 2 byte (16 bit)
dalam memori.
|
int
|
Variabel-variabel dengan tipe ini
dapat memiliki nilai dari -2147483648 sampai
+2147483647
dan menempati 4 byte (32 bit) dalam memori.
|
long
|
Variabel-variabel dengan tipe ini
dapat memiliki nilai dari -9223372036854775808 sampai +9223372036854775807 dan menempati 8 byte (64 bit) dalam memori.
|
Seperti yang telah disebutkan sebelumnya bahwa
pemilihan tipe data bergantung rentang nilai yang Anda butuhkan. Pada
prakteknya, Anda akan lebih banyak menggunakan tipe int atau long. Lihat
beberapa deklarasi variabel untuk tiap tipe ini:
byte nilaiKecil;
short banyakHal;
int banyakKata;
long nilaiBesar;
Tiap statemen ini mendeklarasikan variabel dengan
tipe data integer yang berbeda.
Rentang nilai yang dapat disimpan oleh tiap tipe
integer dalam Java, seperti ditunjukkan pada tabel, selalu sama, tanpa memandang
jenis komputer yang sedang Anda gunakan. Ini juga berlaku untuk tipe-tipe
primitif atau fundamental lainnya.
Gambar 2.1
Meskipun rentang nilai untuk tiap tipe data integer
dinyatakan dalam nilai desimal, nilai integer secara internal disimpan dalam
biner, dan banyak bit yang disediakan untuk menyimpan tiap tipelah yang
menentukan nilai maksimum dan nilai minimum, seperti ditunjukkan pada Gambar
2.1.
Untuk tiap
bilangan biner yang ditunjukkan di sini, bit paling-kiri adalah bit tanda, yang
ditandai dengan s. Ketika bit tanda bernilai 0, maka nilai integer bernilai
positif, sebaliknya jika s bernilai 1, maka nilai integer bernilai negatif.
Bilangan-bilangan negatif biner direpresentasikan dalam bentuk komplemen 2.
Literal Integer
Variabel integer menyimpan nilai integer, jadi
sebelum Anda menggunakan variabel integer Anda perlu memahami bagaimana Anda
menuliskan nilai-nilai integer dengan berbagai tipe data. Seperti disebutkan
sebelumnya, sembarang nilai konstanta dalam Java disebut dengan literal. Jadi,
3, 45.7, dan “Ini adalah konstanta” semuanya adalah contoh literal.
Setiap literal integer yang merupakan rentetan dijit
desimal secara default memiliki tipe int.
Jadi, 1, -9999, dan 12345 semuanya adalah literal dengan tipe int. Jika Anda ingin mendefinisikan
sebuah literal integer dengan tipe long, maka Anda perlu menambahkan L di akhir
nilai tersebut. Nilai 1L, -9999L, dan 12345L semuanya bertipe long. Anda dapat
pula menggunakan huruf kecil l,
tetapi hal itu tidak direkomendasikan karena mirip dengan dijit 1.
Anda mungkin bertanya-tanya bagaimana bila Anda
ingin menetapkan literal dengan tipe byte
atau short. Karena cara kerja
aritmetika dalam Java, kedua literal itu tidak terlalu diperlukan. Anda akan
melihat beberapa contoh dimana literal integer dapat diinterpretasikan oleh
kompilator sebagai tipe byte atau short nanti pada bab ini.
Anda dapat pula menetapkan literal integer dengan
basis 16. Integer basis 16 dikenal pula sebagai bilangan heksadesimal. Literal
heksadesimal dalam Java memiliki 0x atau 0X di depannya dan mengikuti konvensi
penggunaan huruf A sampai F (atau a sampai f) untuk merepresentasikan nilai 10
sampai 15. Berikut adalah beberapa contohnya:
0x100
|
1 * 16^2 + 0 * 16^1 + 0 * 16^0
|
Ekivalen dengan 256 dalam desimal
|
0x1234
|
1 * 16^3 + 2 * 16^2 + 3 * 16^1 + 4 * 16^0
|
Ekivalen dengan 4660 dalam desimal
|
0xDEAF
|
13 * 16^3 + 14 * 16^2 + 10 * 16^1 + 15 * 16^0
|
Ekivalen dengan 57007 dalam desimal
|
0xCAB
|
12 * 16^2 + 10 * 16^1 + 11 * 16^0
|
Ekivalen dengan 3243 dalam desimal
|
Semua literal
heksadesimal pada tabel di atas bertipe int.
Jika Anda ingin menetapkan literal heksadesimal dengan tipe long, Anda perlu menempatkan L di akhir
literal. Sebagai contoh, 0x0FL adalah sebuah literal heksadesimal yang ekivalen
dengan nilai desimal 15.
Mendeklarasikan
Variabel Integer
Seperti yang telah Anda lihat, Anda dapat
mendeklarasikan sebuah variabel bertipe long
dengan statemen:
long nilaiBesar;
Statemen ini adalah sebuah deklarasi untuk variabel nilaiBesar. Ini menetapkan bahwa
variabel nilaiBesar akan menyimpan
sebuah nilai dengan tipe long.
Ketika statemen ini dikompilasi, 8 byte memori akan dialokasikan bagi variabel nilaiBesar. Java tidak secara otomatis
menginisialisasi sebuah variabel. Jika Anda ingin variabel Anda untuk memiliki
nilai awal, maka Anda perlu menetapkannya sendiri pada deklarasi Anda. Untuk
mendeklarasikan dan menginisialisasi (memberi nilai awal) variabel nilaiBesar menjadi 233333333, Anda
menuliskan:
long nilaiBesar = 233333333L;
Variabel nilaiBesar
akan memiliki nilai sesuai dengan apa yang ada di sebelah kanan tanda
sama-dengan. Anda direkomendasikan untuk selalu menginisialisasi variabel Anda
ketika mendeklarasikannya. Perhatikan bahwa jika Anda mencoba menggunakan
sebuah variabel yang belum diinisialisasi dalam sebuah perhitungan, maka Anda
program Anda tidak akan bisa dikompilasi. Ada beberapa kompilator yang
menyatakannya sebagai error.
Anda dapat mendeklarasikan sebuah variabel di mana
saja di dalam program Anda, tetapi Anda harus mendeklarasikan tiap variabel
sebelum menggunakannya dalam perhitungan. Penempatan deklarasi memiliki efek
apakah variabel tertentu dapat diakses pada titik tertentu pada sebuah program.
Hal ini akan dibahas lebih lanjut pada bab selanjutnya.
Anda dapat mendeklarasikan dan mendefinisikan
beberapa variabel sekaligus pada sebuah statemen. Misalnya:
long nilaiBesar = 99999999L, nilaiTinggi = 100000000L;
Di sini Anda mendeklarasikan dua variabel bertipe long. Tanda koma memisahkan satu
variabel dari variabel lain. Anda dapat mendeklarasikan sebanyak mungkin
variabel yang Anda sukai pada sebuah statemen, meskipun direkomendasikan agar
Anda mendeklarasikan satu variabel untuk tiap statemen. Hal ini akan membantu
orang lain atau diri Anda sendiri dalam membaca program Anda. Pengecualian terjadi
pada variabel-variabel yang sangat berkorelasi. Misalnya, sepasang koordinat
(x, y) yang merepresentasikan sebuah titik koordinat, yang Anda deklarasikan
sebagai:
int xKoord = 0, yKoord = 0; //
Koordinat titik
Pada baris kode yang sama dimana deklarasi kedua
variabel diberikan, Anda menambahkan sebuah komentar yang ditempatkan setelah
dua garis-miring (slash), yang menjelaskan untuk apa variabel tersebut.
Kompilator mengabaikan semua yang ada setelah tanda // sampai akhir baris.
Penjelasan tentang tujuan variabel merupakan hal yang baik dalam pemrograman,
baik untuk Anda maupun untuk programer lain yang membaca program Anda.
Anda juga dapat menyebar sebuah deklarasi tunggal
pada beberapa baris jika Anda inginkan. Ini akan membuat program Anda lebih
mudah dibaca. Sebagai contoh:
int km = 0, // Satu
kilometer adalah 1000 meter
meter =
0, // Satu meter adalah 100
sentimeter
senti =
0, // Satu sentimeter adalah 10
milimeter
mili = 0;
Statemen ini mendefinisikan empat variabel bertipe int pada satu statemen tunggal dengan
nama km, meter, senti, dan mili. Setiap variabel memiliki 0
sebagai nilai awalnya. Anda perlu memastikan bahwa nilai awal untuk sebuah
variabel harus berada dalam rentang dari tipe yang dipakai. Kalau tidak,
kompilator akan memandangnya sebagai error. Kompilator Anda cukup cerdas dalam
mengenali dan membedakan antara tipe-tipe fundamental. Karena statemen disebar
ke empat baris kode, maka Anda bisa menambahkan komentar pada tiap baris kode
untuk menjelaskan kegunaan tiap variabel.
Selanjutnya, Anda dapat mendeklarasikan sekaligus
menginisialisasi sebuah variabel bertipe byte dan variabel lain bertipe short
dengan dua statemen berikut:
byte nilaiKeberuntungan = 7;
short nilaiKecil = 1234;
Di sini
kompilator menyimpulkan bahwa literal-literal integer tersebut bertipe byte dan short. Adalah tanggung-jawab Anda untuk memastikan bahwa nilai awal
harus berada dalam rentang nilai dari tipe variabel yang diberikan. Jika tidak,
kompilator akan menolak statemen tersebut dan menampilkan pesan error.
Tipe Data Titik-Mengambang
Nilai-nilai numerik yang bukan bilangan bulat
(integer) dikatakan sebagai bilangan pecahan (titik-mengambang). Sebuah
bilangan titik-mengambang memiliki banyak dijit keakuratan yang tetap tetapi
dengan rentang nilai yang lebar. Misalnya, nilai 0.000005, 500.0, dan 5000000000000.0
dapat dituliskan dengan dan 5x10^-6, 5x10^2, 5x10^12.
Pada contoh tersebut, Anda hanya memiliki satu dijit tetapi Anda memiliki tiga
bilangan yang berbeda dengan menggeser titik desimal.
Ada dua tipe titik-mengambang primitif atau
fundamental dalam Java, tipe float
dan tipe double. Ini memberikan Anda
pilihan banyaknya dijit kepresisian yang tersedia untuk merepresentasikan
nilai-nilai data Anda:
Tipe Data
|
Penjelasan
|
float
|
Variabel dengan tipe ini dapat
memiliki nilai dari -3.4E38 sampai +3.4E38 dan menempati 4 byte dalam memori.
Nilai-nilai secara aproksimasi direpresentasikan dengan akurasi 7 dijit
desimal.
|
short
|
Literal
Titik-Mengambang
Literal titik-mengambang secara default adalah tipe double, jadi 1.0 dan 345.678 keduanya
adalah tipe double. Ketika Anda
ingin menetapkan sebuah nilai dengan tipe float,
maka Anda perlu menambahkan akhiran f atau F pada nilai tersebut, sehingga 1.0f
dan 345.678F keduanya adalah literal bertipe float.
Ketika Anda
perlu menulislakn nilai titik-mengambang yang sangat besar atau yang sangat
kecil, maka biasanya Anda akan menuliskannya menggunakan eksponen. Anda dapat
melakukannya dalam Java dengan menuliskan sebuah nilai desimal yang diikuti
dengan huruf E atau e. Misalnya, jarak dari Bumi ke Matahari adalah berkisar
149600000 kilometer, yang lebih mudah dituliskan dengan 1.496E8.
Mendeklarasikan
Variabel Titik-Mengambang
Anda mendeklarasikan variabel titik-mengambang
dengan cara yang sama ketika Anda mendeklarasikan variabel integer. Anda dapat
mendeklarasikan dan menginisialisasi sebuah variabel bertipe double dengan statemen berikut:
double jarakMatahari = 1.496E8;
Ini mendeklarasikan variabel dengan nama jarakMatahari dan menginisialisasinya dengan nilai awal.
Pendeklarasian variabel dengan tipe float dilakukan dengan cara sama.
Misalnya:
float massaElektron = 9E-28F;
Anda tentu saja dapat mendeklarasikan lebih dari
satu variabel pada sebuah statemen:
float beratnya = 123.4F, beratku = 108.F;
Menetapkan Nilai Dari Sebuah Variabel
Kadangkala, Anda perlu mendeklarasikan dan
menginisialisasi sebuah variabel dengan nilai yang tidak seharusnya dapat
diubah. Misalnya:
int meter_per_senti = 100;
double mm_pe_inci = 25.4;
Kedua nilai ini seharusnya tidak perlu diubah. Satu
meter selalu bernilai 100 sentimeter, dan satu inci selalu bernilai 25.4
milimeter. Meskipun keduanya bernilai tetap yang dapat Anda gunakan dalam
perhitungan, tetapi akan lebih baik bila menyimpannya ke dalam variabel yang
membuatnya mudah dimengerti dalam program. Jika Anda menggunakan nilai 100 pada
kode program Anda, nilai itu dapat bermakna apapun, tetapi nama meter_per_senti memiliki makna yang
sudah jelas dari namanya.
Java menyediakan cara agar Anda bisa menetapkan
nilai dari sembarang variabel yang tidak bisa diubah pada kode program Anda
menggunakan katakunci final ketika
Anda mendeklarasikan variabel tersebut. Misalnya:
final int METER_PER_SENTI = 100; //
Nilai-nilai konstan
final double MM_PER_INCI = 2.54; //
yang tidak dapat diubah
Katakunci final
menyatakan bahwa nilai dari sebuah variabel sudah final dan tidak dapat diubah
lagi. Kompilator akan memeriksa kode Anda dan memandangnya sebagai error bila
kode Anda mencoba untuk mengubah nilainya.
Perhitungan Aritmatik
Anda menyimpan hasil perhitungan ke dalam sebuah
variabel menggunakan statemen penugasan.
Statemen penugasan terdiri-dari tiga elemen: nama variabel dimana Anda akan
menyimpan hasil perhitungan ke dalamnya; operator penugasan, =, yang
mengindikasikan bahwa yang terjadi adalah operasi penugasan; dan ekspresi
aritmatik yang mendefinisikan perhitungan yang akan dilakukan. Keseluruhannya
dihentikan atau diakhiri dengan sebuah karakter semikolon (titik-koma). Berikut
adalah sebuah contoh sederhana dari statemen penugasan:
banyakBuah = banyakApel + banyakPisang; // Perhitungan banyak buah
Ketika statemen ini dieksekusi, nilai dari ekspresi
yang ada di sebelah kanan operator penugasan = akan dihitung, dan hasilnya
disimpan ke dalam variabel yang ada di sebelah kiri operator penugasan. Pada
kasus ini, nilai yang disimpan di dalam variabel banyakApel dan banyakPisang
dijumlahkan, dan hasilnya disimpan ke dalam variabel banyakBuah. Tentu, Anda perlu mendeklarasikan ketiga variabel
sebelum statemen ini diberikan.
Penginkremenan sebuah variabel dengan nilai tertentu
merupakan salah satu teknik pemrograman yang sering dilakukan. Lihat statemen
penugasan berikut:
banyakApel = banyakApel + 1;
Hasil evaluasi ekspresi di sebelah kanan = akan
bernilai satu lebih banyak dari nilai banyakApel.
Hasil ini disimpan kembali ke dalam variabel banyakApel, sehingga efek menyeluruh dari eksekusi statemen ini
adalah menginkremen nilai banyakVariabel
sebesar 1. Anda akan melihat cara alternatif yang lebih ringkas dari ini nanti.
Anda dapat menuliskan beberapa statemen penugasan
pada satu statemen. Dimisalkan bahwa Anda memiliki tiga variabel a, b, dan c
yang telah Anda definisikan sebagai tipe int, dan Anda ingin menetapkan
ketiganya dengan nilai 777. Anda dapat melakukannya dengan statemen berikut:
a = b = c = 777;
Perhatikan bahwa penugasan berbeda dengan inisialisasi
pada sebuah deklarasi. Inisialisasi menyebabkan sebuah variabel memiliki nilai
konstan yang Anda tetapkan ketika menciptakan variabel. Penugasan menyebabkan
penyalinan data dari satu tempat di dalam memori ke tempat lain. Dari statemen
contoh di atas, kompilator akan mengalokasikan memori yang sama (4 byte) untuk
menyimpan nilai konstan 777 dengan tipe int.
Nilai ini kemudian disalin ke variabel c. Nilai di dalam c akan diekstraksi dan
disalin ke b. Terakhir, nilai di dalam b akan disalin ke dalam a.
Dengan penugasan sederhana atas suatu nilai konstan
kepada sebuah variabel bertipe short
atau byte, nilai konstan tersebut
akan disimpan sebagai tipe data dari variabel yang ada di sebelah kiri operator
penugasan =, bukan sebagai tipe int.
Misalnya:
short nilai = 0;
nilai = 10;
Di sini, Anda
memiliki sebuah statemen deklarasi untuk variabel nilai, yang diikuti dengan sebuah statemen penugasan. Ketika
deklarasi dieksekusi, kompilator kemudian mengalokasikan memori untuk variabel nilai, dan menetapkan nilai awalnya
menjadi 0. Statemen penugasan yang ada setelah statemen deklarasi menetapkan 10
sebagai literal integer dengan tipe short,
yang menempati 2 byte, karena variabel nilai
bertipe short. Nilai 10 akan disalin
ke variabel nilai.
Perhitungan
Integer
Operator-operator dasar yang Anda gunakan dalam
perhitungan melibatkan +, -, *, dan /, yang masing-masing bermakna penjumlahan,
pengurangan, perkalian, dan pembagian. Setiap operator ini dikatakan sebagai
operator biner, karena menggabungkan kedua operandnya untuk memberikan sebuah
hasil. Misalnya, 2 + 3 menghasilkan 5. Operand adalah istilah untuk suatu nilai
dimana sebuah operator akan diterapkan kepadanya. Prioritas atau keutamaan yang
berlaku pada operator-operator ini sama seperti yang telah Anda pelajari di
sekolah. Jadi, operasi perkalian dan pembagian dieksekusi lebih dahulu daripada
operasi penjumlahan atau pengurangan. Evaluasi terhadap ekspresi:
20 – 3 * 3 – 9/3
akan menghasilkan nilai 8, karena ekspresi itu
ekivalen dengan 20 – 9 – 3.
Seperti yang telah Anda pelajari di sekolah, Anda
bisa memanfaatkan tanda kurung untuk mengubah urutan operasi. Ekspresi-ekspresi
di dalam kurung selalu dievaluasi lebih dahulu, yang dimulai dari ekspresi yang
paling dalam. Jadi, Anda bisa mengganti urutan eksekusi default sesuai dengan
keinginan Anda. Oleh karena itu, ekspresi
(20 – 3) * (3 – 9) / 3
ekivalen dengan 17 * (-6) / 3, yang hasilnya -34.
Tentu, Anda menggunakan operator-operator ini dengan
variabel-variabel yang menyimpan nilai-nilai integer dan literal-literal
integer. Anda dapat menghitung sebuah nilai yang akan disimpan ke dalam sebuah
variabel, luas, yang bertipe int, dari nilai-nilai pada variabel panjang dan lebar, yang juga bertipe int,
dengan menuliskan:
luas = panjang * lebar;
Seperti
disebutkan sebelumnya, operator-operator ini adalah operator biner, yang
memerlukan dua operand. Terdapat pula versi unary dari operator + dan – yang
bisa dipakai terhadap satu operand. Misalnya, jika variabel cacah memiliki nilai -10, maka ekspresi
–cacah akan menghasilkan nilai +10.
Tentu, penerapan operator unary + terhadap nilai dari sebuah variabel akan
menghasilkan nilai yang sama. Tidak berdampak apapun.
Latihan
|
Apel dan Jeruk
|
Ketiklah kode pada contoh ini dan simpan dengan nama
file Buah.java. Anda tentu ingat
dari bab sebelumnya bahwa setiap file sumber akan memuat satu definisi kelas,
dan nama file tersebut harus sama dengan nama kelas. Simpan file ke dalam
sebuah direktori yang terpisah dari hierarki yang memuat JDK. Anda bisa
memberikan nama apapun pada direktori tersebut.
public class Buah {
public static void main(String[] args) {
// Mendeklarasikan dan menginisialisasi tiga variabel
int banyakJeruk = 5; // Jumlah
jeruk
int banyakApel = 10; // Jumlah
apel
int banyakBuah = 0; // Jumlah buah
banyakBuah = banyakJeruk + banyakApel; // Menghitung banyak total buah
// Menampilkan hasil
System.out.println("Program menghitung total buah");
System.out.println("Banyak total buah adalah " + banyakBuah);
}
}
Pada beberapa lingkungan Java, keluaran bisa jadi
tidak ditampilkan cukup lama sehingga Anda tidak bisa melihatnya. Jika kasus
ini terjadi pada Anda, maka Anda perlu menambahkan beberapa kode baris agar
program menunggu sampai Anda menekan Enter sebelum program mengakhirinya:
import java.io.IOException; // Agar kode menunda
program berakhir
public class TungguBuah {
public static void main(String[] args) {
// Mendeklarasikan dan menginisialisasi tiga variabel
int banyakJeruk = 5; // Jumlah
jeruk
int banyakApel = 10; // Jumlah
apel
int banyakBuah = 0; // Jumlah buah
banyakBuah = banyakJeruk + banyakApel; // Menghitung banyak total buah
// Menampilkan hasil
System.out.println("Program menghitung total buah");
System.out.println("Banyak total buah adalah " + banyakBuah);
// Kode untuk menunda mengakhiri program
System.out.println("(Tekan Enter untuk mengakhiri)");
try {
System.in.read(); // Membaca
masukan dari keyboard
}
catch (IOException e) { // Menangkap eksepsi masukan
return; // kembali
}
}
}
Jika Anda menjalankan program ini, makan keluaran
akan tampak seperti pada Gambar 2-2.
Gambar 2-2
Elemen-elemen dasar dari kode program ditampilkan
pada Gambar 2-3.
Program ini hanya memiliki satu kelas, Buah, dan satu metode, main(). Eksekusi atas sebuah aplikasi
selalu diawali dari statemen pertama pada metode main(). Tidak ada objek kelas Buah yang didefinisikan, tetapi
metode main() tetap dapat dieksekusi
karena dideklarasikan static. Metode
main() selalu ditetapkan public dan static dan dengan tipe nilai balik void. Efek dari ketiga katakunci
ini adalah berikut:
public
|
Menetapkan bahwa metode main() dapat diakses dari luar kelas
Buah.
|
static
|
Menyatakan bahwa metode main() adalah sebuah metode kelas
yang dapat dieksekusi, meskipun tidak ada objek kelas yang diciptakan.
|
void
|
Menetapkan bahwa metode main() tidak menghasilkan nilai
apapun.
|
Gambar 2-3
Tiga statemen pertama pada main() mendeklarasikan variabel banyakJeruk, banyakApel, dan banyakBuah
dengan tipe int dan
menginisialisasinya dengan nilai 5, 10, dan 0. Statemen selanjutnya
menjumlahkan nilai yang disimpan pada banyakJeruk
dan banyakApel, dan menyimpan
hasilnya, 15, pada variabel banyakBuah.
Menghasilkan
Keluaran
Dua statemen berikutnya
menggunakan metode println(), yang
menampilkan keluaran teks. Statemen tersebut tampak sedikit rumit tetapi dapat
dibedah dengan mudah, seperti ditunjukkan Gambar 2-4.
Gambar 2-4
Teks yang ada di antara dua
kutip-ganda, “Program menghitung total
buah”, adalah string karakter. Kapanpun Anda memerlukan konstanta string,
Anda bisa menempatkan runtun karakter yang Anda inginkan di antara dua
tanda-kutip ganda.
Di sini metode println() dieksekusi, yang merupakan
metode dari objek out. Objek out adalah sebuah anggota statis dari
kelas System. Karena objek out berwatak statis, maka objek itu
tetap ada meskipun tidak ada objek bertipe System
yang diciptakan. Hal ini ekivalen dengan penggunaan katakunci static untuk metode main().
Kebanyakan objek pada sebuah
program merupakan anggota non-statis dari suatu kelas, jadi pemanggilan sebuah
metode objek umumnya melibatkan nama objek dan nama metode. Misalnya, jika Anda
ingin memanggil metode sebutNamaSaya()
dari objek namaSaya dengan tipe Nama, maka Anda akan menuliskan:
namaSaya.sebutNamaSaya();
Jangan khawatir ketika Anda belum
memahami ini. Anda akan mempelajari hal ini nanti pada bab yang spesifik
membahas kelas. Untuk sementara, Anda hanya perlu mengetahui bahwa kapanpun
Anda ingin menampilkan teks pada keluaran, Anda hanya perlu menuliskan
System.out.println(“Apapun yang ingin Anda
tampilkan silahkan taruh di sini”);
Selanjutnya, statemen kedua:
System.out.println("Banyak total buah adalah " + banyakBuah);
menampilkan string karakter “Banyak total buah adalah “ yang
diikuti dengan nilai dari banyakBuah
yang telah dikonversi menjadi karakter-karakter, yaitu 15. Jadi, Apa yang
dilakukan tanda plus (+) di sini bukanlah operasi aritmatik. Operasi
penjumlahan (+) memiliki efek khusus ketika digunakan pada operand-operand
string karakter, yaitu menggabungkan kedua string karakter menjadi string
tunggal. Tetapi, apakah banyakBuah adalah
sebuah string? Tidak, tetapi operand kiri, “Banyak
total buah adalah ”, adalah sebuah string, dan ini menyebabkan kompilator
memutuskan bahwa keseluruhannya adalah ekspresi yang diterapkan pada
string-string karakter.
Oleh karena itu, kompilator
mengkonversi nilai dari operand kanan, banyakBuah,
menjadi string karakter agar kompatibel dengan operand kiri. Efek operasi +
adalah menempelkan representasi string dari nilai banyakBuah ke akhir dari string “Banyak total buah adalah “. String komposit ini kemudian
dilewatkan kepada metode println()
untuk ditampilkan di layar monitor.
Jika Anda menginginkan nilai
keluaran dari banyakJeruk juga ditampilkan, Anda bisa menuliskan:
System.out.println(“Banyak total buah adalah
“ + banyakBuah + “ dan banyak jeruk = “ + banyakJeruk);
Pembagian dan Sisa Pembagian
Integer
Ketika Anda membagi satu integer
dengan integer lainnya dan hasilnya tidak akurat, itu karena sisa pembagian
telah dibuang. Jadi, hasil akhirnya selalu integer. Pembagian 3/2, misalnya,
menghasilkan nilai 1, dan 11/3 menghasilkan nilai 3. Untuk membagi banyakBuah
secara merata kepada empat anak, Anda bisa melakukannya:
int banyakBuah = 0; // Banyak buah untuk tiap anak
banyakBuah = banyakBuah/4;
Hasil pembagian ketika kedua
operandnya bernilai positif adalah positif. Operand di sisi kanan operator
pembagian / disebut dengan pembagi atau divisor dan operand di sisi kiri
operator / disebut dengan dividend.
Jika Anda membagi 7 dengan -3,
maka hasilnya adalah -2. Sama halnya, jika Anda membagi -10 dengan 4, maka
hasilnya adalah -2. Jika Anda membagi -5 dengan -3, maka hasilnya adalah +1.
Magnitudo hasil atas pembagian nilai a dengan nilai b adalah sama, tetapi tanda
hasil bergantng pada tanda dari operand-operandnya. Tanda hasil akan positif
ketika kedua operand bertanda positif atau kedua operand bertanda negatif.
Tanda hasil akan negatif ketika kedua operand berbeda tanda dan divisor tidak
lebih besar dari dividend (jika tidak, hasilnya akan nol).
Pembagian dengan nol sebaiknya
dihindari. Jika Anda secara tak sengaja melakukannya, maka program akan
berhenti karena eksepsi bertipe ArithmeticException akan otomatis dilemparkan.
Anda akan mempelajari tentang ekseps pada Bab 7.
Tentu, ada beberapa kasus dimana
Anda ingin mendapatkan sisa hasil pembagian, dan pada kesempatan itu Anda dapat
menghitungnya menggunakan operator modulus, %. Jika Anda ingin mengetahui
berapa banyak buat yang tersisa setelah membagi total buah pada empat anak,
maka Anda bisa menuliskan:
int sisa;
sisa = banyakBuah%4; // Menghitung sisa setelah pembagian 4
Ketika salah satu atau kedua
operand dari operator sisa adalah negatif, maka hasilnya akan sedikit membuat
Anda bingung. Anda perlu mengingat bahwa operasi modulus ini berkaitan dengan
operasi pembagian, jadi Anda perlu mengetahui berapa hasil pembagian, dan dari
situ Anda bisa mendeduksi hasil dari operasi sisa atau modulus.
Hasil dari operasi 8 % (-2)
adalah +2. Ingat bahwa hasil dari 8 / (-3) adalah -2. Jika Anda mengalikan
hasil pembagian dengan divisor, (-2) * (-3), hasilnya adalah +6. Jadi, sisa +2 menjadi
masuk akal. Ekspresi (-8) % 3 menghasilkan -2, yang bisa dideduksi dari hasil
atas (-8) / 3, yaitu -2. Anda bisa menambahkan -2 pada hasil dari (-2) * (3)
untuk mendapatkan nilai awal, -8.
Operator Inkremen dan Dekremen
Jika Anda ingin
menambah nilai dari sebuah variabel integer dengan satu, Anda bisa menggunakan
operator inkremen menggantikan statemen penugasan. Anda bisa menuliskan
operator inkremen menggunakan dua tanda plus, ++. Misalnya, jika Anda memiliki
sebuah variabel integer cacah yang
Anda deklarasikan sebagai:
int cacah = 10;
maka Anda kemudian dapat
menuliskan statemen:
++cacah; //
Menambahkan 1 pada cacah
Statemen ini akan menambah 1 pada
nilai cacah menjadi 11. Jika Anda
ingin mengurangi nilai cacah sebesar 1, maka Anda dapat menggunakan operator
dekremen, --:
--cacah; //
Mungurangi 1 dari cacah
Sekilas, Anda tidak melihat
banyak keuntungan, karena Anda bisa saja melakukannya dengan menuliskan:
cacah = cacah – 1; // Mengurangi 1 dari cacah
Namun, keuntungan dari operator
inkremen dan operator dekremen adalah bahwa Anda dapat menggunakannya pada
sebuah ekspresi. Anda bisa mencoba mengubah statemen aritmatik yang menghitung
penjumlahan atas banyakApel dan banyakJeruk pada contoh sebelumnya:
public class Buah {
public static void main(String[] args) {
// Mendeklarasikan dan menginisialisasi tiga variabel
int banyakJeruk = 5; // Jumlah
jeruk
int banyakApel = 10; // Jumlah
apel
int banyakBuah = 0; // Jumlah buah
//
Menginkremen dan menghitung total buah
banyakBuah
= ++banyakJeruk + banyakApel;
System.out.println("Program menghitung total buah");
// Menampilkan hasil
System.out.println("Nilai jeruk adalah " + banyakJeruk);
System.out.println("Banyak total buah adalah " + banyakBuah);
}
}
Baris-baris kode
yang telah diubah atau ditambahkan diberi keabuan yang lebih gelap. Untuk
mengubah perhitungan banyakBuah,
sebuah statemen ekstra telah ditambahkan untuk menampilkan nilai akhir dari banyakJeruk. Nilai dari banyakJeruk akan diinkremen menjadi 6
sebelum ditambahkan pada nilai banyakApel.
Jadi, nilai dari banyakBuah menjadi
16. Oleh karena itu, statemen tersebut mengubah nilai yang disimpan pada banyakJeruk dan juga mengubah nilai
yang disimpan pada banyakBuah. Anda
juga dapat mencoba operasi dekremen dengan cara yang sama.
Watak operator
inkremen dan operator dekremen yang lain adalah keduanya berperilaku berbeda
pada sebuah ekspresi, yang tergantung pada di posisi operator apakah di depan
variabel atau di belakang variabel Anda menempatkannya. Ketika Anda
menempatkannya di depan sebuah variabel, seperti pada contoh yang telah
ditunjukkan, hal ini dinamakan dengan bentuk
prefiks. Sebaliknya, dengan operator berada di belakang variabel, formasi
tersebut dikatakan sebagai bentuk postfiks.
Jika Anda mengubah statemen pada contoh menjadi:
banyakBuah
= banyakJeruk++ + banyakApel;
dan mengeksekusi
kembali program tersebut, maka Anda akan mendapati bahwa banyakJeruk masih tetap bernilai 6, tetapi total buah yang disimpan
pada variabel banyakBuah bernilai
15. Ini dikarenakan efek postfiks pada operator inkremen yang mengubah nilai
dari banyakJeruk menjadi 6 setelah
nilai awalnya, 5, telah dipakai pada ekspresi yang melakukan operasi
penjumlahan. Operator dekremen postfiks bekerja dengan cara sama.
Seperti yang
Anda perhatikan, tidak ada tanda-kurung yang diperlukan pada ekspresi banyakJeruk++ + banyakApel. Anda bahkan
dapat menuliskannya sebagai banyakJeruk+++banyakApel
dan maknanya masih tetap sama, meski cukup sulit dibaca oleh pembaca program
Anda. Seseorang yang tidak mengetahui aturan evaluasi ekspresi Java bisa secara
salah menebaknya sebagai banyakJeruk+(++banyakApel).
Kebingungan semacam itu tentu saja kesalahan penulis program. Anda bisa
menuliskannya sebagai (banyakJeruk++) +
banyakApel untuk menghindarkan kebingungan pembaca program.
Perhitungan
dengan Tipe-Tipe Integer Lebih Pendek
Semua variabel
yang telah digunakan sejauh ini adalah tipe int. Perhitungan yang melibatkan variabel-variabel dengan tipe
integer yang lebih pendek menyebabkan beberapa komplikasi. Ini karena semua
operasi integer biner dalam Java hanya dapat diterapkan pada operand-operand
bertipe int atau operand-operand
bertipe long. Hasilnya adalah bahwa
pada ekspresi aritmatik yang melibatkan variabel-variabel bertipe byte atau
short, nilai dari variabel-variabel tersebut lebih dahulu dikonversi menjadi
tipe int, dan perhitungan kemudian dilakukan menggunakan aritmatik 32-bit.
Hasilnya akhirnya akan bertipe integer 32-bit. Ini berdampak menarik seperti
yang dapat Anda lihat pada konteks contoh sebelumnya. Cobalah mengubah tipe
variabel banyakJeruk, banyakApel, dan banyakBuah menjadi tipe short,
misalnya:
short banyakJeruk = 5;
short banyakApel = 10;
short banyakBuah = 0;
Anda akan
mendapati bahwa program tidak lagi bisa dikompilasi. Permasalahannya ada pada
statemen:
banyakBuah = banyakJeruk +
banyakApel;
Ekspresi banyakJeruk + banyakApel akan
menghasilkan nilai bertipe 32-int, kompilator tidak bisa menyimpannya pada
variabel banyakBuah, karena banyakBuah adalah variabel hanya
memiliki ruang memori 16 bit. Agar kode tetap dapat dikompilasi, Anda perlu
memodifikasi statemen penugasan sehingga hasil penjumlahan 32-bit dikonversi
kembali menjadi 16-bit. Anda dapat melakukannya dengan mengubah statemen di
atas menjadi:
banyakBuah = (short)(banyakJeruk
+ banyakApel);
Statemen
tersebut sekarang dapat menghitung penjumlahan atas banyakJeruk dan banyakApel
dan kemudian mengkonversi hasil penjumlahan 32-bit menjadi tipe short sebelum menyimpannya pada banyakBuah. Ini dinamakan dengan konversi tipe eksplisit (explicit cast). Jika variabel-variabel
di sini bertipe byte, maka Anda
perlu melakukan konversi hasil penjumlahan menjadi tipe byte. Anda akan
menuliskan dengan (byte).
Efek dari
konversi tipe short pada contoh ini adalah hanya mengambil 16 bit LSB (least-significant bit) dari hasil dan
membuang 16 bit MSB (most-significant bit).
LSB adalah bit-bit di sebelah kanan karena bit-bit pada bilangan biner pada
Java disusun dari kanan ke kiri. Jadi, MSB adalah bit-bit di sebelah kiri pada
bilangan biner. Pada konversi tipe byte,
hanya 8 bit LSB yang dipertahankan. Ini berarti bahwa jika magnitudo hasil dari
penjumlahan memerlukan lebih dari ruang memori 16 bit, maka hasil penjumlahan
akan bernilai salah.
Operasi
aritmatik integer melibatkan sebuah nilai bertipe long akan selalu dilakukan menggunakan nilai nilai-nilai 64-bit.
Jika terdapat nilai lain pada operasi tersebut yang bukan bertipe long, maka kompilator akan melakukan
konversi tipe terhadap nilai tersebut menjadi long sebelum operasi dilakukan. Misalnya:
long hasil;
long faktor;
int nilai = 5;
hasil = faktor*nliai;
Pada saat
eksekusi terhadap statemen terakhir dilakukan, karena variabel faktor bertipe long, perkalian akan dilakukan dengan
melibatkan nilai-nilai long. Nilai
yang disimpan pada variabel nilai akan dikonversi menjadi long sebelum nilainya dikalikan dengan faktor. Semua operasi aritmatik yang melibatkan tipe-tipe selain long akan dilakukan dengan nilai-nilai
32-bit. Jadi, Anda
Perhitungan
Titik-Mengambang
Empat operator
aritmatik dasar, +, -, *, /, juga dapat dipakai pada ekspresi titik-mengambang.
Anda dapat mencobanya pada program berikut.
Latihan
|
Rerata
Buah
|
Lakukan sejumlah
perubahan pada file Buah.java, dan
simpan dengan nama RerataBuah.java.
Jika diperlukan, Anda bisa menambahkan pada kode agar program menunggu sampai
kunci Enter ditekan sebelum program berakhir.
public class RerataBuah {
public static void main(String[] args) {
// Mendeklarasikan dan menginisialisasi
tiga variabel
double banyakJeruk = 50.0E-1; // Nilai awal 5.0
double banyakApel = 1.0E1; // Nilai awal 10.0
double rerataBuah = 0.0;
rerataBuah = (banyakJeruk +
banyakApel)/2.0;
// Menampilkan hasil
System.out.println("Program
menghitung total buah");
System.out.println("Rerata buah
adalah " + rerataBuah);
}
}
Hasilnya adalah:
Program menghitung total
buah
Rerata buah adalah 7.5
Operator-Operator Aritmatik Titik-Mengambang Lain
Anda bisa
menggunakan ++ dan -- pada variabel titik-mengambang, dan efeknya sama seperti
pada variabel integer, yang menginkremen atau mendekremen variabel
titik-mengambang. Anda juga dapat menggunakan bentuk prefiks atau postfiks.
Anda juga dapat
menerapkan operator modulus, %, pada nilai-nilai titik-mengambang. Operasi
dengan bentuk:
operandFloat1 %
operandFloat2;
akan
menghasilkan sisa titik-mengambang setelah dilakukan pembagian operandFloat2 dengan operandFloat2. Misalnya, ekspresi 12.6 % 5.1 akan menghasilkan 2.4.
Umumnya, tanda dari hasil penerapan operator modulus terhadap nilai-nilai
titik-mengambang adalah tanda dari dividend. Magnitudo hasil dari operasi sisa
titik-mengambang adalah nilai bulat terbesar sehingga magnitudo hasil dari
perkalian divisor dengan hasil dari operasi sisa tidak melebihi nilai dividend.
Kondisi-Kondisi Error pada Aritmatik
Titik-Mengambang
Ada dua kondisi
error yang dapat terjadi pada operasi-operasi titik-mengambang yang diindikasikan
oleh nilai hasil yang dibangkitkan. Salah satu kondisi terjadi ketika
perhitungan menghasilkan sebuah nilai di luar rentang yang dapat
direpresentasikan oleh tipe titik-mengambang yang sedang digunakan. Kondisi
error lain terjadi ketika secara matematik hasil perhitungan tidak bisa
ditentukan, seperti ketika perhitung melibatkan pembagian dengan nol.
Untuk
mengilustrasikan jenis error pertama, Anda dapat menggunakan sebuah variabel
untuk menetapkan banyak tipe buah. Anda mendefinisikan variabel:
double tipeBuah = 2.0;
dan kemudian
menuliskan-ulang perhitungan sebagai:
rerataBuah = (banyakJeruh +
banyakApel)/tipeBuah;
Statemen
tersebut tentu tidak mengalami masalah apapun, tetapi jika Anda menetapkan tipeBuah menjadi 0.0, maka keluaran
program akan menjadi:
Program menghitung total
buah
Rerata buah adalah Infinity
Nilai Infinity mengindikasikan nilai positif,
yang mengindikasikan rentang yang lebih besar dari nilai terbesar yang dapat
disimpan oleh tipe double.
Jika Anda ingin
melihat hasil tak-tentu, Anda bisa mengganti statemen di atas untuk menghitung
rerataBuah dengan berikut:
rerataBuah = (banyakJeruh –
5.0)/ (banyakApel – 10.0);
Statemen ini akan
menghasilkan nilai tak-tentu. Nilai dari rerataBuah
yang ditampilkan adalah NaN, kependekan
dari Not-a-Number, yang
mengindikasikan sebuah nilai tak-tentu.
Ekspresi Aritmatik Campuran
Anda mungkin
bisa menebak dari diskusi sebelumnya bahwa Anda bisa mencampur nilai-nilai
dengan tipe data berbeda pada sebuah ekspresi. Cara mencampur atau menggabungkannya
diatur dengan cara berikut:
ð
Jika salah satu
operand bertipe double, maka operand
lainnya dikonversi menjadi double
sebelum operasi dilakukan.
ð
Jika salah satu
operand bertipe float, maka operand
lainnya dikonversi menjadi float
sebelum operasi dilakukan.
ð
Jika salah satu
operand bertipe long, maka operand
lainnya dikonversi menjadi long
sebelum operasi dilakukan.
Jika tidak ada
operand yang bertipe double, float, atau long, misalnya bertipe int,
short, atau byte, maka operand-operand tersebut akan dikonversi menjadi tipe int dan menggunakan aritmatik 32-bit
untuk memberikan hasil.
Konversi
Tipe Eksplisit
Bisa jadi bahwa
perlakuan default terhadap ekspresi campuran yang telah disebutkan di atas
bukanlah apa yang Anda inginkan. Misalnya, Anda telah mendefinisikan sebuah
variabel hasil bertipe double; dan dua variabel lain, tiga dan dua, yang bertipe int
dengan nilai awal 3 dan 2. Jika Anda menghitung nilai dari hasil dengan statemen:
hasil = 1.5 + tiga/dua;
maka nilai yang
disimpan pada variabel hasil adalah
2.5, karena tiga/dua akan dieksekusi sebagai sebuah
operasi integer dan menghasilkan nilai 1. Jika Anda mengingkan tiga/dua agar menghasilkan nilai 1.5 (agar hasil akhir penjumlahan
menjadi 3.0), maka Anda perlu melakukan konversi tipe eksplisit:
hasil = 1.5 + (double)tiga/dua;
Ini menyebabkan
nilai yang disimpan pada tiga
dikonversi menjadi tipe double
sebelum operasi pembagian terjadi. Kemudian aturan 1 berlaku untuk operasi
pembagian, dan operand dua juga
dikonversi menjadi tipe double
sebelum operasi pembagian dieksekusi. Oleh karena itu, nilai dari hasil pada kasus ini akan 3.0.
Konversi Tipe
Otomatis Pada Statemen Penugasan
Ketika tipe data
dari hasil dari ekspresi aritmatik di sisi kanan operator penugasan berbeda
dari tipe data dari variabel di sisi kiri operator penugasan, konversi tipe
otomatis akan diterapkan pada hasil sepanjang tidak ada kemungkinan hilangnya
informasi. Tipe-tipe data dasar yang sejauh ini telah didiskusikan memiliki
runtun berikut (berdasarkan besarnya alokasi memori):
byte -> short -> int
-> long -> float -> double
Konversi
otomatis akan dilakukan kompilator sepanjang dilakukan dari kiri ke kanan,
yaitu dari tipe data dengan lokasi memori lebih kecil ke tipe data dengan
alokasi memori lebih besar. Jika arah konversi dilakukan terbalik, dari tipe double menjadi float atau long,
misalnya, maka Anda perlu menyisipkan konversi tipe eksplisit pada kode Anda.
Operator-Operator op=
Operator op=
dipakai pada statemen-statemen dengan bentuk:
lhs op= rhs;
dimana op adalah salah satu dari
operator-operator arimatik +, -, *, /, %. Bentuk ini juga berlaku untuk
operator-operator yang belum Anda kenal. Statemen tersebut di atas merupakan
representasi ringkas dari statemen:
lhs = lhs op (rhs);
Operand di
sisi-kanan (rhs) diapit kurung
karena ia dieksekusi lebih dahulu. Kemudian hasilnya dikombinasikan dengan
operand di sisi-kiri (lhs)
menggunakan operasi op. Lihat
beberapa contoh berikut. Untuk menginkremen sebuah variabel int dengan nama cacah sebesar 5, Anda dapat menuliskan:
cacah += 5;
Tentu, ekspresi
di sisi-kanan dari operator op= dapat berupa apa saja yang legal dalam Java.
Jadi, statemen:
hasil /= a % b/(a+b);
ekivalen dengan:
hasil = hasil/(a % b/(a+b));
Jika tipe dari
hasil dari ekspresi rhs berbeda
dengan tipe dari lhs, maka
kompilator akan secara otomatis melakukan konversi tipe untuk mengkonversi
nilai rhs agar bertipe sama dengan lhs. Ini akan terjadi pada contoh
terakhir jika hasil bertipe int dan a dan b bertipe double, misalnya.
Berikut adalah
operator-operator op= yang dikenal
dalam Java:
+= -= *= /= %=
<<= >>= >>>= &= |= ^=
Konstanta dan Fungsi Matematik
Cepat atau
lambat Anda akan memerlukan fungsi-fungsi matematik pada program Anda, bahkan
jika kasusnya hanya sekedar untuk mendapatkan nilai absolut atau menghitung
akar kuadrat. Java memberikan sejumlah metode yang mendukung fungsi-fungsi
semacam itu sebagai bagian dari pustaka standar yang disimpan pada paket java.lang. Semua fungsi pustaka
tersebut dapat langsung Anda gunakan pada program Anda.
Metode-metode
yang mendukung sejumlah fungsi matematik diimplementasikan pada kelas Math sebagai metode-metode statik. Jadi,
untuk menggunakan fungsi tertentu, Anda hanya perlu menuliskan Math dan nama metode yang ingin Anda
gunakan yang dipisahkan dengan tanda titik. Sebagai contoh, metode sqrt() menghitung akar kuadrat dari
nilai apapun yang Anda tempatkan di dalam kurung tersebut. Untuk menggunakan
metode sqrt() untuk menghasilkan
akar kuadrat dari nilai titik-mengambang yang disimpan pada variabel aNilai, Anda menuliskan:
Math.sqrt(nNilai);
Kelas Math memiliki sejumlah metode untuk
fungsi-fungsi trigonometrik standar:
Berlaku pada
semua metode, argumen-argumen yang Anda tempatkan di dalam kurung yang ada
setelah nama metode dapat berupa sembarang ekspresi yang menghasilkan suatu
nilai dengan tipe yang diperlukan. Metode toRadians()
pada kelas Math akan mengkonversi
sebuah arugmen double, yang
merupakan pengukuran sudut dalam derajat, menjadi radian.
Metode kebalikannya,
toDegrees(), mengkonversi secara
terbalik. Kelas Math juga
mendefinisikan nilai-nilai double untuk konstanta natural e dan pi,
yang dapat diakses dengan Math.E dan
Math.PI.
Kelas Math juga menyediakan fungsi-fungsi
hiperbolik berikut:
Java juga
menyediakan sejumlah fungsi numerik yang diimplementasikan sebagai
metode-metode statik pada kelas Math:
Metode IEEEremainder() menghasilkan sisa dari arg1 setelah dari arg1 setelah pembagian arg1
dibagi dengan arg2 sejumlah kali
yang terdekat dengan nilai eksak dari arg1/arg2.
Ini berbeda dari operator modulus. Operasi arg1
% arg2 menghasilkan sisa setelah
pembagian arg1 dengan arg2 sejumlah kali yang tidak melebihi
nilai absolut dari arg1. Misalnya,
eksekusi atas ekspresi 9.0 % 5.0
akan menghasilkan 4.0, sedangkan Math.IEEEremainder(9.0,
5.0) akan menghasilkan -1.0. Anda
tinggal memilih satu pendekatan dalam menghitung sisa pembagian yang sesuai
dengan kebutuhan Anda.
Ada sejumlah
metode pada kelas Math yang berelasi
dengan operasi titik-mengambang. Metode signum()
menghasilkan signum atas argumen titik-mengambang, yang hasilnya bertipe double atau float. Signum akan dihasilkan dengan tipe data sama seperti
argumennya, dan nilai nol jika argumen bernilai nol, 1.0 jika argumen bernilai
lebih besar dari nol, dan -1.0 jika argumen lebih kecil dari nol. Metode ulp() menghasilkan ukuran dari ULP
(Unit in the Last Place) dari argumen, yang hasilnya bertipe double atau float. ULP adalah perubahan terkecil yang mungkin pada sebuah nilai
titik-mengambang dalam menghasilkan nilai lebih tinggi atau lebih rendah
selanjutnya. Cara lain dalam menyatakan ini adalah bahwa ULP merupakan jarak
antara satu nilai titik-mengambang dengan nilai titik-mengambang lainnya.
Latihan
|
Radius
Kolam Ikan
|
Anda sedang
merancang sebuah kolam berbentuk lingkaran agar Anda bisa memelihara ikan di
dalamnya. Dari peternak ikan merekomendasikan bahwa Anda memerlukan satu kaki
persegi untuk seekor ikan berukuran 2 inci. Permasalahannya di sini adalah
menghitung radius kolam yang akan mengakomodasi 20 ekor ikan yang berukuran
masing-masing 10 inci. Solusinya adalah dengan menuliskannya dengan program
Java. Program berikut akan menghitung radius kolam, dalam kaki dan inci, yang
akan menjadi rumah bagi sejumlah ikan yang akan dipelihara:
public class RadiusKolam {
public static void main(String[] args) {
// Menghitung radius sebuah kolam
// yang dapat menampung 20 ekor ikan
// dengan panjang rerata 10 inci
int banyakIkan = 20; // Banyak ikan di kolam
int panjangIkan = 10; // Panjang rerata ikan
int panjangPerKakiPersegi = 2; // Panjang ikan per kaki persegi
double radius = 0.0; // Radius kolam dalam kaki
int kaki = 0; // Radius kolam dalam kaki (bilangan bulat)
int inci = 0; // - dan inci (dalam bilangan bulat)
double luasKolam =
(double)(banyakIkan*panjangIkan)/panjangPerKakiPersegi;
radius = Math.sqrt(luasKolam/Math.PI);
kaki = (int)Math.floor(radius); //
Mendapatkan nilai kaki saja
inci = (int)Math.round(12.0*(radius -
kaki)); // Mendapatkan nilai inci saja
System.out.println(" Untuk menampung
" + banyakIkan +
" ekor ikan dengan panjang rerata
" + panjangIkan +
" inci, maka Anda memerlukan
sebuah kolam dengan luas " +
System.out.println("Radius sebuah
kolem dengan luas " + luasKolam +
" kaki persegi adalah\n " +
kaki + " kaki " + inci + " inci");
}
}
Simpan file
sumber program dengan nama RadiusKolam.java. Ketika Anda mengkompilasi dan
menjalankannya, Anda akan mendapatkan:
Untuk menampung 20 ekor ikan
dengan panjang rerata 10 inci, maka Anda memerlukan sebuah kolam dengan luas
100.0 kaki persegi.
Radius sebuah kolem dengan
luas 100.0 kaki persegi adalah
5 kaki 8 inci
Penjelasan
Anda lebih
dahulu mendefinisikan variabel-variabel yang menetapkan data awal, diikuti
dengan variabel kaki dan inci yang akan dipakai untuk menyimpan
hasil. Anda kemudian menghitung luas permukaan kolam dalam kaki dengan statemen
ini:
double luasKolam =
(double)(banyakIkan*panjangIkan)/panjangPerKakiPersegi;
Anda melakukan konversi tipe eksplisit pada panjang total ikan pada kolam, banyakIkan*panjangIkan, menjadi tipe double untuk memaksa pembagian dilakukan menggunakan nilai-nilai titik-mengambang, bukan nilai-nilai integer.
Perhitungan
selanjutnya menggunakan metode sqrt()
untuk menghitung radius kolam. Karena luas dari sebuah lingkaran dengan radius
r diberikan dengan formula pi*r^2,
maka Anda menetapkan argumen dari metode sqrt()
sebagai eskpresi luasKolam/Math.PI:
radius =
Math.sqrt(luasKolam/Math.PI);
Hasilnya adalah
dalam kaki sebagai sebuah nilai bertipe double.
Untuk mendapatkan nilai kaki sebagai bilangan bulat, Anda menggunakan metode floor():
kaki =
(int)Math.floor(radius); // Mendapatkan nilai kaki saja
Perhatikan bahwa
konversi tipe menjadi int atas nilai yang dihasilkan oleh metode floor() sangat penting pada statemen
ini; jika tidak, Anda akan mendapatkan pesan error dari kompilator. Nilai yang
dihasilkan oleh metode floor()
adalah sebuah nilai dengan tipe double,
dan kompilator tidak akan mengkonversinya secara implisit menjadi tipe int secara otomatis karena hal itu
menyebabkan terjadinya potensi kehilangan informasi.
Terakhir, Anda
mendapatkan nilai inci dengan mengurangkan nilai kaki dari radius awal, dengan
mengalikan hasilnya dengan 12 untuk mendapatkan inci ekivalen, dan kemudian
membulatkan hasilnya menjadi integer terdekat menggunakan fungsi round():
inci =
(int)Math.round(12.0*(radius - kaki)); // Mendapatkan nilai inci saja
Untuk
menampilkan hasilnya, Anda menetapkan kombinasi atau gabungan string-string dan
variabel-variabel sebagai argumen-argumen kepada dua pemanggilan metode println():
System.out.println("
Untuk menampung " + banyakIkan +
" ekor ikan dengan panjang rerata
" + panjangIkan +
luasKolam + " kaki persegi.");
System.out.println("Radius
sebuah kolem dengan luas " + luasKolam +
" kaki persegi adalah\n " + kaki +
" kaki " + inci + " inci");
Mengimpor Metode-Metode Pada Kelas Math
Akan lebih mudah
bila Anda tidak harus menyebutkan nama kelas Math ketika Anda menggunakan metode-metode pada kelas itu. Kode
program tentu akan jauh lebih ringkas bila Anda bisa hanya menuliskan floor(radius) daripada harus menuliskan
Math.floor(radius), misalnya. Pada
Java, Anda tentu bisa melakukannya. Apa yang perlu Anda lakukan adalah
menempatkan statemen berikut di awal file sumber:
import static
java.lang.Math.*; // Mengimpor semua anggota
kelas statik dari kelas Math
Statemen ini
membuat semua anggota statik dari kelas Math
tersedia bagi kode program Anda tanpa perlu menyebutkan nama kelas itu. Anda
bisa mencoba statemen ini pada contoh RadiusKolam.
Dengan statemen ini ditempatkan di awal file sumber, Anda bisa menghapus semua
nama kelas Math dari semua
pemanggilan metode dari kelas ini.
Simbol * pada
statemen tersebut mengindikasikan bahwa semua nama statik akan diimpor. Jika
Anda hanya ingin mengimpor nama-nama tertentu dari kelas Math yang diperlukan oleh program RadiusKolam, Anda bisa menuliskan:
import static
java.lang.Math.floor; // Mengimpor
metode floor
import static
java.lang.Math.sqrt; // Mengimpor metode sqrt
import static
java.lang.Math.round; // Mengimpor
metode round
import static
java.lang.Math.PI; // Mengimpor konstanta PI
No comments:
Post a Comment