handout: Konsep Kelas dan Obyek dalam Java

Merupakan bahasa pemrograman yang: Object Oriented, interpreted, bebas arsitektur & portabel, dinamis dan terdistribusi, sederhana, robust, aman, high-performance, dan multithreaded.

Object Oriented: Pemrograman berfokus pada obyek; pembuatan program di arahkan pada implementasi data serta metoda untuk memanipulasnya. Model problem adalah kumpulan dari object yang terdefinisi dalam sejumlah class. Java API menyediakan sejumlah package pendukung berisi kumpulan object class yang bisa di-inherit dan di- instance. Sejumlah literatur mengatakan bahwa Java lebih object oriented daripada C++.

Interpreted: Java Compiler menghasilkan bytecode untuk Java Virtual Machine (JVM) agar mencapai platform independence Bytecode dalam JVM di-run oleh Java Interpreter. Beberapa mesin/OS menyediakan just-in-time compiler dari bytecode ke machine code mesin ybs. agar dapat lebih executable (tanpa menggunakan interpreter).

Bebas Arsitektur & Portabel: Dengan byte code dalam JVM maka dapat run di berbagai sistem yang mengim-plementasi JVM: "run anywhere on networks & universal market". Ukuran data type yang konsisten Menjamin agar program bisa dikembangkan secara "pure Java".

Dinamis & Terdistribusi: Class bisa di-load setiap saat memberi dukungan high-level pada networking (URL Class & java.net) di samping low-level (datagram, socket). Berkemampuan class loading secara dinamis (download & run).

Sederhana: Jumlah konstruksi bahasa relatif lebih kecil (beberapa meniru sejumlah konstruksi di C/C++) Menghilangkan hal-hal yang "merepotkan & jarang digunakan". Tidak ada goto, struct, union, operator overloading, multiple inheritance, dan terutama, pointer. Array & string merupakan obyek

Robust: Lingkungan untuk menuliskan S/W yang andal; menghilangkan sejumlah sumber kesalahan pemrogRaman: pemeriksaan saat kompilasi yang ekstensif; deklarasi eksplisit. tidak ada pointer: tidak ada bug akibat kesalahan penggunaan pointer; casting diperiksa saat runtime; garbage collection yang otomatis; exception handling

Aman: Menyediakan beberapa layer of security controls yang melindungi thd. code yang membahayakan: Lowest-level: melarang akses langsung ke memori "sandbox model" layer untuk memblok aktifitas sensitif untrusted code "digital signature" utuk mengidentifikasi trusted/untrusted code.

High-performance: Tidak lebih cepat dari compiled language namun masih cukup untuk aplikasi interaktif, GUI, dan berbasis network (C/C++: highest performance, lowest reliability/portability, semantara UNIX Shell: highest portability, lowest performance). "just in time" compiler dapat mengubah bytecode menjadi real machine code comparable dengan C/C++ menurut Versi Sun.

Multithreaded: Dalam satu aplikasi Java dapat terdefinisi banyak thread untuk menjalankan unit-unit aktifitas proses secara konkuren. Thread dapat lebih mudah didefinisikan dan dikelola dalam proses. Tidak mensupport I/O yang asinkron & non-blocking (thread harus memblok sendiri setiap I/O yang diperlukan)

Pemrograman dengan Bahasa Java

Ada dua modus pemrograman dengan Java

Pemrograman aplikasi yang stand-alone, yaitu program pada level command prompt dengan interpreter java
Pemrograman applet, yaitu menghasilkan class object yang merupakan modul aplikasi yang ditampilkan pada Webpage dan run di atas Java-enable web browser (NN, IE, HotJava)

Contoh Program Aplikasi Java: public class HelloWorld {
   public static void main(String[] args) {
      System.out.println("hello World!");
   }
}

Program ini harus di-save dalam file dengan nama yang sama dengan nama kelas dan berekstensi .java, yaitu HelloWorld.java, lalu di-compile dengan perintah: $ javac HelloWorld.java

Kompilasi ini menghasilkan bytecode yang otomatis disimpan dalam HelloWorld.class. Nama ini sesuai pula dengan nama kelasnya. Kemudian file class ini di-run oleh interpreter java dengan perintah & output: $ java Contoh
Hello World

