Kalian semua tentu sudah mengenal Java class kan ? Sekarang saya ingin mengajak kalian semua untuk mengenal Java class lebih dalam lagi.😀

Sebelum saya membahas hal2 yang lebih dalam, terlebih dahulu saya akan memberikan beberapa aturan mengenai deklarasi source file.

  • Untuk sebuah file source code ( file yang berekstensi .java), class utamanya haruslah bersifat public atau dikosongkan (tanpa Access modifier).
  • Sebuah file source code hanya boleh memiliki 1 public class.
  • Berbagai comment bisa muncul di mana aja. (dengan menggunakan tanda // untuk single line comment atau tanda /* */ untuk multiple line comment).
  • Nama file source code harus sama dengan nama public class yang terletak di file tersebut. Misalnya saya mendeklarasikan public class Belajar{ }, maka nama file source codenya harus Belajar.java.
  • Statement package harus terletak di baris pertama dalam suatu file source code.
  • Statement import harus terletak di bawah statement package.

Berikutnya dalam mendeklarasi suatu class (class utama/ top class), terdapat 5 modifier yang dapat digunakan. Kelima modifier dikelompokkan menjadi 2 kategori yaitu :

  1. Access modifiers. Terdiri dari default (dikosongkan) dan public.
  2. Non-access modifiers. Terdiri dari  final ,abstract, dan strictfp.

Sampai disini, mungkin ada yang bertanya-tanya dalam hati “setahu saya access modifiers ada 4, ada lagi protected dan private“. Ya, anda benar. Tapi itu digunakan untuk members. Apakah yang dimaksud members? Sabar ya, pasti akan saya jelaskan di tulisan berikutnya.😀

Sekarang saya akan menjelaskan dan memberikan contoh untuk menjelaskan kelima class modifier tersebut.

  1. Default (dikosongkan). Coba perhatikan source code berikut, pertama buat class Data di package com.maniakjava.DefaultClass. Contohnya seperti ini :
 package com.maniakjava.DefaultClass;

class Data// perhatikan modifier class ini adalah default
{
   int x;

   int getX() {
      return x;
   }

   void setX(int x) {
      this.x = x;
   }
}

Kemudian buat lagi sebuah class Main yang berada di package yang sama.

 package com.maniakjava.DefaultClass;

class Main
{
   public static void main(String[] args)
   {
      Data obj = new Data();
      obj.setX(30);
      System.out.println(obj.getX());
   }
}

Jika kedua source code di atas dijalankan tentu tidak akan error dan menghasilkan output : 30.
Lalu sekarang cobalah membuat sebuah class baru di package yang berbeda. Sebagai contoh :

package com.maniakjava.ClassBaru;

import com.maniakjava.DefaultClass.Data;

class Main2
{
   public static void main(String[] args)
   {
      System.out.println("Hello");
   }
}

Cobalah jalankan source code di atas, kalian akan mendapat pesan error : ” Uncompilable source code – com.maniakjava.DefaultClass.Data is not public in com.maniakjava.DefaultClass; cannot be accessed from outside package

Sudah mengerti kan apa fungsi dari default modifier ? Dengan menggunakan default modifier, maka class tersebut hanya bisa diakses oleh class 2 lainnya yang berada di package yang sama.

  1. Public. Untuk mengetahui lebih jelas kegunaan public modifier, sekarang cobalah ubah source code yang pertama menjadi seperti ini :
     package com.maniakjava.DefaultClass;
    public class Data// perhatikan modifier class ini adalah public
    {
       int x;
    
       int getX() {
          return x;
       }
    
       void setX(int x) {
          this.x = x;
       }
    }
    

    Lalu jalankan kembali class Main2 di atas, maka sudah tidak akan ada error lagi alias class Data sudah bisa diakses oleh class yang berada di package yang berbeda. Jadi fungsi public modifier adalah untuk membuat suatu class bisa diakses dari package manapun.

  2. Final. Dengan menggunakan keyword final di depan nama class, maka suatu final class tidak akan bisa lagi diturunkan ke kelas2lainnya. Sebagai contoh ubah source di atas menjadi seperti ini :
     package com.maniakjava.DefaultClass;
    final class Data// perhatikan modifier class ini adalah final
    {
       int x;
    
       int getX() {
          return x;
       }
    
       void setX(int x) {
          this.x = x;
       }
    }
    

    Lalu ubah source code kedua menjadi seperti ini :

     package com.maniakjava.DefaultClass;
    
    class Main extends Data
    {
       public static void main(String[] args)
       {
          System.out.println("Hello World");
       }
    }
    

    Kemudian jalankanlah class Main di atas, maka kalian akan mendapat error : ” java.lang.VerifyError: Cannot inherit from final class “. Pada prakteknya, saya sendiri tidak pernah menggunakan final class. Saya lebih sering menggunakan final method atau final variable.

  3. Abstract. Kita tidak akan pernah bisa membuat objek dari suatu abstract class. Abstract class hanya bisa diturunkan / extends ke class lainnya. Sebagai contoh liat code berikut ini :
     package com.maniakjava.DefaultClass;
    abstract class Data
    {
       int x;
       abstract void fungsiAbstract(String kal);
       void fungsiBiasa()
       {
          System.out.println("ini fungsi biasa");
       }
    }
    

    Code di atas adalah berupa abstract class yang terdiri dari 1 variable biasa, 1 method biasa dan 1 abstract method. Yang perlu diperhatikan adalah jika terdapat abstract method, maka classnya juga harus berupa abstract class. Sekarang kita akan membuat suatu class yang akan meng-extends abstract class di atas.

     package com.maniakjava.DefaultClass;
    
    class Main extends Data
    {
       void fungsiAbstract(String kal)
       {
          System.out.println(kal);
       }
    
       public static void main(String[] args)
       {
          Main obj = new Main();
          obj.fungsiAbstract("testing abstract");
          obj.fungsiBiasa();
          obj.x=4;
          System.out.println(obj.x);
       }
    }
    

    class Main di atas merupakan turunan dari class Data ( yang merupakan abstract class ), maka class Main wajib mengimplementasi semua abstract method yang ada di class Data.  Lalu apa perbedaan interface dengan abstract class, bukankah keduanya memiliki fungsi yang hampir sama ? Ya memang benar, namun ada perbedaan di antara keduanya. Silahkan baca di Perbedaan abstract class dan interface di Java untuk mengetahui perbedaanya.

  1. Strictfp. Yang perlu diketahui, modifier strictfp hanya bisa digunakan pada class dan method saja. Strictfp tidak bisa digunakan di variable. Dengan menggunakan modifier strictfp, maka class tersebut akan memenuhi standar IEEE 754 tentang aturan floating-point.
Comments
  1. […] Deklarasi Java class dan java class modifiers […]

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s