admin

Jenis Modifier

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!

Posted in Java ProgrammingTagged , ,