Dalam pemrograman Java kita akan menggunakan berbagai jenis operator untuk memanipulasi variable. Beberapa kelompok operator itu ialah :

• Arithmetic Operator
• Relational Operator
• Bitwise Operator
• Logical Operator
• Assignment Operator
• Misc Operator

Arithmetic Operator

Bagian ini seringkali dipakai untuk menghitung kalkulasi matematis, kayak yang sering dipakai saat perhitungan algebra. Asumsikan saja ada variable A untuk nilai 10 dan ada variable B untuk nilai 20. Nah ini dia:

Operator	Contoh
+ (penambahan)	A + B hasilnya 30
– (pengurangan)	A – B hasilnya -10
* (perkalian)	A * B hasilnya 200
/ (pembagian)	B / A hasilnya 2
% (modulus)	B % A hasilnya 0
++ (increment)	B++ hasilnya 21
— (decrement)	B– hasilinya 19

Untuk yang baru saja menggunakan istilah ‘increment’ itu sebenarnya mudah difahami sebagai penambahan 1. Dan untuk istilah kebalikannya ‘decrement’ berlaku pengurangan 1.

Relational Operator

Bagian operator yang satu ini sering dipakai untuk memeriksa keadaan hubungan antar variable. Misalkan ya, anggap story tadi variable A senilai 10 dan variable B senilai 20, maka…

Operator	Deskripsi	Contoh
==	Memeriksa nilai kedua variable apakah sama?	(A==B) maka false
!=	Memeriksa nilai kedua variable apakah berbeda?	(A!=B) maka true
>	Memeriksa nilai variable kiri lebih besar daripada variable kanan.	(A>B) maka false
<	Memeriksa nilai variable kiri lebih kecil daripada variable kanan.	(A<B) maka true
>=	Memeriksa nilai variable kiri lebih besar sama dengan variable kanan.	(A>=B) maka false
<=	Memeriksa nilai variable kiri lebih kecil sama dengan variable kanan.	(A<=B) maka true

Untuk lebih mudahnya gunakan praktek dalam penggunaan contoh logika if else dalam coding java. Sehingga operator ini bisa dikenali kegunaannya masing-masing.

Bitwise Operator

Dalam penggunana Bitwise operator kita sering menggunakannya untuk beberapa jenis variable seperti : long, int, short, char, dan byte.

Kenapa? Tentu saja karena seluruh dari data type variable ini bisa melakukan penggeseran nilai bit (1 & 0), pelajari lagi tentang nilai binary apabila kamu ingin mengetahui tentang kegunaannya.

Asumsikan variable A senilai 60 dan variable B senilai 13. Karena dalam angka binary maka :

A dianggap 0011 1100
B dianggap 0000 1101

Sehingga apabila digunakan dengan bitwise operator maka hasilnya begini:

Operator	Deskripsi	Contoh
&	Binary AND	(A&B) hasilnya 12 yaitu 0000 1100
|	Binary OR	(A|B) hasilnya 61 yaitu 0011 1101
^	Binary XOR	(A^B) hasilnya 49 yaitu 0011 0001
~	Binary unary	(~A) hasilnya -61 yaitu 1100 0011
<<	Binary LEFT	(A<<2) hasilnya 240 yaitu 1111 0000
>>	Binary RIGHT	(A>>2) hasilnya 15 yaitu 0000 1111
>>>	Geser 0 kanan	(A>>>2) hasilnya 15 yaitu 0000 1111

Logical Operator

Untuk penggunaan logical operator kita hanya memerlukan variable yang menghasilkan true atau false. Asumsikan kita pakai variable A senilai true dan variable B senilai false maka seperti ini misalnya:

Operator	Deskripsi	Contoh
&&	Logical AND	(A&&B) maka false
||	Logical OR	(A||B) maka true
!	Logical NOT	(A!=B) maka true

Assignment Operator

Nah dalam penggunaan Assignment operator pula kita akan menggunakan tanda ‘sama dengan’ lebih sering lho! Karena memang dikenal juga sebagai operator pemberi nilai. Misalkan variable A senilai 5 dan variable B senilai 10. Dari 11 jenisnya ada 6 buah assignment operator yang kamu bisa fahami dengan mudah yaitu :

Operator	Deskripsi	Contoh
=	Pemberian nilai kanan ke kiri	B = A + 1 hasilnya B ialah 6
+=	Penambahan nilai kanan disimpan ke kiri	B += 1 hasilnya 10+1 yaitu 11 disimpan di B
-=	Pengurangan nilai kanan disimpan ke kiri	B -= 2 hasilnya 10-2 yaitu 8 disimpan di B
*=	Perkalian nilai kanan disimpan ke kiri	A *= 3 hasilnya 5*3 yaitu 15 disimpan di A
/=	Pembagian nilai kanan disimpan ke kiri	B /= 2 hasilnya 10/2 yaitu 5 disimpan di B
%=	Pembagian sisa habis disimpan ke kiri	B %= 2 hasilnya 0 yaitu disimpan di B

Misc Operator

Nah untuk operator lainnya yang tidak masuk kategori apapun diatas itu ada dibagian yang satu ini. Paling tidak pembahasannya dipakai untuk 2 hal saja yaitu: Conditional Operator dan Instanceof Operator. Seperti apakah itu? Ok mari kita perhatikan dengan seksama….

Conditional Operator

Conditional Operator itu sering dikenal sebagai ternary operator, memang namanya rada aneh gitu ya. Tapi yang jelas fungsinya memperpendek penggunaan if else dan pemberian nilai. Contohnya begini:

variable x = (checking) ? true : false;

Sebagai penggunaannya kita bisa pakai seperti ini lho:

public class Contoh {
   public static void main(String [] args){
    int a,b;
    a = 10;
    b = (a == 1) ? 20 : 30;
    System.out.println("nilai B yaitu : " + b);

    b = (a ==10) ? 20 : 30;
    System.out.println("nilai B yaitu : "+ b);

   }

}

Udah kebayang hasilnya gimana? Nah ini dia…

nilai B yaitu : 30
nilai B yaitu : 20

Kalau penasaran cobain aja coding dan lihat hasilnya langsung ya!

Instanceof Operator

Dibagian penggunaan Instanceof Operator kita akan menggunakannya pada penerapan variable object yang akan diperiksa. Secara mudahnya pola yang dipakai akan memeriksa apakah variable tertentu itu cocok dengan jenis yang diberikan? Misalnya begini…

