Belajar dasar-dasar bahasa pemrograman Java

Belajar Coding Interaktif Pemrograman Java

Tutorial belajar Java dasar yang interaktif dan sistematis di CodePolitan, belajar java dasar, belajar pemrograman dasar

Array (dikenal juga dengan istilah larik) adalah tipe variabel yang dapat menyimpan lebih dari satu nilai. Misalnya kita punya himpunan nama hewan yang ingin diproses di dalam program, maka kita dapat menyimpan ke dalam variabel seperti ini:
```
String hewan1 = "ayam";
String hewan2 = "sapi";
String hewan3 = "kuda";
```
Permasalahannya sekarang adalah bagaimana bila kita hendak melakukan pencarian nama hewan diantara daftar nama tersebut? Selain itu bagaimana bila kita ingin mencetak semua daftar nama yang boleh jadi tidak hanya ada 3-4 buah, tapi ratusan? Penggunaan himpunan variabel dalam jumlah banyak akan menyulitkan proses data tersebut. Disinilah peran Array.

Array dibuat seperti berikut:
```
tipedata[] namavar = new tipedata[jumlahdata];
```
Atau kita dapat langsung menginisiasi nilai arraynya seperti ini:
```
tipedata[] namavar = {data1, data2, ..};
```
Sebagai contoh, bila data nama hewan di atas disimpan dalam bentuk array, maka sintaks penulisannya seperti ini:
```
String[] hewan = new String[3];
hewan[0] = "ayam";
hewan[1] = "sapi";
hewan[2] = "kuda";
```
atau seperti ini:
```
String[] hewan = {"ayam", "sapi", "kuda"};

```
Kita dapat mengisikan atau memanggil nilai array dengan menggunakan nomor indeksnya.
```
hewan[0] = "kambing";
System.out.println(hewan[0]);
```
Indeks adalah nomor posisi nilai di dalam array. Nomor indeks dimulai dari 0.

Array

Matriks atau dikenal juga dengan array multidimensi adalah array yang memiliki deret data dua dimensi atau lebih. Untuk mendefinisikan matriks dua dimensi, Kamu dapat membuat seperti berikut:
```
tipedata[][] namavar = new tipedata[jumlahKolom][jumlahBaris];
```
Misalnya kita membuat array integer dua dimensi dengan dua kolom dan dua baris seperti berikut:
```
int[][] matriks2Dimensi = new int[2][2];
matriks2Dimensi[0][0] = 1;
matriks2Dimensi[0][1] = 2;
matriks2Dimensi[1][0] = 3;
matriks2Dimensi[1][1] = 4;
```
Sama halnya bila Kamu hendak membuat array tiga dimensi, cukup definisikan ukuran array per dimensinya.
```
int[][][] matriks3Dimensi = new int[2][2][2];
```

pemrograman dasar java, matriks dan penjumlahan matriks

Array Multidimensi/Matriks

Kita dapat menampilkan isi dari sebuah array dengan menggunakan method `toString()` dari library `Arrays`.
```
String[] sayuran = {"kangkung", "bayam", "brokoli"};
System.out.println(Arrays.toString(sayuran));
```
Method `Arrays.toString()` akan mengembalikan isi sebuah array dalam bentuk string. Untuk dapat menggunakan method ini kita harus mengimpor terlebih dahulu library Arrays di bagian atas file.
```
import java.util.Arrays;
```

Selain itu kita juga dapat menampilkan isi array multidimensi dengan menggunakan method `Arrays.deepToString()`.

Kedua method ini akan sangat berguna dalam proses debugging, bila kita ingin mengetahui apa saja isi sebuah array dengan cepat.

Mencetak Array

Hampir setiap operasi array dapat kita lakukang dengan memanfaatkan perulangan for. Selain itu kita juga akan membutuhkan beberapa operator seperti relasional dan *assignment*.

Sekarang kita akan mencoba membuat beberapa operasi sederhana terhadap *array* yang berisi angka. Beberapa operasi yang akan kita lakukan adalah operasi *max*, *min*, *sum*, dan *average*.

Operasi Array

Setiap variabel array harus berisi nilai dengan tipe yang sama. Misalkan array integer, maka semua nilai di dalam variabel array tersebut harus bertipe integer. 
```
int[] angka = {1, 2, 3, 4, 5};
```
Bila kita memasukkan nilai bertipe lain ke dalam variabel bertipe integer di atas:
```
int[] angka = {"satu", 2, 3, 4, 5};
```
maka compiler akan menampilkan pesan kesalahan `incompatible types`. 

Selain menggunakan tipe data standar yang sudah kita bahas di awal tutorial, array juga dapat dibuat dari objek yang kita buat sendiri. Hal ini akan sering digunakan pada saat memprogram karena adakalanya kita perlu menyimpan koleksi data dalam bentuk yang tidak umum.

