PERTEMUAN 4
A.
ABSTRACT CLASS
Abstract Class
Dalam Java Abstract class dalam java digunakan untuk mendeklarasikan
karakteristik umum dari subclass. Abstract class tidak bisa diinstansiasi sama
halnya dengan kelas interface. abstract class hanya bisa digunakan sebagai
super class, tapi juga bisa diturunkan dari class abstract lainnya. Untuk
mendeklarasikan sebuah abstract class digunakan keyword abstract, [abstract]
class [class_name] Sebuah abstract class pada dasarnya tidak hauh beda dengan
class lainnya, yakni juga berisi method yang menggambarkan carakteristik dari
kelas abstract tersebut, bedanya yakni sebuah abstract class bisa berisi method
tanpa diimplementasikan artinya sebuah method tanpa body, methid seperti ini
disebut method abstract. untuk pendeklarasiannya digunakan keyword abstract:
[abstract] modifier class [class_name]
berikut contoh program yang menggunakan class abstract
abstract class Shape { public String color;
//constractor default, constraktor yang tidak memiliki
argumen dan isi
public Shape() { }
//sama halnya
dengan kelas biasa abstract class juga bisa berisi method
//seperti yang ada pada kelas biasa public void
setColor(String c) { color = c; } public String getColor() { return color; }
//sebuah
abstract method yang tidak memiliki body
//method ini
akan diinisialisasi nantinya pada subclass yang mewarisi kelass abstract Shape
ini
//semua
abstract method yang ada pada class abstract harus diimplementasikan
//semua oleh subclass abstract public double area(); }
//keyword
extends adalah keyword yang digunakan oleh subclass
//ketika
melakukan pewarisan terhada super class public class Point extends Shape {
static int x, y; public Point() { x = 0; y = 0; } public double area() { return
0; } public double perimeter() { return 0; } public static void print()
{ System.out.println("point: " + x +
"," + y); } public static void main(String args[])
{ Point p = new Point(); p.print(); } }
output point: 0, 0
B. INTERFACE
Interface adalah jenis khusus dari blok yang hanya
berisi method signature (atau constant). Interface mendefinisikan
sebuah(signature) dari sebuah kumpulan method tanpa tubuh. Interface
mendefinisikan sebuah cara standar dan umum dalam menetapkan sifat-sifat dari
class-class. Mereka menyediakan class-class, tanpa memperhatikan lokasinya
dalam hirarki class, untuk mengimplementasikan sifat-sifat yang umum. Dengan
catatan bahwa interface-interface juga menunjukkan polimorfisme, dikarenakan
program dapat memanggil method interface dan versi yang tepat dari method yang
akan dieksekusi tergantung dari tipe object yang melewati pemanggil method
interface –
Untuk memahami lebih mudah, interface sekumpula dari
method-method yang dibuat tapi belum ada operasi di dalam tubuh method
tersebut, interface ini bisa diturunkan atau diwariskan kepada class yang ingin
memakai method yang ada dalam masing-masing interface tersebut dengan keyword extends [interface yang didefinisikan]. Dan
juga sebuah class mengimplementasi 1 interface yang sudah dibuat dengan keyword
implements.
Ciri-ciri dari interface adalah sebagai berikut..
- Method interface tidak punya tubuh, sebuah interface hanya dapat
mendefinisikan konstanta dan interface tidak langsung mewariskan hubungan
dengan class istimewa lainnya, mereka didefinisikan secara independent.
- Tidak bisa membuat instance atau objek baru dari sebuah interface.
- Ciri umum lain adalah baik interface maupun class dapat mendefinisikan
method. Bagaimanapun, sebuah interface tidak punya sebuah kode
implementasi sedangkan class memiliki salah satunya.
C. INNER CLASS
- Inner class adalah suatu class yang berada di dalam class lainnya. [1]
- Di buku [2], disebutkan 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. [2]
- Inner class didefinisikan (ditulis) di dalam
kurung kurawal dari outer class. [2]
- Bila ada kode java sebagai berikut : [2]
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). [2]
Contoh : [1]
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. [2]
Contoh : [1]
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. [2]
- 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 : [1]
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 : [1]
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 : [1]
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 : [2]
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 : [1]
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 : [2]
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