public class Contoh {

   public static void main(String [] args){
    String nama = "Udin";

    // disini kita akan memeriksa

    boolean jenisText = nama instanceof String;
    System.out.println("Apakah variable nama ialah text? " + jenisText);

   }

}

Bagaimana dengan hasilnya? Ini dia…

Apakah variable nama ialah Text? true

Okay, segitu dulu pembahasan tentang operator yang sering dipakai dalam java code. Di pembahasan selanjutnya kita akan lanjut ke Loop Control yaitu proses pengulangan yang mempermudah code lebih efisien dan lebih ringkas!

Dalam penggunaan Modifier yang kita akan explore yaitu :

• Java Access Modifier
• Java Non Access Modifier

Bagaimana menggunakannya? Caranya cukup mudah, sebenarnya kita perlu menyertakan keywords tertentu di depan penerapan method, class, dan atau variable. Keywords nya yg tersedia ialah seperti ini:

• public
• private
• protected
• static
• final
• abstract
• synchronized
• volatile

Coba perhatikan penjelasan berikutnya.

Java Access Modifier

Sesuai tujuannya dengan penggunaan modifier ini maka bertujuan untuk memberikan akses terhadap pihak tertentu:

• Agar bisa diakses oleh package (biarkan secara default)
• Agar bisa diakses hanya di dalam suatu class (private)
• Agar bisa diakses semuanya (public)
• Agar bisa diakses oleh package itu dan subclass nya saja (protected)

Kemudian coba perhatikan lagi.

Java Non Access Modifier

Sesuai namanya disini modifiernya hanya berfungsi sebagai target pengguna masing-masing:

• Penerapan pada method, dan variable (static)
• Penerapan pada implementasi class, method dan variable yg ingin dikunci nilainya (final)
• Penerapan konsep abstrak class dan atau methodnya juga (abstract)
• Penerapan khusus thread (synchronized dan volatile)

Tentu siapapun juga makin penasaran bagaimana sih penulisannya? Karena belum diberikan contoh sama sekali. Berikut ini cara penggunaan simple nya :

public class MesinMotor {
 // contoh pola public class
}

// ini access private
private boolean statusWargaIndo = false;

// ini non access modifier 
static final double rasioNilaiKalkulasi = 450.5;

// penggunaan pada method juga boleh
public static void main (String [] args) {
   // method yg khusus secara static
}

Sekarang kamu mulai sadar ya ternyata access modifier dan non access modifier ini sering dipakai dalam setiap keadaan apapun. Baiklah mari kita explore lagi untuk penjelasan terperinci berikutnya.

Default Access Modifier

Secara default kita bisa saja tidak menuliskan access modifier dalam java code, sehingga nanti bawaannya ya default aja. Misalkan ada sebuah variable atau method yang tidak diberikan penulisan access modifiernya maka hak aksesnya cuma bisa dipanggil oleh class manapun yang satu package (se-folder). Hal ini juga berlaku bagi interface ataupun methodnya yang tidak dituliskan access modifiernya. Contohnya begini:

// ini default lho access modifiernya 
String versiApp = "1.5.2";

// kemudian method juga bisa tanpa access modifier
// jadi dapet bawaan secara default
boolean checkStatusOrder(){
   return statusOrder;
}

Semoga sekarang kamu mulai faham ya? Ok. Lanjutkan…

Private Access Modifier

Nah apabila kita menggunakan keywords ‘private’ maka otomatis nih bagi method, variable, dan atau constructur hanya akan dapat diakses oleh class itu saja.

Yang menggunakan keywords ‘private’ ini juga berfungsi memperketat hak akses code. Sehingga pihak luar class tidak bisa memanggilnya. Tapi kita bisa menggunakan method seperti public get dan public set nya masing-masing variable tersebut. Kalau berniat untuk menyembunyikan hak aksesnya suatu object terhadap class lain ya ini dia gunakan keywords ‘private’. Contoh prakteknya begini:

public class Pencatat {
  private String format;

  public String getFormat(){
    return this.format;
  }

  public void setFormat(String jenis){
    this.format = jenis;
  }

}

Dari code diatas ini kita bisa melihat variable ‘format’ di dalam class ‘Pencatat’ memiliki access modifier berjenis ‘private’. Dengan begitu maka setiap class lain yang dari luar tidak dapat memanggilnya secara langsung. Seperti apa itu? Ini dia…

// asumsikan dipanggil oleh class lain

Pencatat panggilan1 = new Pencatat();

// dibawah ini bakalan error
panggilan1.format = "simple";

// tapi kita masih boleh menggunakan set dan get nya
panggilan1.setFormat("custom");

// dan ini juga boleh 
String jenisFormatPertama = panggilan1.getFormat();

Public Access Modifier

Misalkan kita menggunakan keywords ‘public’ ini disaat penggunaan suatu class, method, constructor, dan atau interface ya. Dengan begitu maka siapapun pihak classnya yang memerlukan mereka bisa langsung panggil secara mudah.

Tapi ingat apabila yang melakukan panggilan ialah sebuah class luar packagenya, maka statement ‘import’ bakal dipergunakan. Hal tersebut berguna sebagai penghubung, sehingga Java Code kenal ‘oh class yang baru dipanggil berasal dari bagian yang baru saja di import’. Begitu lho!

Protected Access Modifier

Suatu variable, method, dan atau constructor yang menggunakan keywords ‘protected’ maka hanya bisa diakses oleh sub-class dari super-class nya. Tetapi bisa juga diakses oleh class lain yang sama packagenya.

Perlu diingat bahwa penggunaan keywords ‘protected’ bukan untuk penggunaan class atau interface secara langsung. Kalau kita mau menggunakannya untuk method atau variable itu bisa saja. Kegunaan utamanya tentu saja memberikan hak akses bagi sub-class sehingga membatasi pemanggilan oleh class lain yang tidak ada kaitannya.

class AudioPlayer {
  protected boolean jalankanSpeaker(Speaker sp){
    // implementasi disini
  }
}

class StreamingAudioPlayer extends AudioPlayer {
  boolean jalankanSpeaker(Speaker sp){
    // modifikasi lain bisa disini
  }
}