Pada materi Class dan Objek mendatang akan dibahas lebih dalam mengenai class dan objek di Java. Adapun kali ini kita akan melihat bagaimana sebuah objek dapat disimpan di dalam array objek.

Variasi Array

Sebuah *class* terdiri dari beberapa bagian berikut:

* atribut, variabel yang menjadi milik *class* tersebut dengan tipe data tertentu dan tingkat akses tertentu
* konstruktor, *method* yang akan selalu dipanggil saat kita membuat objek (instansiasi) dari *class* tersebut
* *method*, fungsi yang dimiliki oleh *class* dan akan melakukan suatu operasi bila dipanggil

Kamu dapat menggunakan suatu *class* dengan melakukan apa yang disebut dengan *instantiation* atau instansiasi. Sebuah *class* dapat digunakan setelah berbentuk objek. Misal ketika kamu ingin melakukan operasi terhadap *file* XML atau JSON, kamu harus membuat objek dari clas *JSONParser* untuk mulai melakukan operasi terhadap *file* JSON tersebut.

Sederhananya secara default bila kita ingin menggunakan suatu *method* dari suatu *class*, kita harus membuat objeknya terlebih dahulu.

```
// instansiasi objek
NamaClass namaobjek = new NamaClass(params);

// menggunakan method objek
namaobjek.namaMethod();
```

Instansiasi Class

Method constructor adalah *method* yang akan selalu dipanggil setiap kali kita membuat objek dari *class* tersebut. Nama method constructor sama dengan nama classnya tanpa mendefinisikan tipe data method.

```
clas Hello {
      void Hello(String name){
          // kode
      }
}
```

Bila method constructor memiliki parameter seperti contoh di atas, maka kita harus mengisi parameter tersebut saat instansiasi objek. Bila tidak, compiler akan menampilkan pesan error.
```
Hello hello = new Hello("Ridwan");
```
Bila constructor membutuhkan dua buah parameter, maka kita juga harus mengisi kedua parameter tersebut.

Constructor

Sesuai namanya, inner class adalah *class* yang didefinisikan berada di dalam *class* lain. Di Java, untuk membuat *inner class* biasanya menggunakan *keyword* **static** di depan nama *inner class*.

Hanya saja *inner class* hanya dapat diakses dari dalam *class* pemiliknya. *Class* lain tidak dapat menggunakan *inner class* yang dimiliki suatu *class*.


Inner Class

Inheritance secara bahasa artinya pewarisan. Dalam pemrograman berorientasi objek, inheritance adalah pewarisan suatu class kepada class yang lain, atau suatu *class* menjadi landasan bagi *class* lain. Dengan menggunakan *inheritance* kamu cukup sekali mendefinisikan suatu *method* atau property dan *method* atau property tersebut dapat digunakan di *class* lain yang mewarisi *class* tersebut.
```
class Hello {
      String message = "Hello world";

      void getMessage() {
          return message;
      }
}

class HelloCoder extends Hello {
      // class ini otomatis memiliki 
      // method getMessage() dan property message
}
```
Walaupun tanpa mendefinisikan *method* `getMessage()`, kamu dapat memanggil *method* tersebut dari *class* turunan ketika dibuat objeknya. Untuk melakukan *inheritance* kamu harus menggunakan *keyword* **extends** diikuti nama *class* yang ingin diwarisi.

Selain itu kamu pun dapat menimpa proses yang ada di dalam *constructor* atau suatu *method* dikenal dengan istilah *method overriding*.
```
class Hello {
      String message = "Hello world";

      void getMessage() {
          return message;
      }
}

class HelloCoder extends Hello {
      // override method
      void getMessage() {
          message = "Hello Coders!";
          return message;
      }
}
```
Pada contoh kode di atas, bila method `getMessage()` dipanggil dari objek class HelloCoder, maka nilai yang dikembalikan adalah nilai dari method `getMessage()` yang dimiliki HelloCoder, bukan lagi dari method induknya.

Class Inheritance

Method adalah satu blok kode yang direferensikan dengan sebuah nama yang dapat dipanggil untuk dijalankan.
```
String getMessage()
{
      String message = "Hello world";
      return message;
}
```
Pada contoh di atas, kita membuat sebuah method yang berisi dua buah baris kode. Kedua baris kode tersebut akan dijalankan bilamana nama method tersebut dipanggil.
```
System.out.println( getMessage() );
```

