diff options
| -rw-r--r-- | id-id/java-id.html.markdown | 801 |
1 files changed, 801 insertions, 0 deletions
diff --git a/id-id/java-id.html.markdown b/id-id/java-id.html.markdown new file mode 100644 index 00000000..a5455952 --- /dev/null +++ b/id-id/java-id.html.markdown @@ -0,0 +1,801 @@ +--- +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Madison Dickson", "http://github.com/mix3d"] + - ["Simon Morgan", "http://sjm.io/"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] + - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] + - ["Rachel Stiyer", "https://github.com/rstiyer"] +filename: LearnJava-id.java +translators: + - ["Ahmad Zafrullah", "https://github.com/23Pstars"] +lang: id-id +--- + +Java adalah bahasa pemrograman yang memiliki tujuan umum dan berorientasi kelas dan objek. +[Baca lebih lanjut.](http://docs.oracle.com/javase/tutorial/java/) + +```java +// Komentar satu baris diawali dengan // (dua garis miring) +/* +Ini adalah contoh komentar banyak-baris. +*/ +/** +Ini adalah contoh komentar JavaDoc. Digunakan untuk mendeskripsikan sebuah kelas, +atau beberapa sifat dari kelas tersebut. +*/ + +// Menyertakan kelas ArrayList dalam paket java.util +import java.util.ArrayList; +// Menyertakan semua kelas yang ada dalam paket java.security +import java.security.*; + +// Setiap dokumen .java sebuah kelas publik dengan nama yang sama dengan nama kelas. +public class BelajarJava { + + // Untuk menjalankan program java, program harus memiliki sebuah method utama (main) sebagai awalan. + public static void main (String[] args) { + + // System.out.println() digunakan untuk menampilkan satu baris teks. + System.out.println("Halo Dunia!"); + System.out.println( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // System.out.print() hanya menampilkan teks tanpa baris baru. + System.out.print("Halo "); + System.out.print("Dunia"); + + // System.out.printf() memudahkan dalam mengatur format penampilan. + System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159 + + /////////////////////////////////////// + // Variabel + /////////////////////////////////////// + + /* + * Deklarasi Variabel + */ + // Deklarasi variabel menggunakan format <tipe> <nama> + int nilai; + // Deklarasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <tipe> <nama2>, <tipe> <nama3> + int nilai1, nilai2, nilai3; + + /* + * Inisialisasi Variabel + */ + + // Inisialisasi sebuah variabel menggunakan <tipe> <nama> = <nilai> + int nilai = 1; + // Inisialisasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <nama2>, <nama3> = <nilai> + int nilai1, nilai2, nilai3; + nilai1 = nilai2 = nilai3 = 1; + + /* + * Tipe Variabel + */ + // Byte - 8 bit signed untuk bilangan bulat komplemen 2 + // (-128 <= byte <= 127) + byte nilaiByte = 100; + + // Short - 8 bit signed untuk bilangan bulat komplemen 2 + // (-32,768 <= short <= 32,767) + short nilaiShort = 10000; + + // Integer - 32 bit signed untuk bilangan bulat komplemen 2 + // (-2,147,483,648 <= int <= 2,147,483,647) + int nilaiInt = 1; + + // Long - 64 bit signed untuk bilangan bulat komplemen 2 + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long nilaiLong = 100000L; + // Karakter "L" pada akhir nilai menyatakan tipe Long; + // selainnya akan dianggap sebagai nilai bilangan bulat. + + // Catatan: Java tidak memiliki tipe unsigned. + + // Float - Presisi-satu 32-bit standar IEEE 754 untuk Floating Point + // 2^-149 <= float <= (2-2^-23) * 2^127 + float nilaiFloat = 234.5f; + // Karakter "f" atau "F" pada akhir nilai menyatakan tipe Float; + // selainnya akan dianggap sebagai nilai double. + + // Double - Presisi-dua 64-bit standar IEEE 754 untuk Floating Point + // 2^-1074 <= x <= (2-2^-52) * 2^1023 + double nilaiDouble = 123.4; + + // Boolean - true & false + boolean nilaiBoolean = true; + boolean nilaiBoolean = false; + + // Char - Sebuah karakter Unicode 16-bit + char nilaiChar = 'A'; + + // Variabel "final" tidak dapat di-set kembali nilainya pada objek lain, + final int WAKTU_SAYA_BEKERJA_TIAP_MINGGU = 9001; + // tapi dapat dilakukan inisialisasi diwaktu yang lain. + final double E; + E = 2.71828; + + + // BigInteger - Bilangan bulat yang memiliki presisi dinamis + // + // BigInteger adalah tipe data yang memungkinkan pembuat program untuk memanipulasi + // bilangan bulat lebih panjang dari 64-bit. Bilangan bulat tersebut tersimpan dalam + // bentuk kumpulan byte (array) dan dimanipulasi menggunakan fungsi yang sudah tersedia + // pada BigInteger + // + // BigInteger dapat diinisialisasi menggunakan kumpulan byte atau teks. + + BigInteger nilaiBigInteger = new BigInteger(kumpulanByte); + + + // BigDecimal - Bilangan signed desimal yang memiliki presisi dinamis + // + // Tipe BigDecimal memiliki dua bagian: sebuah bilangan bulat dengan nilai presisi + // dinamis tanpa skala dan sebuah bilangan bulat skala 32-bit. + + // BigDecimal memungkinkan pembuat program untuk memegang kontrol penuh + // terhadap batas desimal. BigDecimal baik digunakan untuk nilai tukar mata uang + // dimana sangat mementingkan presisi nilai desimal. + // + // BigDecimal dapat diinisialisasi dengan int, long, double, String, + // atau dengan melakukan inisialisasi nilai tanpa skala (BigInteger) + // dan nilai dengan skala (int). + + BigDecimal nilaiBigDecimal = new BigDecimal(nilaiBigInteger, nilaiInt); + + // Perlu diperhatikan konstruktor yang digunakan apakah float atau double + // karena dapat mengakibatkan ketidak-akurasian float/double yang akan digunakan + // dalam BigDecimal. Sebaiknya gunakan nilai String pada konstruktor + // jika membutuhkan nilai pasti. + + BigDecimal sepuluhSen = new BigDecimal("0.1"); + + + // Strings + String nilaiString1 = "Ini adalah contoh String!"; + + // Karakter \n berfungsi untuk membuat baris baru + String nilaiString2 = "Menampilkan baris baru?\nTidak masalah!"; + // Karakter \t berfungsi untuk membuat tab antar karakter + String nilaiString3 = "Ingin menambahkan sebuah tab?\tTidak masalah!"; + System.out.println(nilaiString1); + System.out.println(nilaiString2); + System.out.println(nilaiString3); + + // Larik (array) + // Ukuran array harus ditentukan ketika instansiasi + // Format berikut adalah beberapa cara deklarasi array + // <tipe data>[] <nama variabel> = new <tipe data>[<ukuran array>]; + // <tipe data> <nama variabel>[] = new <tipe data>[<ukuran array>]; + int[] barisAngka = new int[10]; + String[] barisString = new String[1]; + boolean barisBoolean[] = new boolean[100]; + + // Cara lain untuk mendeklarasikan dan menginisialisasi sebuah array + int[] y = {9000, 1000, 1337}; + String nama[] = {"Andi", "Budi", "Agus"}; + boolean bools[] = new boolean[] {true, false, false}; + + // Indeks sebuah array - Mengakses sebuah elemen + System.out.println("barisAngka @ 0: " + barisAngka[0]); + + // Array menggunakan indeks 0 yang tetap. + barisAngka[1] = 1; + System.out.println("barisAngka @ 1: " + barisAngka[1]); // => 1 + + // Lainnya yang perlu diketahui + // ArrayLists - Sama seperti array biasa, namum penggunaannya sudah ditentukan, + // dan ukurannya dapat berubah-ubah. + // LinkedLists - Implementasi dari doubly-linked list. Semua operasi yang digunakan + // hampir sama dengan operasi yang dimiliki oleh sebuah doubly-linked list. + // Maps - Sebuah kumpulan objek yang menyatakan hubungan antara kunci dan nilai. Map merupakan + // sebuah interface sehingga tidak dapat diinstansiasi. Jenis kunci dan nilai yang digunakan + // pada Map harus spesifik pada saat instansiasi ketika diimplementasikan pada sebuah kelas. + // Setiap kunci hanya memiliki sebuah nilai, dan hanya muncul sekali. + // HashMaps - Kelas ini menggunakan tabel-hash untuk mengimplementasikan interface Map. + // Hal ini memungkinkan waktu eksekusi ketika melakukan operasi dasar (mengakses + // dan menambahkan elemen) menjadi konstan, meskipun memiliki banyak set data. + + /////////////////////////////////////// + // Operator + /////////////////////////////////////// + System.out.println("\n->Operator"); + + int i1 = 1, i2 = 2; // Cara singkat untuk deklarasi banyak nilai + + // Kemudahan dalam artimatika + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int menghasilkan int juga) + System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5 + + // Modulus + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Operator Perbandingan + System.out.println("3 == 2? " + (3 == 2)); // => false + System.out.println("3 != 2? " + (3 != 2)); // => true + System.out.println("3 > 2? " + (3 > 2)); // => true + System.out.println("3 < 2? " + (3 < 2)); // => false + System.out.println("2 <= 2? " + (2 <= 2)); // => true + System.out.println("2 >= 2? " + (2 >= 2)); // => true + + // Operator Boolean + System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false + System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true + System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true + + // Operator Bitwise + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed/Arithmetic right shift + >>> Unsigned/Logical right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR + */ + + // Peningkatan + int i = 0; + System.out.println("\n->Pengurangan/Peningkatan"); + // Operator ++ dan -- masing-masing melakukan peningkatan dan penurunan 1 nilai. + // Jika diletakkan sebelum variabel, maka akan di tambah/kurang 1 sebelum dilakukan perintah lainnya; + // jika setelah variabel, maka akan ditambah/kurang 1 setelah dilakukan perintah lainnya; + System.out.println(i++); // i = 1, prints 0 (peningkatan setelahnya) + System.out.println(++i); // i = 2, prints 2 (peningkatan sebelumnya) + System.out.println(i--); // i = 1, prints 2 (pengurangan setelahnya) + System.out.println(--i); // i = 0, prints 0 (pengurangan sebelumnya) + + /////////////////////////////////////// + // Struktur Kontrol + /////////////////////////////////////// + System.out.println("\n->Struktur Kontrol"); + + // Perintah "if" hampir sama dengan bahasa C + int j = 10; + if (j == 10) { + System.out.println("Saya ditampilkan"); + } else if (j > 10) { + System.out.println("Saya tidak ditampilkan"); + } else { + System.out.println("Saya juga tidak ditampilkan"); + } + + // Perulangan "while" + int fooWhile = 0; + while(fooWhile < 100) { + System.out.println(fooWhile); + // Tingkatkan penghitung + // 100 kali iterasi, fooWhile 0,1,3,...,99 + fooWhile++; + } + System.out.println("Nilai fooWhile: " + fooWhile); + + // Perulangan "do...while" + int fooDoWhile = 0; + do { + System.out.println(fooDoWhile); + // Tingkatkan penghitung + // 99 kali iterasi, fooDoWhile 0->99 + fooDoWhile++; + } while(fooDoWhile < 100); + System.out.println("Nilai fooDoWhile: " + fooDoWhile); + + // Perulangan "for" + // Struktur perulangan "for" => for(<awal_pernyataan>; <kondisi>; <langkah/tahapan>) + for (int fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // 10 kali iterasi, foofor 0-9 + } + System.out.println("Nilai fooFor: " + fooFor); + + // Perulangan "for" bertingkat dengan label "exit" + outer: + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + if (i == 5 && j ==5) { + break outer; + // Menghentikan semua perulangan, tidak hanya perulangan bagian dalam saja + } + } + } + + // Perulangan "for each" + // Perulangan "for" juga dapat melakukan iterasi terhadap larik (array) dari objek + // yang mana mengimplementasikan interface Ieterable. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // Struktur perulangan "for each" => for (<objek> : <iterable>) + // dibaca: setiap elemen dalam iterable + // catatan: tipe objek harus sama dengan tipe iterable + + for (int bar : fooList) { + System.out.println(bar); + // Melakukan interasi sebanyak 9 kali dan menampilkan 1-9 tiap baris + } + + // "switch case" + // "switch" dapat digunakan pada byte, short, char, dan tipe data bilangan bulat (int). + // "switch" juga dapat digunakan pada tipe "enum" (dijelaskan nanti), kelas String, + // dan beberapa kelas khusus yang mengandung tipe data primitif: + // Character, Byte, Short, dan Integer. + int bulan = 3; + String bulanString; + switch (bulan) { + case 1: bulanString = "Januari"; + break; + case 2: bulanString = "Februari"; + break; + case 3: bulanString = "Maret"; + break; + default: bulanString = "Bulan lainnya"; + break; + } + System.out.println("Hasil switch case: " + bulanString); + + // Mulai dari Java 7 keatas, "switch" memiliki format: + String jawabanSaya = "mungkin"; + switch(jawabanSaya) { + case "ya": + System.out.println("Anda menjawab ya."); + break; + case "tidak": + System.out.println("Anda menjawab tidak."); + break; + case "mungkin": + System.out.println("Anda menjawab mungkin."); + break; + default: + System.out.println("Anda menjawab " + jawabanSaya); + break; + } + + // Pengkondisian dengan cara singkat + // Karakter '?' dapat digunakan untuk penilaian atau logika secara cepat antara dua pernyataan. + // Dibaca "Jika (pernyataan) adalah benar, gunakan <nilai pertama>, sisanya gunakan <nilai kedua> + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Menampilkan A, karena pernyataannya benar + + + //////////////////////////////////////// + // Konversi Data dan Tipe Data (Typecasting) + //////////////////////////////////////// + + // Konversi Data + + // Konversi String ke Integer + Integer.parseInt("123"); // menghasilkan nilai versi Integer dari "123" + + // Konversi Integer ke String + Integer.toString(123); // menghasilkan nilai versi String dari 123 + + // Untuk konversi lainnya silakan coba kelas berikut: + // Double + // Long + // String + + // Typecasting + // Objek dalam Java juga dapat dikonversi, banyak penjelasan dan aturan + // dengan beberapa konsep sederhana. Silakan cek di alamat berikut: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Kelas dan Fungsi + /////////////////////////////////////// + + System.out.println("\n->Kelas & Fungsi"); + + // (penjelasan mengenai kelas "Sepeda" ada dibawah) + + // Gunakan "new" untuk melakukan instansiasi pada kelas + Sepeda laju = new Sepeda(); + + // Memanggil method objek + laju.tambahKecepatan(3); // Dapat juga digunakan "setter" dan "getter" method + laju.setIrama(100); + + // Method "toString()" menghasilkan representasi string dari objek. + System.out.println("informasi jalur: " + laju.toString()); + + // Dua Pasang Inisialisasi + // Bahasa Java tidak memiliki sintaks untuk membuat koleksi dari "static" sekaligus + // dengan mudah, kecuali dengan cara berikut: + + private static final Set<String> NEGARA = new HashSet<String>(); + static { + validCodes.add("INDONESIA"); + validCodes.add("MALAYSIA"); + validCodes.add("SINGAPURA"); + } + + // Terdapat cara yang baik untuk menulis skrip dengan mudah, + // dengan menggunakan Dua-Kurung Kurawal Inisialisasi (Double Brace Initialization) + + private static final Set<String> NEGARA = new HashSet<String>() {{ + add("INDONESIA"); + add("MALAYSIA"); + add("SINGAPURA"); + }} + + // Kurung kurawal yang pertama membuat sebuah AnonymousInnerClas + // dan kurung kurawal yang kedua mendeklarasikan instance dari blok + // inisialisasi. Blok ini kemudian dipanggil ketika InnerClass dibentuk. + // Cara ini tidak hanya berfungsi pada koleksi data, juga dapat digunakan + // pada semua kelas bukan-"final". + + } // Akhir dari method utama +} // Akhir dari kelas BelajarJava + + +// Kelas bukan-"public" lainnya dapat dimasukkan kedalam satu dokumen .java, +// namun tidak dianjurkan, sebaiknya memisahkan menjadi beberapa dokumen terpisah. + +// Sintaks pendeklarasian kelas: +//<public/private/protected> class <nama kelas> { +// // isi data, konstruktor, dan fungsi. +// // dalam Java, fungsi biasa disebut juga "method" +// } + +class Sepeda { + + // Variabel dari kelas Sepeda + public int irama; // Public: dapat diakses dari manapun + private int kecepatan; // Private: hanya dapat diakses dari dalam kelas + protected int rodaGigi; // Protected: dapat diakses dari dalam kelas dan turunan kelas + String nama; // Default: hanya dapat diakses kelas yang berada dalam paket yang sama + + static String namaKelas; // Variabel "static" + + // Blok Static + // Java tidak memiliki implementasi untuk konstruktor "static", namun + // memiliki blok status yang dapat digunakan untuk inisialisasi variabel + // dalam kelas (variabel "static"). + // Blok ini akan dipanggil secara otomatis ketika kelas dijalankan. + static { + namaKelas = "Sepeda"; + } + + // Konstruktor adalah salah satu cara untuk membuat kelas + // Ini adalah bagian konstruktor + public Sepeda() { + // Dapat juga dipanggil konstruktor lainnya: + // this(1, 50, 5, "Bontrager"); + rodaGigi = 1; + irama = 50; + kecepatan = 5; + nama = "Bontrager"; + } + + // Ini adalah bagian konstruktor yang menggunakan argumen (parameter) + public Sepeda(int iramaAwal, int kecepatanAwal, int rodaGigiAwal, + String nama) { + this.rodaGigi = rodaGigiAwal; + this.irama = iramaAwal; + this.kecepatan = kecepatanAwal; + this.nama = nama; + } + + // Sintaks untuk method: + // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>) + + // Kelas Java terkadang mengimplementasikan "getters" dan "setters" untuk data. + + // Sintaks untuk deklarasi method: + // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>) + public int getIrama() { + return irama; + } + + // Tipe "void" tidak memiliki kembalian (return) nilai + public void setIrama(int nilaiBaru) { + irama = nilaiBaru; + } + + public void setRodaGigi(int nilaiBaru) { + rodaGigi = nilaiBaru; + } + + public void tambahKecepatan(int nilaiTambahan) { + kecepatan += nilaiTambahan; + } + + public void kurangiKecepatan(int nilaiPengurangan) { + kecepatan -= nilaiPengurangan; + } + + public void setNama(String namaBaru) { + nama = namaBaru; + } + + public String getNama() { + return nama; + } + + // Method untuk menampilkan nilai dari tiap atribut yang dimiliki objek Sepeda. + @Override // Diturunkan dari kelas "Object" (Pustaka Java). + public String toString() { + return "roda gigi: " + rodaGigi + " irama: " + irama + " kecepatan: " + kecepatan + + " nama: " + nama; + } +} // akhir dari kelas Sepeda + +// PennyFarthing adalah kelas turunan dari Sepeda +class PennyFarthing extends Sepeda { + // (Penny Farthings adalah sepeda dengan roda depan yang besar, + // dan tidak memiliki roda gigi.) + // (Penny Farthings are those bicycles with the big front wheel. + // They have no gears.) + + public PennyFarthing(int startCadence, int startSpeed) { + // Call the parent constructor with super + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // You should mark a method you're overriding with an @annotation. + // To learn more about what annotations are and their purpose check this + // out: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setRodaGigi(int rodaGigi) { + roda rodaGigi = 0; + } +} + +// Interfaces +// Sintaks untuk deklarasi Interface +// <level akses> interface <nama interface> extends <interface induk> { +// // Konstan +// // Deklarasi method +// } + +// Contoh - Makanan: +public interface dapatDimakan { + public void makan(); // Setiap kelas yang menggunakan interface "dapatDimakan", + // harus mengimplementasikan method "makan". +} + +public interface dapatDicerna { + public void cerna(); +} + + +// Membuat kelas dengan mengimplementasikan dua interface dalam satu waktu. +public class Buah implements dapatDimakan, dapatDicerna { + + @Override + public void makan() { + // ... + } + + @Override + public void cerna() { + // ... + } +} + +// Dalam Java, kelas hanya dapat diturunkan sekali, tapi dapat mengimplementasikan +// banyak interface. Contoh: +public class ContohKelas extends ContohKelasInduk implements InterfaceSatu, + InterfaceDua { + + @Override + public void MethodInterfaceSatu() { + } + + @Override + public void MethodInterfaceDua() { + } + +} + +// Kelas Abstrak (Abstract) +// Sintaks untuk deklarasi kelas abstrak +// Abstract Class declaration syntax +// <level akses> abstract <nama kelas abstrak> extends <induk kelas abstrak> { +// // Konstan dan variabel +// // Deklarasi method + +// Menjadikan kelas sebagai abstrak adalah memungkinkan kelas berisi method abstrak +// yang harus didefinisikan pada kelas turunannya. Mirip dengan Interface, kelas abstrak +// tidak dapat dilakukan instansiasi, namun harus diturunkan pada kelas lain dan method abstrak +// harus didefinisikan. Perbedaannya dengan Interface ialah kelas abstrak dapat berisi method +// kongkrit dan method abstrak. Pada Interface method tidak dapat memiliki isi, artinya hanya +// method statis, dan variabel langsung ditentukan menjadi final, tidak seperti kelas abstrak. +// Kelas abstrak juga dapat memiliki method "main". + +public abstract class Hewan +{ + public abstract void bersuara(); + + // Method biasa dapat memiliki isi + public void makan() + { + System.out.println("Saya adalah hewan dan Saya makan."); + // Catatan: Kita dapat mengakses variabel private yang ada disini. + umur = 30; + } + + // Tidak perlu dilakukan inisialisasi, berbeda dengan Interface + // sebuah variabel adalah final dan harus dilakukan inisialisasi. + protected int umur; + + public void tampilkanUmur() + { + System.out.println(umur); + } + + // Kelas abstrak dapat memiliki fungsi utama (main). + public static void main(String[] args) + { + System.out.println("Saya adalah kelas abstrak!"); + } +} + +class Kucing extends Hewan +{ + // Catatan: kelas ini harus melakukan override method abstrak + // yang ada pada kelas abstrak (induk). + @Override + public void bersuara() + { + System.out.println("Moe"); + // umur = 30; ==> ERROR! umur merupakan variabel private pada abstrak Hewan + } + + // CATATAN: Akan muncul error jika menggunakan + // keterangan @Override pada method utama (main), + // Java tidak mengizinkan hal tersebut. + // Kejadian ini sering disebut sebagai METHOD HIDING. + // Pertanyaan-jawaban yang menarik dapat dilihat: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Kucing moe = new Kucing(); + noe.bersuara(); + moe.makan(); + moe.tampilkanUmur(); + } +} + +// Kelas Final + +// Sintaks untuk deklarasi kelas Final +// <level akses> final <nama kelas final> { +// // Konstann dan variabel +// // Deklarasi method +// } + +// Kelas Final merupakan kelas yang tidak dapat diturunkan sehingga menjadikan +// method tersebut turunan method terakhir. Disisi lain, kelas final merupakan +// lawan dari kelas abstrak karena kelas abstrak dapat diturunkan lagi, sedangkan +// kelas final tidak dapat diturunkan lagi. +public final class Serigala extends Hewan +{ + // Catatan: method abstrak harus di-override pada kelas abstrak. + @Override + public void bersuara() + { + System.out.println("Auuww"); + } +} + +// Method Final +public abstract class Mamalia() +{ + // Sintaks untuk method final: + // <level akses> final <tipe kembalian> <nama fungsi>(<args>) + + // Method final, seperti kelas final tidak dapat di-override oleh kelas turunan, + // sehingga menjadikannya implementasi terakhir dari method. + public final boolean apakahBerdarahDingin() + { + return true; + } +} + + +// Tipe Enum +// +// Tipe Enum merupakan tipe data spesial yang memungkinkan sebuah nilai dijadikan +// konstan awal (predefined). Variabel setidaknya harus memiliki nilai yang sama +// dengan salah satu dari enum-enum yang telah ditentukan. Karena nilainya merupakan +// konstan, untuk itu penamaannya menggunakan huruf kapital (uppercase). Dalam Java, +// Enum didefinisikan dengan kata kunci "enum". Contohnya nama-nama hari dalam semunggu: + +public enum Hari { + SENIN, SELASA, RABU, KAMIS, + JUMAT, SABTU, MUNGGU +} + +// Cara menggunakan Enum: +public class CobaEnum { + + // Variabel Enum + Hari hari; + + // Konstruktor + public CobaEnum(Hari hari) { + this.hari = hari; + } + + public void tampilkanKeterangan() { + switch (day) { + case SENIN: + System.out.println("Senin adalah hari yang menyebalkan."); + break; + + case JUMAT: + System.out.println("Jumat adalah hari yang singkat."); + break; + + case SABTU: + case MINGGU: + System.out.println("Akhir pekan adalah hari yang menyenangkan."); + break; + + default: + System.out.println("Hari kerja yang biasa saja."); + break; + } + } + + public static void main(String[] args) { + CobaEnum hariPertama = new CobaEnum(Hari.SENIN); + hariPertama.tampilkanKeterangan(); // Senin adalah hari yang menyebalkan. + CobaEnum hariKetiga = new CobaEnum(Hari.RABU); + hariPertama.tampilkanKeterangan(); // Hari kerja yang biasa saja. + } +} + +// Tipe enum memiliki banyak kegunaan selain yang dicontohkan diatas. +// Tipe enum dapat memiliki isi seperti method dan variabel. +// Penjelasan lebih detail di https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html + +``` + +## Referensi Lainnya + +Link-link berikut hanya menyediakan pemahaman lebih lanjut mengenai topik diatas. +Tip, trik, dan contoh lainnya dapat melakukan pencarian melalui Google atau mesin pencari yang lain. + +**Panduan resmi Oracle** + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html) + +**Tutorial dan Praktik Online** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Buku**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Thinking in Java](http://www.mindview.net/Books/TIJ/) + +* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) + +* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300) |