Coba perhatikan bagian method ‘jalankanSpeaker()’ itu diatas. Misalkan saja kita menggunakan keywords ‘private’ maka otomatis dong pemanggilan luar dari class tersebut tidak bisa menggunakannya. Sebaliknya jika kita menggunakan keywords ‘public’ maka semua class bisa memanggil method tersebut karena memang terbuka bebas oleh keywords ‘public’.

Namun karena kita ingin membatasi hanya bagi sub-class saja dan tidak boleh diakses oleh class lain, maka keywords ‘protected’ saja yang dipergunakan. Ok, mengerti ya?

Beberapa penggunan non-access modifier ada bedanya terlebih sesuai dengan kasus yang akan diimplementasikan.

Static Modifier

Jika suatu variable menggunakan keyword ‘static’ maka setiap object class yang memerlukannya bisa menggunakan panggilan secara langsung. Karena tiap variable yang menggunakan keyword ‘static’ akan memiliki 1 nilai yang tetap running meskipun dipanggil oleh class yang bervariatif. Istilah lain variable yang menggunakan keyword ‘static’ ialah class variable.

Berbeda halnya jika kita ingin membuat suatu method yang dapat diakses oleh class manapun juga (meskipun berbeda package). Seperti ini misalnya:

class PencetakLaporan(){
   private static int jumlahData = 0;
   
   public static void getJumlahTerkini(){
     return jumlahData;
   }

   public static void cetak(String data){
    // operasi tertentu
    // lalu akses variable staticnya
    System.out.println("printing.... " + data);
    jumlahData++;
   }
}

Nah kalau kita perhatikan bagian ini, memang terlihat seperti biasa class dan variable pada umumnya. Namun perhatikan lagi methodnya yang mendapatkan non access modifier static ini. Lihat baik-baik saat kita mulai memanggilnya dari penerapan selanjutnya:

class Implementasi {
  public static void main(String [] args){
     PencetakLaporan.cetak("data baru");
     int totalData = PencetakLaporan.getJumlahTerkini();
     System.out.println("dihasilkan sejumlah " + totalData + " data!");
  }
}

Perhatikan penggunaan method cetak(), yang bisa langsung diakses tanpa object initialisasi, dan juga terhadap method getJumlahTerkini(), luar biasa simple kan jika menggunakan ‘static’ ini? Dan tentu saja hasilnya ini dia…

printing... data baru
dihasilkan sejumlah 1 data!

Final Modifier

Dalam penggunaan final modifier, kita hanya menggunakan inisialisasi sekali dan juga penggunaan nilai lain hanya itu saja, tidak boleh berubah meskipun dipanggil oleh berbagai macam proses lain. Seringkali satu variable menggunakan keyword ‘final’ ini lalu diiringi pula dengan menggunakan ‘static’. Tujuannya agar dapat diakses oleh class lain secara instan dan nilainya konstan alias tidak berubah-ubah. Begini misalnya:

final int patok = 10;

// kemudian konstan disini
public static final int BATAS_TEPI = 100;

public void prosesTertentu(){
  patok++;
  // hasilnya? error dong!
}

Dari contoh diatas kita sudah bisa faham dan mengerti bahwa suatu variable yang menggunakan keyword ‘final’ maka jangan sekali kali dilakukan pemberian nilai yang niatnya untuk merubah nilai pertama. Hasilnya bakalan error! Kan udah dibilang final, ya jangan berubah diproses manapun itu!

Kemudian, sekarang kita lanjutkan ke contoh method. Serupa dengan variable tadi. Namun penggunaannya ialah menjadikan sub-class pengguna untuk tidak merubah konsep final method yang diberikan. Seperti ini misalnya:

public class Kotak{
  public final void prosesPertama(){
    // proses tertentu disini
  }
}

public class PenggunaBentuk extends Kotak{
  // dilarang untuk diubah... cobalah!
  public void prosesPertama(){
    // pasti error!
  }
}

Dan begitu pula terhadap class yang menggunakan keyword ‘final’ hal ini juga berfungsi sama yaitu penguncian agar tidak terjadi perubahan terhadap penggunanya. Seperti pada :

public final class Program {
  // isilah dengan sesuatu 
  // kemudian cobalah diextends oleh class lain
  // pasti error
}

Abstract Modifier

Saat penggunaan keyword ‘abstract’ maka penggunaan suatu class tersebut tidak boleh menggunakan keyword ‘final’. Karena keduanya memiliki sifat yang berbeda. Jika menggunakan keyword ‘abstract’ maka kita mewajibkan user untuk melakukan inheritance, menurunkan fitur kepada sub-class dengan cara ‘extends’. Dan method manapun yang menerapkan ‘abstract’ maka wajib deh class naming nya juga ikut penggunaan ‘abstract’. Bingung? Kita perjelas deh dengan contoh berikut ini supaya lebih mudah….

abstract class Pedagang{
  private double harga;

  // disini ada abstract method
  // tak perlu code di dlm body-nya
  public abstract void proses();
  public abstract void ubahWarna();
}

Mungkin sebagian ada yang nanya, kenapa ada keyword ‘abstract’ pada sebuah class kalo coding body-nya ngga dituliskan? Jawabannya sederhana, karena konsep class yang menggunakan keyword ‘abstract’ ini akan menjadi patokan konsep yang diteruskan (dipakai/diterapkan) oleh sub-classnya. Pembahasan lebih detail tentang inheritance (tentu akan lebih menyederhanakan tentang ini) nanti ada!

Modifier lainnya

Synchronized Modifier

Kita boleh menggunakan keyword ini dengan tujuan untuk membatasi penggunaan pada 1 thread saja dalam 1 waktu.

Transient Modifier

Berbeda halnya dengan keyword ‘transient’ karena akan memberikan perintah terhadap JVM untuk skip (mengecualikan) serialisasi bagi object yang menggunakannya.

Volatile Modifier

Penggunaannya keyword ‘volatile’ memang menjadikan suatu variable bertahan pada copyan nilainya di memory oleh JVM. Karena thread akan selalu mempertahankan master-copy nya. Penggunaannya lebih cocok apabila ingin diterapkan pada instance variable yang bisa jadi object atau bisa juga private. Contohnya begini:

public class Program implements Runnable {
  private volatile boolean putaran;
  
  public void run(){
   putaran = true;

   while(putaran){
     // coding tertentu
   }
  }

  public void stop(){
    putaran = false;
  }
}

