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!