Method dapat dipanggil dimana saja di dalam classnya, kecuali di dalam method static seperti method `main()`. Kita harus membuat objeknya terlebih dahulu dari class tersebut dengan menggunakan statemen `new`, baru kita dapat memanggil methodnya.
```
class ClassSaya
{
	String getURL() {
		return "https://www.codepolitan.com";
	}

	void printURL() {
		System.out.println( getURL() );
	}

	public static void main (String[] args) {
		ClassSaya myclass = new ClassSaya();
		myclass.printURL();
	}
}
```

Pada contoh di atas, kita mempunyai dua buah method bernama `getURL()` dan `printURL()`. Method `getURL()` isinya kode untuk mengembalikan string url. Method `printURL()` isinya mencetak string hasil pemanggilan method `getURL()`.

Seperti kita lihat, method `getURL()` dapat dipanggil langsung di dalam method `printURL()`. tapi method `printURL()` tidak dapat langsung dipanggil di dalam method `main()`. Alasannya karena `main()` adalah method *static*. Sehingga kita harus menginstansiasi objeknya terlebih dahulu baru method tersebut dapat dipanggil melalui objeknya.
```
ClassSaya myclass = new ClassSaya();
myclass.printURL();
```
Lebih dalam pembahasan tentang Class dan Object dapat Kamu temukan di bagian selanjutnya.

Method di Java

Ada dua jenis *method* yang dapat kamu buat di Java, yaitu *static* dan *non-static*. Pada tutorial sebelumnya kita sudah belajar membuat method yang pada dasarnya adalah method non-static. Adapun untuk membuat method static adalah dengan menambahkan kata kunci *static* sebelum menuliskan tipe data dan nama dari methodnya.
```
static String getURL(){
	return "https://www.codepolitan.com";
}
```

*Static method* dapat langsung dipanggil dari manapun di dalam class tersebut tanpa harus membuat objeknya terlebih dahulu, termasuk dari dalam method *static* seperti method `main()`.

Static Method

Baik *static* ataupun *non-static* kita dapat mengembalikan suatu nilai dari dalam *method*. Untuk mengembalikan nilai ke luar method, kita gunakan statemen `return`.

Ada beberapa tipe data yang dapat kamu kembalikan, yaitu:
* **standard type**, *method* mengembalikan nilai dari tipe *standard* Java
* **objek**, *method* mengembalikan nilai berupa objek yang sesuai dengan *class* tertentu
* **array**, *method* mengembalikan nilai berupa *array* dengan tipe data tertentu

Pada saat mendeklarasikan method, kita menyertakan tipe data sebelum nama methodnya. Tipe data *method* yang dideklarasikan harus sama dengan data yang akan dikembalikan dari dalam *method* tersebut.

Return Value Method

Adakalanya kita hanya ingin membundel kode program di dalam sebuah method dan menjalankannya tanpa ingin mengembalikan nilai apapun. Untuk itu Kamu membutuhkan void method.

Void method sederhananya adalah method bertipe void dan di dalamnya tidak mengembalikan nilai apapun.
```
static void myMethod(){
      System.out.println("Hello from void method!");
}
```

Void Method

Lazimnya suatu bahasa pemrograman pasti mendukung sebuah *function* untuk dapat menerima *parameter*. Di Java, *method* dapat menerima sejumlah parameter dengan tipe data tertentu. 
```
String getMessage(String name){
      return "Hello " + name + "!";
}
```
Kemudian saat dipanggil dari bagian kode lain, kamu cukup melewatkan nilai sesuai dengan posisi parameter dan juga tipe data yang tepat yang telah kamu tentukan di pendefinisian *method*.
```
getMessage("Toni");
```
Bila kamu salah mengisi parameter, misalnya tipe data dari nilai yang dimasukkan tidak sama, maka akan muncul pesan error *incompatible types*.

Method Parameter

Di Java kamu dapat melakukan operasi aritmatika dasar seperti kali, bagi, tambah, kurang. Beberapa operator aritmatika tersebut antara lain:

* `+` untuk penjumlahan
* `*` untuk pengalian
* `-` untuk pengurangan
* `/` untuk pembagian
* `%` untuk modulus (sisa bagi)
* `++` untuk menaikkan nilai sebanyak satu
* `--` untuk menurunkan nilai sebanyak satu

Jika dua buah variabel berisi angka, maka operator aritmatika dapat diterapkan. Sekarang mari kita coba buat kode yang menggunakan operator aritmatika.

pemrograman dasar java, operator arimetika, operator matematika

Operator Aritmatika

Operator relasional atau perbandingan digunakan untuk membandingkan dua buah nilai atau variabel dan akan menghasilkan **true** dan **false**.

Operator relasional yang harus kamu ingat antara lain:

* `==` sama dengan (tanda `=` digunakan untuk mengisikan nilai pada variabel)
* `!=` tidak sama dengan
* `>` lebih dari
* `<` kurang dari
* `>=` lebih dari sama dengan
* `<=` kurang dari sama dengan