Nah disini bisa kita lihat saat thread bermula, kita memproses run() method ya? Tapi apa jadinya saat proses tertentu kita melakukan pemanggilan stop() ? Yang seharusnya terjadi sesuai keinginan yaitu while-loop berhenti karena status berganti menjadi false. Namun karena volatile, maka pemanggilan stop() seperti tidak memberikan efek sama sekali. While-loop jalan terus!

Oke cukup sampai sini dulu, kita akan lanjutkan ditopik berikutnya tentang Operator Dasar. Tetaplah simak dan praktekkan code agar lebih menguasai dengan baik ya!

Memang untuk menyimpan suatu nilai kita memerlukan variable. Dari sinilah sebenarnya nilai tertentu ada di lokasi khusus pada suatu memory. Mungkin kita belum begitu sadar ya tiap nilai tertentu itu tersimpan rapi di dalam memory. Tetapi begitu RAM kita rusak, phewww! Rata-rata langsung merembet error kesana kemari! Tapi kali ini kita bukan membahas tentang error koq! Disini kita bakalan explore tentang jenis data yang disimpan oleh suatu variable. Apa saja sih? Ada dua hal:

• Primitive Data Type
• Reference atau Object Data Type

Primitive Data Type

Wah apa itu Primitive? Disini disebut primitif sebenarnya bukan bermakna ‘purbakala’. Tetapi digunakan oleh java sebagai identifikasi 8 jenis data yang sudah ditentukan sejak awal. Apa saja itu?

• byte
• short
• int
• long
• float
• double
• boolean
• char

Itulah ke-8 jenis Primitive Data Type. Secara terperinci begini jadinya :

	boolean	char	double	float	long	int	short	byte
Kegunaan Simpanan	true / false	huruf tunggal	nilai desimal 64bit dengan 754 floating point	nilai desimal 32bit 754 floating point	nilai 64bit integer	nilai 32bit integer	nilai 16bit integer	nilai 8bit integer
Default	false		0.0d	0.0f	0L	0	0	0
Minimum		‘\u0000’			(-2^63)	(-2^31)	(-2^15)	(-2^7)
Maximum		‘\uffff’			(2^63-1)	(2^31-1)	(2^15-1)	(2^7-1)
Contoh	boolean b = true;	char = ‘a’;	double cash = 500.5d;	float x = 245.5f;	long y = 12000L;	int y = 12;	short n = 12;	byte m = 8;

Reference Data Type

Sering dikenal sebagai Object data type. Secara default nilainya pasti null. Contohnya begini :

Binatang robot;
System.out.println(robot);

// tapi akan beda jika
Binatang robotKece = new Binatang("laba-laba");
System.out.println(robotKece.jenis);

Sehingga hasilnya :

null
laba-laba

Java Literal

Dalam penulisan nilai yang sudah fixed kita dapat memberikan nilai langsung kepada suatu variable misalkan seperti ini :

byte kode = 68;
char simb = 'A';

Dan ada juga pemberian nilai yang memberikan nilai oktal, bisa diawali dengan 0. Kemudian penggunaan nilai hexadecimal bisa menggunakan awalan 0x. Begini misalnya:

int bulat = 100;
int oktal = 0144;
int hexa = 0x64;

Kemudian kita juga harus ingat bahwa pemberian nilai String wajib pakai tanda petik seperti ini :

String namaPanggilan = "Udin Sampudin";
String alamat = "Jl. Kemayoran No.12, Jakarta Selatan";

Khusus pada jenis data char kita diperbolehkan menggunakan unicode character. Seperti apa itu misalnya? Ini dia…

char serina = '\u0001';
char serinb = '\u0002';

Dan pada kondisi tertentu kita juga terkadang membutuhkan simbol lain yang digunakan berdasarkan kebutuhan khusus misalnya spasi, tab, garing (garis miring), dst… Ini dia listing nya :

Notasi	Kegunaan
\n	Newline
\r	Carriage return
\f	Formfeed
\b	Backspace
\s	Space
\t	tab
\”	Double quote
\’	Single quote
\\	Backslash
\uxxxx	Hexadesimal Unicode

Tanda diatas memang kelihatan aneh, tapi coba aja pada beberapa String dan perhatikan hasilnya!

Deklarasi Variable

Dalam penulisannya kita perlu menggunakan syntax alias kaidah standar yaitu :

datatype variable = nilai;

Sehingga contoh penerapannya bisa semudah ini :

int a, b, c;
int aku = 28, kamu = 9, dia = 99;
double nilaiPI = 3.14;
char kode = 'X';

// cukup jelas ya?

Untuk itu setidaknya kita harus faham lho bahwa dalam Java Programming ini ada 3 jenis variable yang harus diketahui :

• Local Variable
• Instance Variable
• Class/Static Variable

Local Variable

• Biasanya dideklarasikan pada method, atau constructor, atau block tertentu.
• Harus diberikan nilai tertentu agar dapat dipakai.
• Sehingga saat proses eksekusi selesai dari suatu method misalnya, maka variable tadi bakal otomatis berakhir. variablenya bakal ‘destroyed’ alias dimusnahkan oleh memory. Kita ngga tau hal tersebut. Yang jelas lancar jalan udah gitu aja!

Contohnya begini:

public class MotorGen{
  public void testGerak(){
   int powerNa;
   powerNa = powerNa + 7;
   System.out.println("Power semula " + powerNa);
  }


  public static void main(String [] args){

    MotorGen coba = new MotorGen();
    coba.testGerak();

  }
}

Hasilnya begini :

MotorGen.java : 4 : variable might not have been initialized 
powerNa = powerNa + 7;
            ^
1 error

tapi coba rubah code testGerak() itu menjadi begini pasti java bakal lancar lagi…

public void testGerak(){
   int powerNa = 10;
   powerNa = powerNa + 7;
   System.out.println("Power semula " + powerNa);
  }

Nah hasilnya betulkan?

Power semula 17

Instance Variable

Disini variable tidak disebut sebagai local tetapi disebut Instance karena deklarasinya terletak diluar method, diluar constructor juga.

Penggunaan Instance variable itu hanya dipakai apabila kita menggunakan keywords ‘new’. Begini misalnya:

  // ini instance baru
  Kucing robot = new Kucing();

  // tapi ini belum ada nilainya
  Kucing mesin;

Ketika Instance variable dipakai sebenarnya seluruh method, constructor dan juga block tertentu dapat mengaksesnya dengan baik! Contohnya begini…

