summaryrefslogtreecommitdiffhomepage
path: root/id-id/java-id.html.markdown
diff options
context:
space:
mode:
authorhyphz <drmoose94@gmail.com>2017-07-18 17:56:42 +0100
committerhyphz <drmoose94@gmail.com>2017-07-18 17:56:42 +0100
commit5ab5cb9800822d607be2c6ac943377811db98158 (patch)
tree3c804707822744c20da1de54ff60fc8c3197781b /id-id/java-id.html.markdown
parent62102d02992f83b3a1fb745a39f36332dd4435b7 (diff)
parent6e7c5c793327f4a63b13e555894597915ca91fda (diff)
Merge remote-tracking branch 'adambard/master'
Diffstat (limited to 'id-id/java-id.html.markdown')
-rw-r--r--id-id/java-id.html.markdown801
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)