Contoh Program Applet Java: //Included packages
import java.applet.Applet;
import java.awt.Graphics;

public class HelloWorldApplet extends Applet{

   public void paint (graphics g) {
      g.drawString("Hello World!", 50, 25);
   }
}

Seperti di contoh program aplikasi stand-alone di atas, program applet ini di-save sebagai HelloWorldApplet.java, dan di-compile dengan javac yang menghasilkan menghasilkan bytecode HelloWorldApplet.class.

Setiap applet di-refer dalam HTML dengan sintaks (bagian bergaris bawah menunjukkan harga-harga yang harus diberikan):

Contoh suatu HTML sederhana dengan nama file: coba.html: <title>Hello World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width=250 height=80> </applet>
<hr>

Peragaan saat di-browse, misalnya dengan appletviewer dengan perintah:

$ appletviewer coba.html

Definisi Kelas dan Obyek

Obyek (object): entitas yang memiliki kumpulan dari data serta metoda-metoda (method-method) yang bekerja pada data tsb. Data dan metoda-metoda suatu kelas mendefinisikan isi dan sifat tersebut.
Kelas obyek (object class): (disngkat kelas) mendefinisikan sekumpulan obyek yang memiliki metoda-metoda dan jenis data yang sama; obyek-obyek tersebut didefinisikan secara format dalam kelas atau dengan perkataan lain suatu obyek merupakan instance dari kelas obyeknya.
Metoda: spesifikasi "sifat" dari kelas yang secara formal ditulis dalam bentuk prosedur/fungsi dan metoda in mengkomputasi/beraksi berdasar sejumlah data yang tedapat pada obyek dan/atau argumen yang diberikan serta data lain yang aksesibel oleh obyek tsb.

Contoh Kelas & Obyek
Kelas lingkaran dideskripsikan oleh titik pusatnya, yaitu (x, y) serta jari-jarinya, yaitu r. Beberapa hal bisa diasosiasikan pada lingkaran tersebut, misalnya "berapa kelilingnya", "berapa luasnya", "apakah suatu titik berada di dalamnya" yang masing-masing bisa ditentukan berdasarkan (x, y) dan r. Terdapat obyek lingkaran yang berpusat di (2.0,2.0) dengan jari-jari =1.0 adalah suatu obyek dari kelas Lingkaran, dan keliling & luasnya dapat dihitung dengan perhitungan di atas dan diperoleh keliling 6.28318 dan luas 3.14159

Kelas lingkaran tersebut dalam bahasa Java didefinisikan sbb.

public class Lingkaran {
public double x, y; // ttk pusat
public double r; // jari-jari

   // method yang menghitung kel.& luas
   public double keliling() {
      return 2*3.14159*r;
   }
   public double luas() {
      return 3.14159*r*r;
   }
}

Sebagai instance dari kelasnya, obyek merupakan sesuatu yang perlu di-refer eksistensinya dengan suatu variabel (kita sebut bvariabel referensi).

Lingkaran c = new Lingkaran();
// c variabel referensi merefer obyek
// yang dicreate oleh perintah new
c.x = 2.0; c.y = 2.0; c.r = 1.0;
Lingkaran d; // d variabel referensi
d = c; // c & d merefer ke satu obyek lingkaran
double b = c.luas();
// metoda luas() merupakan sifat yang
// dimiliki obyek yang direfer oleh c

Note: dalam pemrograman non object-oriented (misalnya C) maka luas lingkaran c dihitung oleh prosedur misalnya luas()dan variabel c menjadi argument dalam penghitungannya sbb.

b = fungsiX(a)

Penciptaan Obyek