import java.io.*;
  public class Karyawan{
    // ini instance variable ya
    public String nama;
    // yang ini juga tapi ga bisa diakses oleh class lain
    private double gaji;

  public Karyawan(String namina){
    nama = namina;
  }

  public void setGaji(double uang){
    gaji = uang;
  }

  public void cetakData(){
    System.out.println("Nama : " + nama);
    System.out.println("Gaji : " + gaji);
  }

  public static void main(String [] args){
    Karyawan orang = new Karyawan("Siska");
    orang.setGaji(400);
    orang.cetakData();
  }

  }

Dan hasilnya ya betul saja:

   Nama : Siska
   Gaji : 400

Faham ya sekarang?

Class/Static Variable

Static variable ini mirip seperti instance cuma tiap variablenya akan bernilai sama pada penggunaan manapun.

Ibaratnya satu variable diciptakan lalu diakses oleh berbagai macam class ternyata nilainya seperti sama semua, alias shared for everyone!

Nah bahayanya variable ini tidak pernah didestroy, kecuali ketika program sudah exit. Nah kan ngeri ya! Tapi tenang koq, karena nanti bakal kita explore cara mengatasinya!

Penggunaan saat dipanggil pada code cukup gunakan format : ClassName.VariableName

Simple yah mari kita coba…

public class Kotak{
  static int nomorSeri = 1234;
  public static void main(String arg[]){
    Kotak benda = new Kotak();
    System.out.println("Awal " + benda.nomorSeri);

    nomorSeri = 9912;

    Kotak bendaBaru = new Kotak();
    System.out.println("Jadi ini " + bendaBaru.nomorSeri);

    // padahal sama saja
    System.out.println("Memang pasti " + Kotak.nomorSeri);
  }

}

Bisa ditebak outputnya bagaimana? Nah ini…

   Awal 1234
   Jadi ini 9912
   Memang pasti 9912

Oke deh, segitu dulu, jika kamu pengen tau lebih jauh tentang itu semua? Cobain dulu ketik coding nya ke dalam source code java. Atau at least bagi yang belum punya laptop cobalah Java Compiler versi mobile ini.

Karena pembahasan di artikel selanjutnya kita akan bahas tentang access modifier. Apa dan bagaimana detailnya… simak terus dan rajin praktek ya!

Masih ingat pembahasan lalu tentang constructor? Okay kita lanjutkan ya disini… Tiap kali setiap object dideklarasikan maka pada saat itu pula constructor terpanggil. Pada umumnya kita menuliskan suatu constructor untuk mempermudah pemberian nilai awal suatu variable tertentu.

Ingat ya setiap class dalam java pasti punya minimal satu constructor secara default meskipun bisa jadi kita ngga menuliskannya secara sengaja. Begini polanya:

class ProgramSatu {
 // ini default constructor nya
 public ProgramSatu(){
 
 }
}

Dari sini kita dapati constructor ProgramSatu tidak menerima variable apapun. Tapi bisa kita gunakan pemberian default value kepada variable yang membutuhkannya misal saja seperti ini:

class ProgramSatu {
String jenisRobot;
int nomerUrut;
 // ini constructor yg ada default value 
 public ProgramSatu(){
    nomerUrut = 1;
    jenisRobot = "ACX-S2023";
 }
}

Berarti kalau kita panggil dalam implementasinya…

class Pemanggilan{

 public public static void main(String [] args){
    ProgramSatu mesin = new ProgramSatu();
    System.out.println("Kita punya " + mesin.jenisRobot + " dengan nomor : " + mesin.nomerUrut);
 }
}

Sehingga hasilnya…

Kita punya ACX-S2023 dengan nomor 1

Bisa difahami ya?

Constructor dengan Parameter

Setelah mengerti tentang constructor sekarang marilah kita sertakan beberapa parameter yang dibutuhkan. Tujuannya agar disaat pemanggilan constructor ini masuk bersamaan sekaligus diberikan inisialisasi nilai pada beberapa variablenya. Anggap saja begini:

class MesinKomputer {
  String rangkaSeri;
  int jumlahPin;

public MesinKomputer(String rangkaMasuk, int banyakPin){
   rangkaSeri = rangkaMasuk;
   jumlahPin = banyakPin;
}

}

Dari sini semisal kita eksekusi langsung pemanggilannya dengan cara…

class PengetesanMesin {
  
public static void main(String [] args){
   MesinKomputer mPercobaan1 = new MesinKomputer("IBM-S1002", 12);
   MesinKomputer mPercobaan2 = new MesinKomputer("IBM-XD02", 45);

   int totalPin = mPercobaan1.jumlahPin + mPercobaan2.jumlahPin;

   System.out.println("2 Mesin baru telah tercipta dengan " + totalPin + " total PIN.");

}

}

Hasilnya bisa dilihat ya?

2 Mesin baru telah tercipta dengan 57 total PIN.

Dibagian kali ini kita akan lebih mengenal secara detail tentang konsep OOP (Object Oriented Programming) yang dipakai khususnya pada Java. Kenapa ya dalam OOP itu dikenal istilah lain seperti :

• Polymorphism
• Inheritance
• Encapsulation
• Abstraction
• Classess
• Objects
• Instance
• Method
• Message Passing

Yuk kita kenali dulu bagian pokoknya yaitu : Object & Class. Apa sih mereka itu ya?

Object : dikenal sebagai suatu entity yang memiliki karakteristik dan fungsi / aksi tertentu. Contohnya anggap saja ada seorang manusia yang memiliki beberapa karakteristik seperti nama, usia, tanggal lahir, dan lainnya. Kemudian seorang manusia ini karena dikenal sebagai Object maka tentu saja memiliki fungsi / aksi tertentu. Misalnya yaitu, berlari, berjalan, mengangkat barang, dst.

Class : konsep suatu object bisa dituliskan kedalam sebuah blueprint atau template yaitu Class. Definisi lain seperti proses tertentu, pengecekan, dan logika lainnya ada di dalam sebuah Class.

Contoh Class

Sekarang perhatikan dulu bagian yang satu ini agar kita menjadi lebih faham penerapannya dalam Java :

public class Manusia{
  String nama;
  int usia;
  String alamat;
  int beratBadan;

  public void berlari(){

  }

  public void mengangkat(String nama){

  }

  public void berjalan() {

  }
}