Bila Kamu sudah pernah mempelajari operator perbandingan di matematika, Kamu sudah tidak akan asing lagi dengan operator di atas.

Operator Relasional

Operator logika membandingkan dua pernyataan kondisi. Penggunaannya biasa digabungkan dengan operator relasional yang sudah dibahas sebelumnya. Fungsinya untuk membentuk paduan kondisi yang akan membuat sebuah aturan yang cukup kompleks.

Operator logika yang harus kamu ingat antara lain:

* `&&` artinya **dan**, dimana kondisi bernilai benar atau *true* hanya jika kedua operand bernilai **true**. Bila salah satu atau kedua operand bernilai **false**, maka nilai kondisi menjadi **false**
* `||` artinya **atau**, dimana kondisi bernilai benar atau *true* jika salah satu dari kedua operand bernilai **true**. Bila kedua operand bernilai **false**, maka kondisi akan bernilai **false**
* `!` artinya **negaSI**, dimana nilai variabel akan dibalik menjadi lawannya, misal **!true** berarti **false** dan **!false** berarti **true**

Bila kamu terbiasa dengan logika matematika, hal ini bukan hal yang sulit.

Operator Logika

Operator *bitwise* digunakan untuk menangani operasi bit pada suatu bilangan dalam representasi biner. Operator *bitwise* yang harus kamu ingat antara lain:

* `&` melakukan operasi AND terhadap dua bilangan biner
* `|` melakukan operasi OR terhadap dua bilangan biner
* `^` melakukan operasi XOR terhadap dua bilangan biner
* `~` melakukan operasi negasi terhadap bilangan biner
* `>> n` melakukan operasi penggeseran bit ke kanan terhadap bilangan biner sebanyak *n* bit
* `<< n` melakukan operasi penggeseran bit ke kiri terhadap bilangan biner sebanyak *n* bit

Misalkan bilangan x = 60 yang dalam biner adalah 0011 1100, dan y = 13 yang dalam biner adalah 0000 1101, maka:

#### x & y
```
0011 1100
0000 1101
---------
0000 1100
```

#### x | y
```
0011 1100
0000 1101
---------
0011 1101
```

#### x ^ y
```
0011 1100
0000 1101
---------
0011 0001
```

#### ~x
```
0011 1100
---------
1100 0011
```

#### x >> 2
```
0011 1100
---------
0000 1111
```

#### x << 2
```
0011 1100
---------
1111 0000
```

Operator Bitwise

Untuk memeriksa apakah suatu objek merupakan hasil instansiasi dari suatu *class*, kamu dapat menggunakan **instanceof**. 
```
namaObjek instanceof NamaClass;
```
Kondisi akan menghasilkan nilai **true** bila `namaObjek` adalah benar hasil instansiasi dari class `namaClass`, dan menghasilkan nilai **false** bila `namaObjek` bukan hasil instansiasi dari class `namaClass`. 

Operator ini berguna bila suatu saat kamu ingin memeriksa suatu objek sebelum melakukan operasi selanjutnya.

Operator Instanceof

Operator `+` tidak hanya digunakan untuk menjumlahkan bilangan, tapi juga digunakan untuk menggabungkan *string*, atau dikenal dengan istilah konkatenansi. Kedua tipe data variabel yang hendak digabung harus bertipe *string*.


pemrograman dasar java, konkatenansi penggabungan string

Operator Konkatenansi

Operator *assignment* digunakan untuk mengisikan nilai pada variabel. Operator assignment yang sudah kita gunakan pada bagian sebelumnya adalah `=`. Selain itu ada beberapa operator assignment lain yang dapat kita gunakan, diantaranya:
* `+=` melakukan operasi penambahan variabel terhadap variabel itu sendiri
* `-=` melakukan operasi pengurangan variabel terhadap variabel itu sendiri
* `*=` melakukan operasi perkalian variabel terhadap variabel itu sendiri
* `/=` melakukan operasi pembagian variabel terhadap variabel itu sendiri
* `%=` melakukan operasi modulus variabel terhadap variabel itu sendiri

Sebagai contoh, kode berikut:
```
x = x + 1;
y = y - x;
z = z * y;
```
dapat ditulis lebih sederhana menjadi:
```
x += 1;
y -= x;
z *= y;
```

Operator Penugasan (Assignment)

Seringkali kita harus melakukan suatu operasi hanya pada kondisi tertentu saja. Artinya kita mengecek terlebih dahulu sebuah kondisi, yang apabila kondisi tersebut terpenuhi (atau bernilai true), maka kita lakukan serangkaian operasi.