Saat obyek baru diciptakan, Java menjalankan konstruktor (constructor) untuk dapat menginisialisasi obyek. konstruktor dispesifikasikan sebagai suatu metoda dengan nama yang sama dengan nama kelas. Jika konstruktor tidak dispesifikasikan maka Java menyediakan konstruktor default seperti yang terjadi pada contoh di atas. Definisi kelas Lingkaran tsb. belum ada constructornya maka x,y, dan r perlu diberi harga sendiri setelah obyek di-generate. Contoh kelas Lingkaran diatas di tambahkan sebuah konstruktor: public class Lingkaran {
public double x, y, r; // ttk pusat & jari-jari

   // method constructor
   public Lingkaran(double x,double y,double r) {
      this.x = x; this.y = y; this.r = r;
      // Keyword this untuk mengakses variabel
      // obyek ybs.; bisa dihilangkan jika nama
      // variabel sudah jelas berbeda
   }
   ....
   // method yang menghitung kel.&luas
   ....

Dengan adanya konstruktor ini obyek dicreate bisa dengan harga-harga awalnya dengan cara memberikan argumen yang sesuai dengan yang di spesifikasikan pada metoda konstruktornya. Contoh dari kelas Lingkaran tsb. Lingkaran c = new Lingkaran(2.0, 2.0, 1.0);

Konstruktor dapat dispesifikasikan dalam lebih dari satu cara pemanggilan yang berbeda. Contohnya dalam kelas Lingkaran di atas selain (1) dengan tiga bilangan (x, y, t), didefinisikan juga konstruktor (2) dengan hanya harga r, (3) dengan harga yang dimiliki obyek lingkaran lain, dan (3) tanpa harga argumennya.

public class Lingkaran {
   public double x, y, r;
   public Lingkaran(double x,double y,double r) { // dengan x,y,r
      this.x = x; this.y = y; this.r = r;
   }

   // dari obyek lingkaran lain
   public Lingkaran(Lingkaran c) {
      x = c.x; y = c.y; r = c.r;
   }
   // harga r saja
   public Lingkaran (double r) {
      x = 0; y = 0; this.r = r;
   }
   // tanpa argument
   public Lingkaran () {x = 0; y = 0; r = 0;}

....
}

Agar penulisan lebih kompak maka bisa juga suatu konstruktor memanggil konstruktor lain yang lebih umum memanfaatkan keyword this untuk merefer dirinya sendiri. Untuk kelas Lingkaran di atas bisa ditulis menjadi public class Lingkaran {
   public double x, y, r;
      public Lingkaran(double tx,double ty,double tr) {
      this.x = x; this.y = y; this.r = r;
   }

   public Lingkaran(Lingkaran c) {this(c.x, c.y, c.r);}
   public Lingkaran (double r) {this(0, 0, r);}
   public Lingkaran () {this(0, 0, 0);}
   ....
}

Obyek dapat diciptakan dengan salah satu metoda konstruktor di atas Lingkaran c1 = new Lingkaran();
// konstruktor menginisialisasi x,y,r = 0, 0, 0
Lingkaran c2 = new Lingkaran(10, 20, 25);
// konstruktor menginisialisasi x,y,r = 10, 20, 25
Lingkaran c3 = new Lingkaran(c2);
// konstruktor menginisialisasi x,y,r = 10, 20, 25
Lingkaran c4 = new Lingkaran(25);
// konstruktor menginisialisasi x,y,r = 0, 0, 25

Bagaima Java melakukannya? Java akan mengenalinya berdasarkan jumlah & ragam dari argumen! Jadi jangan membuat dua konstruktor dengan jumlah dan jenis argumen yang sama.

Bukan hanya konstruktor, setiap metoda dapat dispesifikasikan dalam beberapa cara yang berbeda (di-overload) metoda melakukan fungsi yang sama berdasarkan argumen yang berbeda Java akan mengenalinya dari jumlah dan ragam argumen seperti di atas. Pendefinisian metoda demikian disebut method overloading.

Variabel Kelas (Static Variable)

Jika variabel obyek (instance variable) membawa harga yang berlaku hanya pada obyek itu saja, misalnya x, y, r dalam kelas Lingkaran bisa berbeda dari satu obyek ke obyek lain, maka Variabel Kelas (Class Variable) membawa harga yang berlaku untuk setiap obyek dari kelas tersebut. Variabel Kelas disebut juga Static Varible karena menggunakan keyword static. Contoh Variabel Kelas public class Lingkaran {
   static int jmlLingkaran = 0;
   public double x, y, r;
   public Lingkaran(double x, double y, double r){
      this.x = x; this.y = y; this.r = r;
      jmlLingkaran++;
   }
   public Lingkaran(Lingkaran L){
      this(L.x,L.y,L.r);}
   public Lingkaran(double r){this(0,0,r);}
   public Lingkaran(){this(0,0,0);}
   .... Jika variabel Obyek diakses melalui nama variabel yang me-refer-nya maka variabel kelas diakses melalui nama kelasnya System.out.println("Jari-jari: " + c1.r);
// r adalah variabel obyek
System.out.println("Sudah ada: " + Lingkaran.jmlLingkaran+" lingkaran");
// jml_lingkaran adalah variabel kelas

Metoda Kelas (Class method)

Metoda Kelas (disebut juga Static Method) adalah metoda yang dimiliki oleh kelas tanpa memperhatikan ada/tidaknya obyek dari kelas tersebut. Biasanya untuk fungsi-fungsi library. Metoda kelas diakses melalui nama kelasnya bukan dari obyeknya. Contohnya pemanggilan Math.sqrt() dalam coding berikut ini adalah memanggil mtoda sqrt() dalam kelas Math.

public class Lingkaran {
   public double x, y, r;
   public boolean diDalam(double a, double b){
   double dx = a - x; double dy = b - y;
      double jarak = Math.sqrt(dx*dx + dy*dy);
      if (jarak < r) return true;
      else return false;
   }
   ....
}

Note: Kelas Math merupakan library yang berisikan banyak metoda penghitungan matematika.

Hal yang penting diingat bahwa definisi metoda kelas tidak bisa menggunakan referensi implisit this di dalamnya (mengapa? Karena bukan milik obyek dan this adalah alias dari obyek ybs.!). Berikut ini ada dua metoda dalam kelas Lingkaran tapi yang satu adalah metoda obyek ("manakah yang lebih besar antara apakah suatu Lingkaran tertentu dengan dirinya") dan yang kedua adalah metoda kelas ("manakah yang lebih besar antara suatu lingkaran dengan Lingkaran lain"). public class Lingkaran {
   public double x, y, r;
   public Lingkaran lbhBesar(Lingkaran c){
      if (c.r > this.r) return c; else return this;
   }
   public static Lingkaran lbhBesar(Lingkaran a,
      Lingkaran b){
      if (a.r > b.r) return a; else return b;
   }
   ....
}

Selain dengan konstruktor variabel obyek dapat dapat diinisialisasi dengan assignment pada bagian deklarasinya:

double r = 1.0;

Sementara untuk menginisialisasi suatu Variabel Kelas kita tidak bisa menggunakan konstruktor tapi dapat dilakukan dengan static initializer. Static initializer dijalankan saat kelas pertama kali diakses/di-load. Deklarasi Static initializer tidak perlu nama, argumen, dan return value. Contoh Static Initializer

Static initializer sederhana

static int jml_lingkaran = 0;

Static initializer yang lebih kompleks

public class circle {
   static private double sinusTbl[]=new double[180];
   static {
      double x;
      for (int i=0; i < 180; i++)
         sinusTbl[i] = Math.sin(i*3.14159/180);
   }
   ....
}

Penghapusan Obyek

Suatu obyek yang mengalokasi resource memori yang sudah tidak di-refer oleh siapapun akan dihapuskan sendiri oleh Java agar memori bisa direalokasi! Garbabe collection tsb. dilakukan secara background sementara proses berjalan. Jika dikehendaki maka penghapusan suatu obyek dapat dipercepat dengan memberi null pada variabel yang me-refer-nya.

Untuk obyek yang mengalokasi resource lain, penghapusan dinyatakan oleh metoda finalizer baru kemudian Java melakukan garbage collection. Contoh resource: file descriptor, socket. Note: finalizer adalah metoda obyek tanpa argumen.

Subclass dan Inheritance

Suatu kelas obyek baru yang memiliki sifat suatu kelas K yang sudah ada plus sejumlah sifat tambahan dapat didefinisikan sebagai kelas anak dari K.
Contoh: kelas LingkaranGrafis memiliki sifat-sifat kelas Lingkaran, tetapi juga memiliki metoda untuk penggambaran grafis.

"Pewarisan" sifat ini dilakukan dengan class extention (notasi extends)

Contoh TANPA Inheritance. Didefinisikan suatu kelas LingkaranGrafis yang meniru sifat-sifat Lingkaran dengan membuat obyek Lingkaran di dalamnya di tambah beberapa sifat baru.

public class LingkaranGrafis {
   double x,y,r;
   public lingkaran c;
   public double luas(} {
      return c.luas();
   }
   public double keliling() {
      return c.keliling();
   }
   // variabel/metoda yang baru
   public Color outline, fill;
   public void gambarkan(DrawWindow dw) {
      ....
   }
   ....
}

Contoh: DENGAN Inheritance.

public class LingkaranGrafis extends Lingkaran {
   public Color outline, fill;
   public void gambarkan(DrawWindow dw) {
      ...
   }
   ...
}

Kelas Final (Final Class) adalah kelas yang tidak dapat di-inherit lagi (dpl. tidak dapat dibuat subclass-nya). Deklarasi kelas final adalah dengan menambahkan keyword final sebelum nama kelasnya.Tujuan dengan spesifikasi ini agar compiler dapat mengoptimasikan pemanggilan kelas.

Setiap kelas selalu memiliki superclass-nya kecuali kelas Object yang merupakan superclass dari setiap kelas dalam Java (termasuk Java API). Metoda-metoda kelas Object dapat dipanggil oleh setiap obyek Java. Jika suatu kelas tidak didefinisikan dengan extends maka kelas tersebut memiliki superclass langsung Object.

Suatu kelas dapat memanfaatkan konstruktor dari super class-nya dengan prefiks keyword super (mengganti nama superclass).

public class LingkaranGrafis extends Lingkaran {
   public Color outline, fill;
   ....
   Public LingkaranGrafis(double x, double y,
   double r, Color outine, Color fill) {
      super(x,y,r);
      this.outline = outline;
      this.fill = fill;
   }
   ....
}

Pemanggilan konstruktor superclass tersebut dibatasi untuk hanya dilakukan dalam konstruktor class ybs. dan harus muncul sebagai statement pertama (setelah tanda { ). Pemanggilan tsb. bahkan diperlukan jika data yang diakses bersifat private (akan dibicarakan nanti).
Secara default saat suatu obyek diciptakan, Java akan menjalankan konstruktor-nya, serta konstruktor dari setiap superclass-nya.Urutannya adalah mulai dari konstruktor kelas obyek paling atas (Object) ke kelas obyek ybs.
Contoh: Saat obyek LingkaranGrafis diciptakan, Java menjalankan konstr. Object, lalu konstr. Lingkaran, dan baru kemudian konstr. LingkaranGrafis.
Apabila dalam kelas obyek tsb. tidak mendefinisikan konstruktor maka Java akan membuatkan konstruktor default-nya yang bersifat public. Jika pada LingkaranGrafis tidak ada konstr. maka seolah-olah Java menambahkan baris:
public LingkaranGrafis() { super(); }
Note: Tetapi jika superclass-nya juga tidak memiliki konstruktor maka akan terjadi compiler error!
Jika konstruktor didefinisikan dengan

keyword public: semua kelas lain bisa mengaksesnya

keyword protected: hanya subclass-nya yang bisa mengaksesnya

keyword private: tidak ada kelas lain yang bisa mengaksesnya

Jika tidak mau bersifat public, maka hindari konstr. default dengan mendefinisikanya!
Apakah juga hal yang terjadi pada konstruktor, terjadi pula pada finalizer? TIDAK! Apabila obyek dari suatu kelas hendak di hapuskan dengan memanggil finalizer-nya, dan jika superclass-nya juga memiliki finalizer, maka finalizer superclass ini pun harus dipanggil juga membentuk rantai perintah finalizer.
Jika terdefinisi suatu variabel dalam suatu kelas yang bernama sama dengan variabel. yang ada dalam superclass-nya, bagaimanakah hubungannya? Keduanya berbeda! Variabel tersebut disebut shadowed variable. Untuk dapat membedakannya maka perlu diberikan identitas "pemiliknya", yaitu miliknya dengan referensi keyword this (misalnya variable x,ditulis this.x) dan milik superclass dengan referensi keyword super (misalnya variable x,ditulis super.x) atau dengan cara casting (Misalnya nama kelas superclassnya adalah Y, casting ditulis((Y) this).x).
Contoh: Jika C subclass dari B, Bsubclass dari A, x adalah var. shadowed var. x di B, dan juga var. x di A
// semua code ini dalam metoda di kelas C
x // variabel x dalam kelas C
this.x // variabel x dalam kelas C
super.x // variabel x dalam kelas B
((B) this).x // variabel x dalam kelas B
((A) this).x // variabel x dalam kelas A
// super.super.x tidak boleh digunakan
Dalam hal metoda, jika mendefinisikan ulang suatu metoda yang muncul di superclass di dalamkelasybs. maka yang terjadi adalah overriding. Perbedaannya adalah bahwa yang berlaku adalah metoda kelas dari obyek tersebut (walaupun melalui casting!).
Contoh: jika dibentuk subclass Elips dari Lingkaran maka metoda luas dan keliling dari Lingkaran perlu di-overrriding sesuai dengan sifat kelas Elips
Jika suatu etoda mendapat prefiks keyword final, maka metoda tersebut tidak dapat di-overriden (note: demikian halnya metoda static dan private tidak bisa di-overriden, mengapa?)
Jika kita menganggap bahwa suatu metoda tidak akan dioverrid lagi maka kita perlu mendefinisikannya final guna memungkinkan compiler melakukan optimisasi. Penjelasannya adalah berkaitan dengan mekanisme Dynamic Method Lookup (DML) yang dilakukan Java sebagai berikut.
Karena adanya metoda/variabel yang bisa ter-overriden dalam suatu "keluarga" (kelas + semua subclass-nya) maka interpreter-lah yang bertugas mengidentifikasi metoda yang sebenarnya (bukan compiler!) pada saat run dengan DML. Sementara suatu akses pada metoda final dilakukan secara langsung, akses metoda biasa yang dilakukan melalui DML pasti menjadi lebih lambat .
Method overriding dan variable shadowing berbeda secara konseptual, namun sintaks Java untuk memanggilnya sama. Yaitu menggunakan keyword super.

class A {
   int i = 1;
   int f() { return i;}
}
class B extends A {
   int i;
   int f() { i = super.i + 1; return super.f() + i;}
}
Sebelumnya sudah disinggung bahwa metoda finalize superclass tidak otomatis dipanggil seperti halnya pada konstruktor, jadi perlu terjadi rantai rinalizer. Namun tidak dijelaskan mengapa itu perlu dilakukan. Pendefinisian metoda finalize dalam suatu kelas di mana dalam superclass-nya sudah terdefinisi metoda finalize juga maka terjadi overriding metoda tsb.
Finalizer milik superclass harus dipanggil di baris terakhir dari metoda finalizer tsb.:

super.finalize()

Penyembunyian Data & Encapsulation
Penyembunyain data dilakukan untuk menyembunyikan rincian implementasi internal dengan tujuan:

melindungi kelas terhadap kesalahan yang tak disengaja atau memang disengaja

modularitas pengembangan perangkat lunak

penulisan program yang elegance

memudahkan dokumentasi

Data atau metoda dapat diakses atau tersembunyi dengan mendeklarasikan ragam data atau metoda tersebut dengan keyword-keyword sbb.:

public: Setiap metoda kelas apa saja dan dalam package mana saja dapat mengaksesnya

private: Hanya metoda di dalam kelas yang sama yang bisa mengaksesnya

protected: Dapat diakses dari semua metoda di dalam subclass-nya serta kelas-kelas dalam package yang sama

package: Metoda-metoda di dalam kelas-kelas dengan package yang sama dapat mengaksesnya

Sebaiknya ragam public digunakan untuk metoda-metoda dan konstanta-konstanta yang bagian dari API publik dari kelas. Data yang paling penting atau paling sering digunakan boleh dinyatakan public (tapi biasanya itu di-non- public-kan & dienkapsulasi dalan metoda akses yang public).
Ragam private digunakan untuk data yang sangat terkait untuk kepentingan metoda di dalam kelas itu saja. Package: kelompok kelas yang ditempatkan dalam satu berkas; idealnya kelas-kelas dalam satu package berelasi dan kooperatif satu dengan lainnya
Ringkasan Visibilitas

Visibilitas untuk public protected package private

Kelas yang sama ya ya ya ya

Kelas dalam package yang sama untuk ya ya ya tidak

Subclass dalam package yang berbeda ya ya tidak tidak

Bukan subclass dan berada dl package lain ya tidak tidak tidak

Contoh Kasus: dari kelas Lingkaran sebelumnya (x,y,r) visibel untuk subclass/kelas kooperatif karena secara logis subclass bisa perlu mengaksesnya langsung. Bagi kelas obyek lain secara umum maka perlu disediakan metoda public yang dapat memodifikasinya variabel-variabel tersebut sambil dapat mevalidasi harganya.
Contoh Metoda-metoda Akses

package shapes;
public class Lingkaran {
   protected double x,y;
   protected double r;
   private static final double MAXR = 100.0;
   private boolean cekjarijari(double r) {
      return (r <= MAXR); }
   public Lingkaran(double x, double y,
      double r) {
      this.x = x; this.y =y;
      if (cekjarijari(r)) this.r = r;
      else this.r = MAXR;
   }
   public Lingkaran(double r) {
      this(0.0, 0.0, r); }
   public Lingkaran() {
      this(0.0, 0.0, 0.0); }
   public void moveto(double x, double y) {
      this.x = x; this.y = y; }
   public void move(double dx, double dy) {
      x += dx; y += dy; }
   public void setRadius(double r){
      this.r = (cekjarijari(r))?r:MAXR; }
   public final double getX() {
      return x;}
   public final double getY() {
      return y;}
   public final double getRadius() {
      return r;}
}

Kelas Abstraks dan Interface
Kelas abstraks maupun interface digunakan untuk mendefinisikan suatu kelas secara umum dimana kelak akan dibentuk sejumlah subclass yang melakukan metoda dengan cara yang berbeda (walaupun namanya sama!). Jadi kelas abstraks digunakan untuk men-generalisasi sejumlah kelas yang sifatnya mirip namun implementasinya berbeda.
Di dalam definisinya kelas abstraks maupun interface hanya berisikan nama-nama metoda tsb. oleh karena itu kelas abstraks tidak dapat diinstansiasi (diciptakan obyeknya) tapi instans dari subclass-nya (untuk kelas abstraks) atau kelas implementasinya (untuk antarmuka) dapat diperlakukan sebagai instans-nya.
Mengingat hanya bisa satu superclass yang diekstend dalam suatu kelas (ini khusus dalam bahasa Java) maka interface digunakan untuk mengakomodasikan "multiple inheritance" mendampingi superclass.
Berikut ini beberapa perbedaan kelas abstraks dengan interface.

Deklarasi: interface menggunakan keyword interface sedangkan kelas abstraks menggunakan keyword abstract

Sintaks: Kelas abstraks "di-inherit" (dgn. keyword extends) sedangan interface "diimplementasikan" (dgn. keyword implements)

Inheritance/implementasi: Kelas abstraks adalah kelas dan sebagai superclass hanya boleh single inheritance, sementara interface bukan kelas, jadi bisa multiple interface

Kelas Abstraks didefinisikan untuk hanya berisi sejumlah memiliki metoda abstraks (Metoda abstraks didefinisikan: metoda yang dideklarasikan dengan keyword abstract serta tanpa implementasi). Subclass dari suatu kelas abstraks adalah juga kelas abstraks apabila metoda abstraks-nya tidak diimplementasikan (jadi hanya di-inherit dan ditambah metoda-metoda abstraks lainnya). Variabel referensi suatu kelas abstraks dapat digunakan untuk merefer obyek dari kelas turunannya.
Contoh Pendefinisian Kelas Abstraks
Kelas-kelas yang mirip adalah Bujursangkar, Persegipanjang, Lingkaran, Ellips, Segitiga dan sifat-sifat yang mirip: memiliki luas, dan keliling, namun implementasi masing-masing berbeda. Maka, kelas abstraks akan didefinisikan: kelas Bentuk.
public abstract class Bentuk {
   public abstract double luas();
   public abstract double keliling();
}
Contoh Subclass dari Kelas Abstraks
public class Lingkaran extends Bentuk {
   ....
   public double luas(){ return PI*r*r; }
   public double keliling(){return 2*PI*r; }
}
public class Bujursangkar extends Bentuk {
   ....
   public double luas(){ return s*s; }
   public double keliling(){return 4*s; }
}
public class Persegipanjang extends Bentuk {
   ....
}
public class Ellips extends Bentuk {
   ....
}
public class Segitiga extends Bentuk {
   ....
}

Contoh Obyek Kelas Abstraks
Obyek-obyek turunan Bentuk bisa mengambil sifat dari subclass-subclass tersebut:
Bentuk [] B = new Bentuk[3];
B[0] = new Lingkaran(2.0);
B[1] = new BujurSangkar(1.0);
B[2] = new SegiEmpat(4.0, 2.0);
double total_luas = 0;
for (int i; i < B.length; i++) {
   total_luas += B[i].luas();
}
Interface didefinisikan dengan sejumlah nama metoda yang kelak harus dirinci oleh kelas obyek yang didefinisikan mengimplementasikannya. Suatu kelas dapat mengimplementasikan kebih dari satu inteface dan hal ini memungkinkan multiple inheritance. Karena bukan kelas jelas interface tidak bisa diinstansiasi tetapi suatu didefinisikan suatu variabel referensi dari interface tsb. dan variabel ini dapat digunakan untuk merefer obyek dari kelas yang mengimplementasikannya..
Dalam antarmuka selain didefinisikan metoda-metoda kosong (belum diimplementasi), dapat juga didefinisikan konstanta yaitu sebagai static var. dan final var. yang apabila diakses perlu dengan prefiks nama antarmukanya di depan konstanta tsb. (mirip variabel kelas).
Seperti halnya subclass, sub-antarmuka dapat juga diturunkan dari suatu antarmuka dengan penambahan metoda abstraks & konstanta lain.
Contoh Antarmuka
Dari contoh kelas abstraks akan dibuat subclass yang meng-inherit sifat luas & keliling dari masing-masing kelas: GbrlLingkaran, GbrBujurSangkar, GbrPersegiPanjang, GbrSegiTiga, dan GbrEllips. Pada kelas-kelas baru tsb. terdapat metoda-metoda-metoda lainnya yang mirip: setWarna, setPosisi, gambarkan. Dibuat antarmuka Gambar untuk ketiga metoda tsb.
public interface Gambar {
   public void setWarna(Color c);
   public void setPosisi(double x, double y);
   public void gambarkan(DrawWindow dw);
}
Implementasinya dalam Gambarlingkaran
public class Gambarlingkaran extends
Lingkaran implements Gambar {
   ....
   public GbrLingkaran(double x, double y,
      double c) { super(x,y,r); }
      ....
   Public void setWarna(color c) {
      this.c = c; }
   public void setPosisi(double x, double c) {
      this.x = x; this.y = y; }
   public void gambarkan(DrawWindow dw) {
      dw.drawCircle(x, y, r, c); }
}

Pada implementasi berganda (lebih dari satu interface yang akan diimplementasikan) maka nama-nama Interface ditulis setelah keyword implementsdan dipisahkan dengan koma.
Contoh:
Dibentuk kelas baru yang memiliki sifat Skala (Skala sebagai antarmuka)
public class SkalaGbrLingkaran extends GbrLingkaran implements Gambar, Skala {
   ....
}

Contoh Obyek dari Kelas Abstraks & Antarmuka

Bentuk[] b = new Bentuk[3];
Gambar[] g = new Gambar[3];
GbrLingkaran gli = new GbrLingkaran(0,0,5);
GbrSegiEmpat gse = new GbrSegiEmpat(10,20);
GbrBujurSangkar gbs = new GbrBujurSangkar(15);
b[0] = gli; g[0] = gli;
b[1] = gse; g[1] = gse;
b[2] = gbs; g[2] = gbs;
double luas_total = 0;
for (int i; i< b.length; i++){
   luas_total += b[i].luas;
   g[i].gambarkan(draw_window);
}

Handout berikutnya, sebelumnya, atau kembali ke halaman utama

Visibilitas untuk	public	protected	package	private
Kelas yang sama	ya	ya	ya	ya
Kelas dalam package yang sama untuk	ya	ya	ya	tidak
Subclass dalam package yang berbeda	ya	ya	tidak	tidak
Bukan subclass dan berada dl package lain	ya	tidak	tidak	tidak

Bahan

Daftar Isi

Bahasa Java dan Perkembangannya

Konsep Umum Bahasa Java