Sekarang sudah mulai faham ya? Bagaimana setiap variable itu digunakan sebagai karakteristik (disebut juga sebagai states dalam Java), kemudian aksi / fungsi tertentu (disebut juga sebagai method dalam java).

Constructor

Karena tadi sudah melihat bagian penulisan Class maka sekarang kenalilah bagian selanjutnya yaitu bagian pokok pertama kali dalam Class yaitu Constructor. Meski saat menuliskan sebuah Class programmer bisa saja tidak menuliskan suatu constructor maka java code akan menganggap adanya 1 default constructor secara otomatis!

Dan disetiap penggunaan Object baru yang tercipta dalam sebuah variable dari class tersebut, maka pemanggilan Constructor akan di-execute secara langsung! Oya, ingat bahwa penamaan Constructor akan sama dengan nama Class nya masing-masing! Begini contohnya :

public class Manusia{

  public Manusia(){
     // ini constructor pertama
  }

  public Manusia(String nama){
     // ini constructor kedua menerima parameter nama
  }

}
  

Nanti kita akan bahas lagi lebih detail tentang penggunaan Constructor ya!

Penggunaan Object

Karena suatu Class tadi akan digunakan dalam sebuah variable maka kita harus menciptakan suatu Object nya! Dari sini kita kenal beberapa istilah yaitu :

• Declaration : deklarasi pertama saat nama diberikan untuk suatu object.
• Instantiation : penggunaan keywords new dipakai disini untuk menciptakan Objectnya.
• Initialization : constructor akan terpanggil saat penciptaan object tersebut.

Bagaimana penggunaannya? Coba simak bagian source code berikut ini :

public class Manusia{

 public Manusia(String nama){
   // disini constructornya dibuat
   // agar dapat menerima sebuah nama
   System.out.println("Orang baru terciptakan..." + nama);
 }

 public static void main(String [] args){
 // ini variable orangAwal ialah Object dari Class Manusia
   Manusia orangAwal = new Manusia("Udin");
 }

}

Bisa dibayangkan seperti apa outputnya ? Ini dia hasilnya :

Orang baru terciptakan...Udin

Mengakses Variable & Method

Karena setiap class dipergunakan dalam dekralasi suatu object variable, maka method ataupun function juga bisa diakses lho!

/* ini deklarasi object pertama */
Manusia orang1 = new Manusia("Michael Jackson");

/* kemudian kita mulai akses methodnya */
orang1.sebutkanProfil();

/* atau kita juga bisa akses variable nya secara lokal */
orang1.namaDepan;
orang1.noHP;
// dan seterusnya...

Tentu saja coding diatas hanya bisa dijalankan apabila kita memiliki class terbaru yang isinya yaitu :

public class Manusia{

String namaDepan;
String noHP;

public Manusia(String namana){
  namaDepan = namana;
}

public Manusia(String namana, String hpna){
  namaDepan = namana;
  noHP = hpna;
}

public void sebutProfil(){
  System.out.println("---------- Profil ----------");
  System.out.println("Nama Saya ialah : " + namaDepan);
  System.out.println("No HP : " + noHP);
}

public static void main(String [] args){
  Manusia orang1 = new Manusia("Michael", "0812-1212-1212");
  orang1.sebutProfil();
}

}

Kira-kira kalau dijalankan outputnya seperti apa ya? Ini dia…

---------- Profil ----------
Nama Saya ialah : Michael
No HP : 0812-1212-1212

Ketentuan Deklarasi

Khusus pada bagian penamaan deklarasi, kamu harus tau dan menerapkan sesuai kaidah yang benar. Diantaranya :

• Tiap 1 buah java di dalamnya cuma boleh 1 public class
• Tiap 1 buah java boleh memiliki deklarasi class lain (selain public)
• Penamaan class yang benar senantiasa berawalan huruf kapital, dan berakhiran .java
• Apabila 1 file java tersebut terletak di dalam package, maka deklarasi pertama yaitu penyebutan package name terlebih dahulu.
• Apabila ada import statement, maka deklarasinya hanya boleh sebelum penamaan class sehingga terdata import statement perbaris dengan benar.

Nanti kita bakalan explore lagi seputar inner class dan anonymous class so, sabar yah!

Java Package

Kalau dilihat dari maksud namanya sebenarnya Package itu berarti pengelompokkan. Sehingga jika kita lihat di lokasi file java nya ada di dalam package, maka itu sama saja berada di suatu folder tertentu. Penamaan package sebenarnya dibuat untuk mempermudah pengelompokkan untuk pemanggilan setiap object nya nanti saat akan di calling.

Misalnya bisa kita lihat ini :

Nah dari sini kita bisa lihat bahwa package “com.toy.anagrams.ui” sebenarnya ialah suatu folder yang terangkum (terkelompokkan) dengan rincian :

• Folder ui didalam anagrams
• Folder anagram di dalam toy
• dan toy di dalam com

Import Statement

Dalam penggunaan Import statement pemanggilan suatu class memudahkan compiler agar dapat menggunakan method ataupun variable tertentu yang dibutuhkan. Untuk penulisaannya juga cukup mudah.

/* bagian ini akan menyertakan seluruh class yg terdapat pada package java.io */
import java.io.*;

/* jika ingin specific maka panggil saja */
import java.io.namaSesuatu;

Okay, selesai! Itu dia pembahasan khusus kali ini. Next kita lanjut kembali ke pembahasan yang lebih dalam lagi, seputar Data Type dan penggunannya di salah satu project Java.

Nah, kita mulai dulu dari persiapan pokoknya ya. Asumsikan dulu komputer kamu saat ini minimal memiliki kriteria sebagai berikut:

• Linux 7.1 atau Windows Xp / 7 / 8 / 10
• Java JDK 8.
• Salah satu IDE tools Netbeans / IntellIJ / Eclipse.

Bagi yang belum memiliki JDK segera download dari link diatas. Kemudian lanjutkan instalasi salah satu IDE tools yang disediakan. Cukup install dengan secara default dan next hingga selesai!

Syntax Dasar

Jalankan salah satu dari IDE Tools tersebut, lalu kini kita tuliskan code berikut ini dengan membuat satu buah file ProgramPertama.java:

public class ProgramPertama{

   /* Kita munculkan dulu...
    * Tulisan 'Hello World' sebagai output
    */
   public void cetak() {
      System.out.println("Hello World"); 
   }

   public static void main(String []args) {
      ProgramPertama objek1 = new ProgramPertama();
      objek1.cetak(); 
   }
}