Statemen **if** digunakan untuk mengecek kondisi dan bila kondisi bernilai true, maka program tertentu akan dijalankan. Statemen if memerlukan sebuah kondisi yang dibangun dengan menggunakan operator logika dan operator relasional. Penulisan sintaksnya adalah:
```
if (kondisi){
	// blok kode
}
```

Adakalanya kita harus mengeksekusi satu blok kode program saat suatu kondisi terpenuhi, dan mengeksekusi blok kode program lain yang berbeda bila kondisi tidak terpenuhi. Untuk itu kita gunakan statemen if..else.
```
if (kondisi){
	// blok kode bila kondisi true
} else {
	// blok kode bila kondisi false
}
```

Statemen If

Adakalanya kita harus mengecek beberapa kondisi dan hanya menjalankan kode dari salahsatu kondisi yang terpenuhi saja. Untuk itu kita dapat menggunakan statemen if..else if..else dst.
```
if(kondisi a){
   // kode bila kondisi a terpenuhi
} else if(kondisi b){
   // kode bila kondisi b terpenuhi
..
..
} else if(kondisi n) {
   // kode bila kondisi n terpenuhi
} else {
   // kode bila semua kondisi tidak terpenuhi
}
```

Statemen If Else If

Kita dapat mendeklarasikan statemen if di dalam statemen if lainnya untuk pengecekan bersarang.

Bila kondisi pertama terpenuhi, maka kondisi di dalamnya akan diperiksa dan bila kondisi di dalam kondisi pertama terpenuhi, maka kode akan dieksekusi.

```
if(kondisi a) {
  if(kondisi b) {
    // jalankan kode
  }
}
```

Statemen If Bersarang

Cara lain untuk membangun kondisi yang cukup banyak yaitu dengan menggunakan switch. Di dalamnya terdapat statemen **switch**, **case**, dan **default**. Statemen switch digunakan untuk menjalankan satu diantara banyak blok kode berdasarkan kecocokan nilai yang dievaluasi.

```
switch(variabel){
   case a:
      // blok kode A
      break;
   case b:
      // blok kode B
      break;
   ...
   default:
      // blok kode default
}
```

Pada statemen switch, nilai variabel akan dievaluasi kecocokannya untuk setiap case. Bila ditemukan kecocokan pada salah satu case, maka blok kode pada case tersebut akan dijalankan. Umumnya blok kode pada setiap case diakhiri dengan perintah break; agar program langsung keluar dari blok statemen switch dan tidak perlu lagi mengecek sisa case di bawahnya.

Apabila tidak ada case yang cocok dengan nilai variabel, maka blok kode pada bagian default yang akan dijalankan.

Statemen Switch

Kamu dapat menulis statemen if..else dengan lebih sederhana menggunakan operator ternary. Dengan operator ternary, Kamu dapat membuat sebuah kondisi hanya dengan satu baris saja.
```
(kondisi) ? //nilai bila kondisi true : //nilai bila kondisi false;
```
Sebagai contoh, statemen if..else berikut:
```
if(nilai > skbm) {
    status = "lulus";
} else {
    status = "tidak lulus";
}
```
dapat ditulis lebih sederhana menjadi:
```
status = (nilai > skbm) ? "lulus" : "tidak lulus";
```
Bila kondisi bernilai true, maka kode setelah tanda tanya (?) yang akan dikembalikan, dan bila kondisi bernilai false, kode setelah tanda titik dua (:) yang akan dikembalikan.

Operator Ternary

Statemen perulangan while akan menjalankan blok kode berulang-ulang selama kondisi masih bernilai true.
```
while (kondisi) {
    // kode yang akan dijalankan berulang
}
```
Sebagai contoh kode berikut:
```
int x = 1;
while(x <= 5)
{
    System.out.println(x);
    x++;
}
```
Pada kode di atas, program akan mencetak nomor 1 sampai dengan 5. Statemen while akan mengecek kondisi, yang apabila nilainya true, dia akan menjalankan blok kode di dalamnya. Statemen while akan terus dijalankan sampai kondisi pada while bernilai false. Sehingga kita harus menyiapkan skenario agar kondisi bernilai false. 

Pengubah kondisi dapat berupa *decrement* / *increment* atau cukup mengubah nilai suatu variabel yang digunakan di kondisi **while**. Pada kode di atas kita menambah nilai variabel x sebanyak 1 setiap kali blok kode pada while dijalankan, agar sampai pada kondisi nilai $x lebih dari 5 sehingga pengecekan kondisi bernilai false.

Statemen While

Hampir sama dengan statemen **while** hanya saja pengecekan kondisi dilakukan di akhir. Sehingga program paling tidak menjalankan iterasi minimal satu kali. Secara umum format **do while** adalah sebagai berikut:

```
do {
    // proses
    // iterasi
} while ( kondisi );
```


Statemen Do While

