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.