Nah dari sini kita bisa pelajari berbagai hal pokok seperti :

• Object: Sebuah objek yang disebutkan dari ProgramPertama diatas.
• Class: Sebuah template yang menjelaskan konsep pokok dan konten apa saja yang ada di dalamnya.
• Method: Sering kita sebut sebagai suatu aksi / proses. Sebut saja sebuah Class memiliki banyak method. Artinya satu buah kelas mampu melakukan banyak proses. Disana terdapat beberapa code tertentu yang ditulis.
• Instance Variable: Yaitu object unik dari setiap kelas yang dideklarasikan menjadi sebuah variable.

Tapi kita semua perlu ingat beberapa hal pokok yang juga penting untuk diingat setiap kali kita membuat source code dengan algoritma tertentu tidak akan keluar dari :

• Case Sensitivity: setiap besar kecil itu penting, karena tidak boleh diacak ataupun berbeda. Kalau saja berbeda maka program bisa-bisa tidak berjalan dengan baik. Sensitivitas ini didapat serupa seperti halnya C dan juga C++ begitu pula pada Java.

• Naming Convention: untuk penamaan setiap variable lebih baik digunakan huruf awalan kecil, dan kata kedua selanjutnya capital. Begitu seterusnya apabila terdapat 3 kosakata dan lakukan penulisan nama secara menempel atau terpisah dengan underscore. Contohnya begini:

int jenisKendaraan = 0;
int nomorRumah = 18;

Tetapi jangan sampai seperti ini:

int JENIsKendARAAN = 0;
int nomorRUMAH = 18;

Sepintas memang tidak error. Tetapi penggunaan saat penulisan menjadi berpengaruh pada baris lainnya yang menggunakan variable tersebut. Ingat java itu mirip seperti C dan C++ mereka cukup sensitif lho!

• Class Name: untuk pemberian nama Class itu berarti nama program dan harus bermula capital (besar). Kaidah penamaan ini standard dan selalu diterapkan pada setiap blueprint (Class) yang lainnya. Tentu saja tujuannya agar tidak tertukar dengan penamaan variable yang berawalan huruf kecil.

Contohnya seperti ini :

 public class Calculator{
   // nama Calculator ini benar
}
 

Jangan sampai ada diantara kita menuliskan:

 public class mesinCAL_Culator{
   // nama mesinCAL_CULATOR ini tidak sesuai kaidah
}
 

Java Identifier

Ok. Kita anggap kamu sudah mulai mengerti perbedaan diawal dan juga cara penulisannya tadi. Nah sekarang kita lengkapi dengan identifier atau kaidah penulisannya yang terstandard!

Ingat, bahwa setiap penamaan ini disebut sebagai identifier atau kaidahnnya yang sudah teridentifikasi secara benar dan memudahkan untuk developers lainnya yang tergabung dalam tim kita (jika ada). Kalau toh solo, alias single fighter juga tidak jadi masalah, karena kaidah ini cukup umum untuk diketahui diantara kalangan software developer. Seperti apa saja ya di Java identifier nya yang berlaku :

• Penamaan identifier selalu bermula dari huruf (a – z atau A – Z), kemudian bisa juga bermula simbol dollar ($) atau garis bawah -underscore ( _ ).
• Setelah huruf pertama ditulis, maka kita bisa menggabungkan huruf / kata lainnya (menempel).
• Gunakan kata-kata yang diluar daftar keywords java.
• Identifier ini senantiasa sensitif besar kecilnya (case sensitive)
• Contoh yang diperbolehkan : umur, $biaya, _nilaiPertama, _nilaiBaru
• Contoh yang dilarang : 123umur, -biaya, ~-nilaiKedua

Java Modifier

Mirip seperti halnya C dan C++ untuk Java kita juga harus kenal penggunaan modifier Access dan Non-Access. Apa saja ya itu?

• Access Modifier : default, public, protected, private.
• Non-Access Modifier : final, abstract, dan strictfp.

Seperti apa penggunaannya? Akan dibahas nanti saat kita praktek lagi di bab berikutnya, sabar oke?

Java Variable

Dalam Java kita memiliki setidaknya ada 3 macam variable :

• Local Variable
• Class Variable
• Instance Variable

Jenis ini diketahui setelah kita menuliskan beberapa variable dalam sebuah kelas berdasarkan fungsi dan letaknya. Penasaran kan ya? Simak dulu pembahasan selanjutnya.

Java Enums & Arrays

Enums itu diperkenalkan saat Java masih versi 5. Disaat penggunaan Variable dengan Enums maka kita memberikan nilai yang terdefinisi sejak awal. Daftar nilai yang terdefinisi dikenal dengan istilah Enum di Java. Kenapa menggunakan Enum? Tentu saja untuk mempermudah penggunaan nilai agar tidak kebanyakan error nantinya (seperti saat penulisan typo, dan lainnya).

Coba bayangkan begini, saat sebuah aplikasi Toko Jus, ketika ingin membatasi sebuah nilai ukuran gelas, maka kita bisa menggunakan pemberian seperti ini agar pilihan gelas hanya terbatas pada beberapa opsi saja, misalnya perhatikan :

 class TokoJus{
   enum UkuranGelas { KECIL, BESAR, SEDANG }
   UkuranGelas pilihanUkuran;
}

public class Implementasi {

  public static void main(String args[]) {
    TokoJus sample = new TokoJus();
    sample.pilihanUkuran = TokoJus.UkuranGelas.BESAR;
    System.out.println("Anda Memilih : " + sample.pilihanUkuran);
  }

}
 

Tentu saja ketika running maka output nya ialah :

 Anda Memilih : BESAR
 

Ingat baik-baik bahwa kita dapat menyertakan Variable, Constructor, dan juga Method tersendiri dalam setiap penggunaan Enumnya.

Java Keywords

Dalam beberapa penamaan variable, siapapun developers nya harus menggunakan penamaan selain dari kata-kata keywords berikut ini :

abstract	assert	boolean	break
byte	case	catch	char
class	const	continue	default
do	double	else	enum
extends	final	finally	float
for	goto	if	implements
import	instanceof	int	interface
long	native	new	package
private	protected	public	return
short	static	strictfp	super
switch	synchronized	this	throw
throws	transient	try	void
volatile	while

Java Comments