Pada statemen *while* dan *do-while*, kondisi yang dicek tidak mesti berupa angka yang diiterasi, tapi bisa juga pengecekan kondisi lain yang kita tak perlu ketahui berapa kali harus dijalankan. Sedangkan statemen perulangan *for* lebih khusus digunakan apabila kita hendak mengulang eksekusi blok kode sebanyak angka yang kita tentukan.

Dalam pengulangan dengan *for* diperlukan sebuah variabel dengan nilai awal untuk diiterasi (biasanya berupa *integer*), kemudian kondisi untuk membatasi iterasi, dan *increment* atau *decrement* variabel.

```
for (inisiasi counter; kondisi; increment/decrement counter) {
    // kode yang akan dijalankan berulang
}
```

- **Parameter pertama** adalah inisial variabel yang akan dijadikan penghitung.
- **Parameter kedua** adalah pengecekan kondisi variabel. **Selama kondisi bernilai true, blok kode akan dijalankan**.
- **Parameter ketiga** untuk menaikkan/menurunkan nilai variabel setiap kali blok kode selesai dijalankan.
- Setiap parameter dipisahkan dengan tanda titik koma.


```
for(int x = 0; x < 5; x++){
   System.out.println(x);
}
```

pemrograman dasar java, perulangan dengan for

Statemen For

Perulangan biasanya diperlukan lebih dari satu tingkat. Misal untuk mencacah isi matriks berdimensi dua, kita memerlukan dua buah pengulangan untuk mengakses satu per satu elemen matriks. Perulangan bersarang atau *nested loop* dapat dilakukan di Java. Kamu cukup menaruh perulangan lain yang kamu perlukan di dalam pengulangan yang dipilih.



Statemen For Bersarang

Kita dapat menyusuri setiap nilai di dalam sebuah array menggunakan for. Array adalah variabel yang dapat memuat nilai lebih dari satu. Ada beberapa teknik untuk menyusuri setiap nilai di dalam array. Contohnya seperti ini:
```
int[] array = {10, 20, 30, 40, 50};
for (int i=0; i < array.length; i++){
    System.out.println(array[i]);
}
```
Namun di Java, kita dapat melakukan hal tersebut dengan kode yang lebih sederhana:
```
int[] array = {10, 20, 30, 40, 50};
for (int a: array) {
    System.out.println(a);
}
```
Setiap nilai pada `array` akan disusuri dari indeks ke-0 hingga akhir dan nilai tersebut dapat kita panggil pada variabel pencacah `a`. Tipe data dari variabel pencacah harus sama dengan tipe data arraynya.

For Array

Penggunaan **break** digunakan untuk memutus perulangan. Biasanya break digunakan bersamaan dengan pengecekan kondisi menggunakan if atau switch. Pengecekan kondisi dibuat di dalam blok kode yang diulang.

Statemen *break* dapat digunakan untuk menginterupsi semua jenis statemen perulangan, baik itu for, while dan do-while.  

Statemen Break

Penggunaan **continue** digunakan untuk meneruskan langsung ke perulangan selanjutnya. Seperti halnya `break`, `continue` biasanya digunakan bersamaan dengan pengecekan suatu kondisi.

Bila pada `break` perulangan akan dihentikan sama sekali, pada `continue` perulangan akan dilewatkan ke iterasi selanjutnya.

pemrograman dasar java, statemen continue

Statemen Continue

Hai Coders, selamat datang di interactive learning Java! Disini Kamu akan belajar pemrograman Java mulai dari yang paling dasar. 

Di dalam pemrograman Java Kamu dapat melihat bahwa struktur kode Java selalu dibungkus dengan `class`. Selain itu **bagian inti program akan dieksekusi di dalam method `main()`**.

Nama class boleh apa saja, hanya saja nama class harus sama dengan nama file. Misalkan nama class Main maka nama filenya harus `Main.java`.

File kode java berekstensi <b>.java</b> dan bila sudah di-*compile* akan menjadi <b>.class</b>, misalnya main.java dicompile menjadi main.class. Untuk mengkompilasi kode Java gunakan perintah `javac namafile.java` pada terminal. Untuk menjalankan bytecode Java gunakan perintah `java NamaClass` di terminal.

Pada tutorial pertama ini kita akan mencoba menampilkan output teks "Hello World".

Hello World

Di Java, kamu dapat melakukan operasi *string* dasar seperti penambahan *string*, mencari panjang *string*, dan *string formatting*.

Kamu dapat mencari panjang *string* dengan menggunakan *method* **length()** pada variabel *string*. Kamu juga dapat melakukan *string formatting* untuk memperelok kode program kamu agar lebih mudah terbaca. Untuk mencetak string dengan menggunakan format, kita dapat menggunakan method `System.out.printf()`.

