ABSTRACT CLASS, INTERFACE, INNER CLASS
- Abstract Class
Class Abstrak tidak berbeda dengan
class – class lainnya yaitu memiliki class members (method dan variabel).
Sebuah class adalah abstrak jika salah satu methodnya dideklarasikan abstrak.
Method abstrak adalah method yang tidak memiliki implementasi.
Contoh
deklarasi method abstrak:
abstract
public void cetak();
Beberapa hal
yang perlu diperhatikan adalah sebagai berikut:
- Class abstrak tidak dapat dibuatkan instan atau objeknya menggunakan keyword new.
- Sebuah class dapat dideklarasikan sebagai class abstrak walaupun tidak memiliki method abstrak.
- Variabel dengan tipe class abstrak tetap bisa diciptakan, tetapi harus refer ke subclass dari class abtrak tersebut yang tentunya tidak abstrak.
Perhatikan
contoh class abstrak di bawah ini.
abstrak public class Mobil {
public void injakPedalGas();
public void injakRem(){
System.out.println(“Mobil berhenti!”);
}
}
public class Kijang extends Mobil{
public void injakPedalGas(){
System.out.println("Mobil Melaju dengan kecepatan 80 Km/jam...");
}
}
public class BMW extends Mobil {
public void injakPedalGas(){
System.out.println("Mobil Melaju dengan kecepatan 100 Km/jam...");
}
}
Objek class abtrak tidak dapat diciptakan menggunakan keyword new secara langsung. Apabila kita terpaksa ingin menciptakan object class abtrak tanpa membuat subclass kongkritnya, maka kita harus mengimplementasikan method – method abstraknya secara langsung saat deklarasi. Perhatikan contoh di bawah ini.
public class TestMobil {
public static void main(String[] args){
Mobil mobil = new Mobil(){
public void injakPedalGas(){
System.out.println("Mobil berjalan...");
}
};
Kijang kijang = new Kijang();
Escudo escudo = new Escudo();
BMW bmw = new BMW();
mobil.injakPedalGas();
mobil = kijang;
mobil.injakPedalGas();
mobil = escudo;
mobil.injakPedalGas();
mobil = bmw;
mobil.injakPedalGas();
}
}
2. Interface
Interface adalah suatu kelas yang berisi method-method tanpa implementasi , namun tanpa modifier abstract, apabila suatu interface ,apabila suatu interface memiliki
atribut, maka atributnya akan berlaku sebagai konstanta. Interface
menyerupai kelas. perbedaanya, kata kunci interface menggantikan
kedudukan kata kunci class
Berikut ini
adalah aturan yang harus dingat tentang pendeklarasian interface:
- Modifier yang digunakan hanya public atau tidak sama sekali. Jika tidak menggunakan modifier maka interface tersebut hanya dapat diakses dalam package yang sama.
- Semua variabel yang dideklarasikan dalam interface secara otomatis adalah static final. Karena itu waktu pendeklarasian harus diberikan nilai.
- Semua method adalah abstrak. Bedanya dengan class abstrak adalah kita tidak perlu menuliskan keyword abstract pada saat mendeklarasikan method dalam interface.
- Kita dapat mengimplementasikan lebih dari satu interface (multiple inheritance) dengan memisahkan nama dari setiap interface dengan tanda koma.
- Dapat terjadi saat kita mengimplementasikan lebih dari satu interface ternyata interface – interface tersebut memiliki method yang sama. Dalam hal ini method yang akan diimplementasi adalah method yang berada pada posisi pertama.
- Semua method yang diimplemetasikan harus public.
- Jika kita tidak mengimplementasikan semua method yang ada pada interface, maka class tersebut harus dideklarasikan sebagai abstract class.
Pembuatan
Interface sebenarnya mirip dengan pembuatan sebuah class. Pada saat kita menggunakan kata kunci class, tetapi jika Interface, kata kunci yang
digunakan adalah interface.
tingkat_akses
interface nama_interface{
type-kembalian
nama_method1(daftar-parameter);
type-kembalian
nama_method2(daftar-parameter);
........
type-kembalian
nama_methodN(daftar-parameter);
type
variable final1 = nilai;
type
variable final2 = nilai;
.......
type
variable finalN = nilai;
}
Di sini tingkat_akses
dapat diisi dengan public atau tidak. Apabila tingkat_akses tidak
disertakan, maka interface yang didefinisikan tersebut hanya dapat dikenal
sebagai kelas maupun interface-interface lain yang terdapat pada satu paket
yang sama. Tetapi dideklarasikan public, maka class dan
interface-interface yang terdapat pada paket lain juga dapat mengenalinya.
Berikut
merupakan contoh interface sederhana dengan 3 method.
Interface
alat_musik{
void
mainkan( ); //secara
otomatis bersifat public
void
stelNada( );
String
ambilNama( );
}
3. Inner Class
Inner
class adalah suatu class yang berada di dalam class lainnya.
Ada 4 jenis inner class, yaitu :
1. “Regular” Inner class
2. Method-local inner class
3. Anonymous inner class
4. Static nested classes
1. “Regular” Inner class
- Kata “Regular” di atas memiliki maksud bahwa inner class yang dibahas di sini adalah inner class yang bukan static / method-local / anonymous.
- Inner class didefinisikan (ditulis) di dalam kurung kurawal dari outer class.
- Bila ada kode java sebagai berikut :
Program 01
|
class MyOuter {
class
MyInner {
}
}
|
Dan kemudian
dicompile dengan perintah :
%java
MyOuter.java
Maka akan tercipta 2 buah file
.class, yaitu : MyOuter.class dan MyOuter$MyInner.class.
- Instance inner class memiliki akses ke semua member dari outer class (termasuk member outer class yang ber access modifier private).
Contoh :
Program 02
|
class A {
private int x = 101;
class B {
void
lakukanSesuatu() {
System.out.print("x = " + x);
}
}
}
public class BelajarInnerClass02 {
public static void main(String[]
args) {
A a = new
A();
A.B b =
a.new B();
b.lakukanSesuatu();
}
}
|
- Sebuah inner class tidak dapat memiliki member static.
Contoh :
Program 03
|
class A {
class B {
static
int a = 10; //error!!!
}
}
|
- Untuk membuat instance dari inner class, kita harus memiliki instance dari outer class terlebih dahulu. Tidak ada pengecualisan untuk aturan ini.
- Untuk membuat instance dari inner class, terdapat 2 cara, yaitu :
1. Dari dalam outer class
2. Dari luar outer class
·
Contoh
membuat instance inner class dari dalam outer class :
Program 04
|
class A {
void buatInstanceKelasB() {
B b =
new B();
}
class B {
}
}
|
Dari contoh di atas, untuk dapat
menjalankan method buatInstanceKelasB, harus terdapat instance dari kelas
A terlebih dahulu. Dengan kata lain, untuk membuat instance inner class, harus
terdapat instance dari outer class terlebih dahulu.
Maksud dari membuat instance inner
class dari dalam outer class tidak termasuk membuat instance dari dalam
method static. Sebab method static tidak dapat menunjuk sesuatu yang tidak
static. Untuk membuat instance inner class dari dalam method static, maka
dipergunakan cara seperti ketika membuat instance inner class dari luar outer
class.
- Contoh membuat instance inner class dari luar outer class :
Program 05
|
class A {
class B {
void
sesuatuDiKelasB() {
System.out.println("Hello, ini di method kelas B");
}
}
}
public class Contoh {
public static void main(String[]
args) {
A a =
new A();
A.B b =
a.new B();
b.sesuatuDiKelasB();
}
}
|
Program 05 di
atas dapat disingkat menjadi :
Program 06
|
class A {f
class B {
void
sesuatuDiKelasB() {
System.out.println("Hello, ini di method kelas B");
}
}
}
public class BelajarInnerClass04 {
public static void main(String[]
args) {
A.B b
= new A().new B();
b.sesuatuDiKelasB();
}
}
|
Ketika kita
ingin membuat instance dari method static dari outer class, maka cara di
ataslah yang digunakan. Hal ini karena method static tidak memiliki reference this.
- Aturan inner class dalam hal mereferensi dirinya sendiri atau instance dari outer class adalah sebagai berikut :
1. Untuk merujuk pada dirinya sendiri
(instance dari inner class) dari dalam inner class, dapat digunakan referensi this atau NamaOuterClass.NamaInnerClass.this.
2. Untuk merujuk pada instance dari
outer classnya dari dalam inner class, dapat digunakan referensi NamaOuterClass.this.
Contoh :
Program 07
|
class A {
int i = 10;
class B {
int i = 11;
class C {
int i = 12;
void lakukanSesuatu() {
System.out.println("A.this.i = " + A.this.i);
System.out.println("A.B.this.i = " + A.B.this.i);
System.out.println("A.B.C.this.i = " + A.B.C.this.i);
System.out.println("this.i
= " + this.i);
}
}
}
}
public class BelajarInnerClass05 {
public static void main(String[]
args) {
A.B.C c =
new A().new B().new C();
c.lakukanSesuatu();
}
}
|
- Modifier-modifier berikut dapat diberikan pada inner class :
1. final
2. abstract
3. public
4. protected
5. private
6. static (tapi dengan modifier ini, maka akan menjadi static nested class, bukan
inner class).
7. strictfp
- 2. Method-Local Inner Class
- Method-local inner class adalah inner class yang dideklarasikan di dalam method.
- Mendeklarasikan method-local inner class tidak berarti kita membuat instance dari class tersebut. Jadi, sebelum kita menggunakan inner class tersebut, kita harus membuat instancenya dari suatu tempat di dalam method dan setelah definisi inner class tersebut.
Contoh :
Program 08
|
class A { //1
void myMethod() { //2
class
B { //3
int i = 10;
void lakukanSesuatu() { //4
System.out.println(" i = " + i);
} //4
} //3
B b =
new B();
b.lakukanSesuatu();
} //2
} //1
|
- Method-local inner class hanya dapat diinstansiasi dari dalam method yang mendefinisikan method-local inner class tersebut.
- Instance method-local inner class memiliki akses ke semua member dari outer class (termasuk member outer class yang ber access modifier private).
Contoh :
Program 09
|
class A { //1
private int i = 10;
void lakukanSesuatu() { //2
class B {
//3
void aksesMemberOuterClass() { //4
System.out.println("i = " + i);
} //4
} //3
B b = new
B();
b.aksesMemberOuterClass();
} //2
} //1
|
- Instance dari method-local inner class tidak dapat mengakses local variabel (termasuk parameter) dari method dimana method-local inner class tersebut didefinisikan. Kecuali bila variabel tersebut bermodifier final.
Contoh :
Program 10
|
class A { //1
void lakukanSesuatu() { //2
int
nonFinalVar = 10;
final
int finalVar = 11;
class B {
//3
void aksesLocalVar() { //4
//ERROR
System.out.println("nonFinalVar = " + nonFinalVar);
//TIDAK ERROR
System.out.println("finalVar = " + finalVar);
} //4
} //3
B b = new
B();
b.aksesLocalVar();
} //2
} //1
|
- Method-local inner class yang didefinisikan di dalam static method tidak dapat mengakses non-static member dari outer classnya.
- Modifier-modifier yang dapat diberikan pada method-local inner class adalah :
1. abstract (tidak dapat digabung dengan final)
2. final (tidak dapat digabung dengan abstract)
3. Anonymous
Inner Class
- Anonymous inner class adalah suatu inner class yang dideklarasikan tanpa nama kelas.
- Anonymous inner class pasti adalah salah satu dari 2 hal berikut :
1. Subclass dari suatu class yang telah
dideklarasikan
2. Kelas implementasi dari suatu
interface
- Suatu anonymous inner class tidak dapat secara bersamaan menjadi subclass dari class yang telah dideklarasikan dan juga sebagai kelas implementasi dari suatu interface
- Tujuan utama dari anonymous inner class adalah mengoverride satu atau lebih method dari super classnya atau mengimplement semua method dari suatu interface.
- Anonymous inner class tidak dapat mengimplement lebih dari sebuah interface
- Anonymous inner class selalu dibuat sebagai bagian dari suatu statement.
- Contoh Anonymous inner class sebagai subclass :
Program 11
|
class A {
int i = 10;
void lakukanSesuatu() {
i--;
System.out.println("i = " + i);
}
}
public class BelajarAnonymous1 {
//1
public static void main(String[]
args) { //2
A a = new
A() { //3
void lakukanSesuatu() { //4
i++;
System.out.println("i = " + i);
} //4
};
//3
a.lakukanSesuatu();
} //2
} //1
|
Note: variabel referensi a di atas mereferensi ke suatu instance anonymous inner class yang merupakan
subclass dari class A. Jadi, variabel referensi a bukan mereferensi ke instance dari kelas A.
- Contoh anonymous inner class sebagai implementasi suatu interface :
Program 12
|
interface A {
public void doA();
}
interface B extends A {
public void doB();
}
public class BelajarAnonymous2 {
public static void main(String[]
args) {
B b = new
B() {
public void doA() {
System.out.println("Ini method doA()");
}
public void doB() {
System.out.println("Ini method doB()");
}
};
b.doA();
b.doB();
}
}
|
- Anonymous inner class adalah salah satu bentuk dari polymorphisme, oleh karena itu, method yang dapat dipanggil dari anonymous inner class adalah method yang dideklarasikan di super class atau interfacenya (meskipun di dalam anonymous inner class dapat dideklarasikan method-method yang tidak ada di super class atau interfacenya).
Contoh :
Program 13
|
class A {
int i = 10;
void
lakukanSesuatu() {
i--;
System.out.println("i = " + i);
}
}
public class BelajarAnonymous1 {
public static void main(String[]
args) {
A a = new
A() {
void lakukanSesuatu() {
i++;
System.out.println("i = " + i);
}
//Di bawah ini adalah method yang tidak ada di class A
void newMethod() {
System.out.println("Hallo, nama saya Anton");
}
};
a.lakukanSesuatu(); //Tidak error
a.newMethod(); //ERROR !!!!!!!
}
}
|
- Anonymous inner class dapat diletakkan sebagai argument dari suatu method. Contoh :
Program 14
|
class A {
void lakukanSesuatu() {
System.out.println("Ini isi aslinya");
}
}
class B {
static void demoAnonymousInnerClassSebagaiArgument(A
a) {
a.lakukanSesuatu();
}
}
public class BelajarAnonymous3 {
public static void main(String[]
args) {
B.demoAnonymousInnerClassSebagaiArgument(new A() {
void lakukanSesuatu() {
System.out.println("Ini method di anonymous inner class");
}
});
}
}
|
4. Static
nested class
- Static nested class adalah inner class dengan modifier static.
- Static nested class sebenarnya bukan inner class, static nested class hanyalah top-level class yang di sarangkan di dalam class lain.
- Karena static, maka untuk membuat instance dari static nested class tidak diperlukan instance dari outer classnya. (tidak seperti regular inner class ataupun method-local inner class ).
Contoh :
Program 15
|
class A {
static class B {
void
lakukanSesuatu() {
System.out.println("Hallo");
}
}
}
public class StaticNestedClass {
public static void main(String[]
args) {
A.B b
= new A.B(); //cara instansiasi static nested class
b.lakukanSesuatu();
}
}
|
- Cara instansiasi static nested inner class adalah :
NamaOuterClass.NamaStaticNestedClass varRef = new
NamaOuterClass.NamaStaticNestedClass()
- Static nested class tidak dapat mengakses non-static member dari outer classnya.
Contoh :
Program 16
|
class A {
int i = 10;
static class B {
void
lakukanSesuatu() {
System.out.println("i = " + i);
}
}
}
public class StaticNestedClass2 {
public static void main(String[]
args) {
A.B b =
new A.B();
b.lakukanSesuatu();
}
|
langsung saja kita ke Contoh yang telah disampaikan oleh Bu Sundari Retno Andani, S.T,M.Kom
Program Makhluk Hidup beserta Scriptnya :
public abstract class MakhlukHidup {
Program Tumbuhan beserta Scriptnya:
Program Pekerjaan beserta Scriptnya :
Program Sasya beserta Scriptnya :
public abstract class MakhlukHidup {
protected boolean BisaTerbang =
false;
protected String Nama;
protected int JlhKaki;
public MakhlukHidup (String Nama1,
int JlhKaki1,boolean BisaTerbang1) {
this.Nama = Nama1;
this.JlhKaki = JlhKaki1;
this.BisaTerbang = BisaTerbang1;
}
abstract
void bernafas ();
public
void status () {
System.out.println ("Nama :
" +Nama);
System.out.println ("Jumlah
kaki : " +JlhKaki);
System.out.println ("Bisa
terbang : " +BisaTerbang) ;
}
}
Outputnya :
Program Manusia beserta Scriptnya :
public
class Manusia extends MakhlukHidup {
Manusia (String nama) {
super (nama, 2,false);
}
public void bernafas () {
System.out.println
(Nama+" bernafas dengan menghirup O2");
}
public static void main (String []
args) {
Manusia m = new Manusia
("Sayuti");
m.status ();
m.bernafas ();
}
}
outpunya :
Program Tumbuhan beserta Scriptnya:
public
class Tumbuhan extends MakhlukHidup {
Tumbuhan(String nama) {
super (nama, 0,false);
}
public void bernafas () {
System.out.println(Nama+"
bernafas dengan menghirup CO2");
}
public static void main
(String[]args) {
Tumbuhan t = new Tumbuhan
("Bayam");
t.status ();
t.bernafas ();
}
}
Outputnya :
Program Pekerjaan beserta Scriptnya :
interface
Pekerjaan {
public
void namaPekerjaan ();
public
void gaji ();
}
Outputnya :
Program Sasya beserta Scriptnya :
public
class Sasya extends Manusia implements Pekerjaan {
public
Sasya () {
super ("Sasya");
}
public
void namaPekerjaan () {
System.out.println("Pekerjaan
:Sekretaris");
}
public
void gaji () {
System.out.println("Gaji : Rp. 3.000.000");
}
public
static void main (String[] args) {
Sasya s = new Sasya();
s.status ();
s.bernafas ();
s.namaPekerjaan ();
s.gaji ();
}
}
Outputnya :
Program Jantung Manusia Beserta Scriptnya :
class
Orang {
private
int jumlKaki = 2;
public
void dengarBunyiJantung() {
Jantung j = new Jantung ();
j.bunyiJantung ();
}
public
void tahanNafas () {
System.out.println ("Jantung
berhenti berdetak!");
}
//Inner
Class
class
Jantung {
public
void bunyiJantung () {
System.out.println
("deg...deg...deg...");
}
public
void istirahat () {
System.out.println ("Silangkan
ke "+jumlKaki+" kaki.");
tahanNafas ();
}
}
}
class
JantungManusia {
public static void main (String[]
args) {
Orang o = new Orang ();
Orang.Jantung p = o.new Jantung ();
o.dengarBunyiJantung ();
p.istirahat ();
}
}
Outputnya :
Dosen :
Sundari Retno Andani, S.T,M.Kom
No comments:
Post a Comment