Kadang kala saat kita menuliskan code, maka ada bagian tertentu yang perlu diberikan tanda / catatan / komentar. Nah penggunaan code ini disebut comments yaitu baris tertentu yang akan diabaikan oleh java dan tidak diterima sebagai execution. Mirip seperti comments yang dipakai oleh C dan juga C++, yaitu dengan menuliskan single-line comments ataupun multi-line comments. Seperti apa penggunaannya, lihat source code berikut ini :

 // Kelas Baru
public class ProgramLagi{

   // ini ialah single-line comment

   public static void main(String []args) {

/* Adapun ini yaitu bagian comments multi-line
* Sehingga notes ataupun komentar tertentu bisa dituliskan 
* ke dalam source code tanpa mengganggu alur proses 
* execution nya
*/ 
      System.out.println("Yihui! Keren...!");
   }
}

Dan outputnya tentu saja hanya ini saja :

 Yihui! Keren...!

Penggunaan Baris Kosong

Penggunaan baris kosong atau istilahnya “Blank Lines” memang tidak menjadi pengaruh dalam source code java. Ya tentu saja, baik itu ENTER yang panjang, ataupun SPASI yang panjang, dalam pemrograman Java semua itu akan diabaikan tidak begitu berpengaruh secara signifikan.

Pembahasan Berikutnya

Nah usai sudah pembahasan pada bagian experiment awal ini. Dan nanti di pembahasan selanjutnya kita akan mulai explorasi lagi tentang Object dan juga Class khususnya secara penulisan dan juga konsepnya. Siap melanjutkan penguasaannya? Okay… lanjutkan!

Ok. Selamat datang di bagian pertama untuk menguasai Java Programming! Dengan adanya tutorial yang disediakan disini kamu bakal mudah untuk mempraktekkan pemrograman berbasis java. Dengan begitu setiap problematika yang ingin dituntaskan dengan java dapat terwujudkan secara nyata!

Java itu Apa ya?

Java ialah bahasa pemrograman berbasis Object yang awalnya dulu diperkenalkan oleh Sun Microsystem kemudian diakusisi oleh Oracle dan kini sudah lebih dari 3 milyar dengan berbagai macam jenis hardware menggunakan aplikasi berbasis java. Memang tidak aneh lagi kalau Java sudah merebak kemana-mana baik itu pengembangan aplikasi berbasis desktop, mobile, dan web. Untuk pengguna Linux dan Windows sekarang tidak aneh lagi kan dengan adanya Java programming ini!

Prospek Karir

Apa iya prospek karirnya bergaji dengan nilai tinggi? Well, jangan heran deh! Baik saat pengembangan desktop, web maupun mobile khusus java programmer memiliki demand yg tinggi di pasar kerja. Terlebih lagi proyek tiap yang membutuhkannya. Sebut saja dengan pengalaman 3-5 tahun kini bergaji senilai 10-15 juta dalam sebulan! Waw…. Dan jika tembus pasar luar negeri maka dapat $120,000 dalam setahun…! Tentunya ini sudah tercatat di beberapa perusahaan besar seperti :

• Google
• Microsoft
• Facebook
• IBM
• Amazon
• UBer
• dan lainnya…

Kenapa Harus Belajar Pemrograman Java?

Untuk siapa saja yang ingin berkarir dalam dunia pemrograman atau bahkan setiap programmer yang ingin terlibat dalam pembuatan aplikasi desktop, mobile, juga web sudah pasti harus mempelajari dan menguasai pemrograman berbasis Java.

Dengan bahasa pemgrograman berbasis java proses memahami alur system, dan juga penulisan syntax code menjadi mudah. Oleh sebab itu jangan heran kalau banyak yang lanjut ke Java Programming meskipun sebelumnya memiliki background di C atau C++ Programming. Eh, atau kamu belum mengerti sama sekali apa itu pemrograman? Jangan khawatir, dengan Java kamu bisa melangkah lebih maju & simple, karena :

• Java itu tidak tergantung Platform tertentu
• Java itu memliki komunitas yang sangat besar
• Java itu memliki prospek karir yang bernilai tinggi
• Java itu simple dan mudah dipelajari
• Java juga tetap Open Source

Java Online Compiler

Nah beruntung nih sekarang sudah banyak fitur java online compiler dimana-mana. Satu diantaranya yaitu Aplikasi Java Compiler versi android. Klik disini.

Banyak pula versi web browser lainnya yang bisa diakses oleh berbagai browser seperti Firefox, Chrome dan lainnya. Sehingga penulisan setiap java Code bisa langsung dieksekusi dan didapatkan hasil outputnya! Seperti ini misalnya. Klik disini.

Penerapan Java

Java yang digunakan pada tutorial ini sering dikenal sebagai Java SE (Java Standard Edition). Dengan konsep yang terkenal yaitu Write Once, Run Anywhere, berarti setiap kali kita menuliskan 1 source code dalam Java, maka runningnya bisa diberbagai platform baik Windows, Linux, maupun Mac OS. Ada keunggulan lainnya saat kita menggunakan Java yaitu:

• Dynamic: Ada perbedaan signifikan bagi developers C dan C++ khususnya saat menggunakan java. Karena beberapa informasi run-time sudah dipersingkat, dan juga objectnya telah dipersiapkan lebih pendek sehingga penerapannya lebih dinamis.
• Multithreaded: Jika ada suatu eksekusi program yang simultan maka Multithreaded jawabannya! Dan itu ada di Java juga! Dengan synchronization yang ada maka eksekusi serentak dalam 1 aplikasi menjadikan program lebih interaktif dan lancar.
• Interpreted: Ingat bahwa setiap byte code yang dihasilkan oleh Java ialah native machine instructions. Sehingga proses linking menjadi lebih ringan dan tidak tergantung pada satu kondisi tertentu.
• High Performance: Gunakan saja Just-In-Time compiler, maka mode performa tertinggi bakal terasa!
• Distributed: Karena persebarannya sudah mendukung fasilitas internet, maka distribusinya menjadi lebih cepat.

Peruntukan Tutorial Ini

Beberapa tutorial yang disediakan disini dapat difahami oleh pemula. Sehingga dengan beberapa konsep berikut code yang diberikan pada setiap pembahasan akan membantu memudahkan siapa saja yang ingin mulai mempelajari pemrograman berbasis java. Targetnya tentu saja akan lebih mempermudah ketika masuk kasus nyata dalam proses pengembangan aplikasi real!