Beberapa tanda *string formatting* yang dapat kamu ingat antara lain:
* `%s` diisi oleh *string lain*
* `%f` diisi oleh bilangan koma
* `%d` diisi oleh bilangan bulat

Perhatikan contoh berikut:
```
String produk = "Pasta gigi":
int harga = 2500;
System.out.printf("Produk: " + produk + " Harga: Rp " + harga);
```
Contoh kode di atas akan menampilkan output:

`Produk: Pasta gigi - Harga Rp 2500` 

Sekarang dengan menggunakan formatting seperti kode berikut:
```
String produk = "Pasta gigi":
int harga = 2500;
System.out.printf("Produk: %s - Harga: Rp %d", produk, harga);
```
kode kita akan nampak lebih rapi dan lebih mudah dibaca karena tidak menggunakan operator konkatenansi yang banyak.

Operasi String

Kita dapat mengganti suatu potongan *string* dengan *string* lainnya dengan menggunakan *method* **replace()**.
```
String kalimat = "pisang yang mentah tidak sama dengan pisang yang matang.";
nama.replace("pisang", "apel");
```
Pada contoh di atas, semua kata pisang yang ditemukan pada string `kalimat` akan diganti menjadi apel.

Adakalanya kita hanya ingin mengganti string yang ditemukan pertama kali saja. Untuk itu kita dapat menggunakan *method* **replaceFirst()**.

String Replacement

Kita dapat memeriksa apakah suatu *string* diawali oleh potongan *string* tertentu dengan menggunakan *method* **startWith()**. Kita juga dapat mengecek apakah suatu string diakhiri oleh potongan *string* tertentu dengan menggunakan **endWith()**. Kedua *method* ini akan mengembalikan nilai true bila ditemukan dan false bila tidak ditemukan.
```
String nama = "Ahmad Oriza Sahputra";
System.out.println(nama.startsWith("Ahmad")); // return true
System.out.println(nama.endsWith("Oriza")); // return false
System.out.println(nama.endsWith("putra")); // return true
```
Selain itu kita juga dapat mengambil suatu *substring* dari suatu string dengan menggunakan *method* **substring()**. 
```
String nama = "Ahmad Oriza Sahputra";
System.out.println(nama.substring(6, 11)); // return "Oriza"
```
Parameter pertama adalah indeks awal *string*, dan parameter kedua adalah indeks akhir dari *string* yang ingin diambil. Indeks string dimulai dari 0 yakni untuk karakter pertama pada string.


Substring

Bila kita ingin mendapatkan posisi indeks dari suatu potongan *string*, kita dapat menggunakan *method* **indexOf()**. 

Nilai yang dikembalikan dari *method* ini adalah nilai integer untuk posisi huruf terkiri dari potongan *string* terhadap *string* yang diperiksa.
```
String status = "Pada hari minggu 19 Maret Fulan berjalan ke supermarket dan membeli lagi snack kentang.";
System.out.println(status.indexOf("Fulan")); // return 26
```
Bila substring yang dicari tidak ditemukan, maka method akan mengembalikan nilai -1.

IndexOf String

Kita dapat mengganti case huruf pada string menjadi kapital atau non-kapital (huruf kecil). Untuk mengubah string menjadi kapital gunakan *method* **toUpperCase()**. Sedangkan bila ingin mengubah menjadi huruf kecil semua, dapat menggunakan *method* **toLowerCase()**.
```
String nama = "Kresna Galuh":
System.out.println(nama.toUpperCase()); // "KRESNA GALUH"
System.out.println(nama.toLowerCase()); // "kresna galuh"
```

Change Case String

*String* yang panjang dapat dibagi-bagi atau dipecah berdasarkan karakter yang ditentukan sebagai pemecahnya. Karakter pembagi bisa saja sebuah koma, spasi, atau tanda baca lainnya sesuai keinginan. Untuk melakukan hal tersebut, kita gunakan method **split()**. Hasil dari pemanggilan method tersebut adalah array string.
```
String nama = "Muhammad Singgih";
System.out.println(Arrays.toString(nama.split(" ")));
```
Contoh kode di atas akan menghasilkan output `"[Muhammad, Singgih]"`.


Split String

Variabel adalah wadah yang diberi nama yang dapat kita isi dengan nilai dan dapat dimanipulasi. Sebelum dapat digunakan, variabel harus dideklarasikan terlebih dahulu.

```
tipedata namavariabel = nilai;
```

Bila hendak mendeklarasikan lebih dari satu variabel yang bertipe sama, pisahkan dengan tanda koma.

```
int a, b, c;
int a = 10, b = 10;
byte B = 22;
double pi = 3.14159;
char a = 'a';
```

Ada tiga jenis variabel di Java:
- Variabel lokal
- Variabel instance
- Variabel Class/Static

Variabel lokal adalah variabel yang dideklarasikan di dalam method atau blok. Variabel ini hanya dapat digunakan di dalam method tersebut. Variabel ini dibuat ketika method dipanggil, dan akan langsung dihapus setelah pemanggilan method selesai.

Pada pendeklarasian variabel lokal, kita harus menuliskan lengkap mulai dari tipe data, nama variabel dan juga nilai awalnya.

Variabel di Java

Instance variable adalah variabel yang dideklarasikan di dalam class, tetapi di luar method. Instance variable biasanya dibuat bila kita membutuhkan variabel yang akan digunakan oleh lebih dari satu method.

Berbeda dengan local variable, instance variable tidak mesti ditulis dengan nilai awal. Bila nilai awal tidak dideklarasikan, maka nilai default untuk instance variable adalah 0 bila bertipe integer, `false` bila bertipe boolean, dan `null` untuk referensi objek.

Instance variable dapat dipanggil langsung dengan namanya di dalam class, kecuali method static. Pada method static seperti `main()`, variabel dapat dipanggil melalui objeknya `namaObjek.namaVariabel`.

Instance Variable

Class variable atau dikenal juga dengan istilah static variable adalah variable yang dideklarasikan di dalam class di luar method. Sama seperti instance variable, class variable dibuat bila kita membutuhkan variabel yang digunakan di banyak method.

Perbedaan class variable dengan instance variable adalah, pada class variable kita menambahkan kata kunci `static` pada pendeklarasian.

```
static String pesan;
```

Class variable dapat dipanggil langsung di dalam class di dalam method, dan pada method static dapat dipanggil dengan menulis `NamaClass.namaVariabel`.

Class/Static Variable

Konstanta pada pemrograman berfungsi mirip dengan variabel. Bedanya variabel dapat kita ubah isinya selama *runtime*, sedangkan konstanta tidak. 

Di Java sebenarnya tidak ada term konstanta. Namun kita dapat membuat variabel yang bersifat seperti konstanta dengan menambahkan kata `final` pada deklarasi variabel sebelum menuliskan tipe data. Dan seperti konstanta umumnya, pada Java juga kita dianjurkan untuk menuliskan final variabel dengan menggunakan nama variabel menggunakan huruf kapital.

```
static final float PI = 3,14;
```

pemrorgraman java dasar, membuat konstanta di java

Konstanta di Java

Ada beberapa tipe data dasar yang wajib kamu ketahui bila ingin membuat sebuah aplikasi dengan bahasa pemrograman Java, diantaranya:

* **byte**, diisi dengan angka bulat bukan bilangan koma dengan rentang -128 hingga 127
* **short**, diisi dengan angka bulat bukan bilangan koma dengan rentang -32.767 hingga 32.767
* **int**, diisi dengan angka bulat bukan bilangan koma dengan rentang -2.147.483.648 hingga 2.147.483.647
* **long**, diisi dengan angka bulat bukan bilangan koma dengan rentang -9.223.372.036.854.775.808 hingga 9.223.372.036.854.775.807
* **float**, diisi dengan bilangan koma dengan rentang 32-bit IEEE 754 floating point
* **double**, diisi dengan bilangan koma dengan rentang 64-bit IEEE 754 floating point
* **boolean**, diisi dengan **true** dan **false** saja. Selain itu akan *error*
* **String**, diisi dengan rangkaian alfanumerik dan tanda baca yang diapit dengan tanda petik dua (")
* **char**, diisi dengan alfanumerik yang diapit dengan tanda petik satu (')

Kamu dapat membuat sebuah variabel di dalam *method* yang tentu saja akan menjadi variabel lokal di dalam *method* tersebut. Atau menjadikannya atribut suatu kelas, namun harus menginstansiasi atau membuat objeknya dahulu bila ingin menggunakan variabel tersebut.

Setelah membuat variabel, kamu dapat melakukan berbagai operasi seperti operasi aritmatika dan menampilkannya ke konsol.

tipe data di java, pemrograman dasar java

Belajar Coding Interaktif Pemrograman Java

Silabus

Tentang Kelas

Yang akan kamu dapat

Web Development

Mobile Development

Studi Kasus

Fundamental

Pemula

Menengah

Framework

Front End

Back End

Laravel

PHP

Kotlin

Android

Javascript

Wordpress

Database

Java

Go-Lang

Kelas Terbaru

Kelas Gratis

Populer

Roadmap

PlaygroundNEW

Belajar Coding Interaktif Pemrograman Java

Silabus

Sintaks Dasar

Variabel

Operator

Pemilihan Kondisi

Perulangan

Array

String

Fungsi

Class dan Objek

Tentang Kelas

Yang akan kamu dapat