Download Labkom UBL - WordPress.com

Konsep Inheritance
Protected Member
Hubungan antara Superclass dan subclass
Hubungan antara obyek-obyek dalam turunan
Nested class
Inheritance :
Secara bebas Inheritance di terjemahkan sebahagai pewarisan.
Yaitu sebuah konsep dimana kita bisa membuat sebuah class baru dengan
mengembangkan kelas yang pernah dibuat sebelumnya.
Metode OOP memungkinkan kita memperoleh seluruh data dari classinduk
(base-class) untuk diberikan kepada class anak (derived-class) tanpa harus
melakukan copy-and-paste seluruh kode base-class.
Contoh :
kita akan membuat class Silinder seperti digambarkan dibawah ini
r
t
Catt:
Selain tinggi silinder (t), silinder juga memiliki jari-jari (r)
lingkaran pada kedua ujungnya.
Berdasarkan gambar
tersebut bisa dibuat bagan
untuk class Silinder dengan
mencantumkan seluruh
data dan metodenya sbb:
Silinder
double jariJari
double tinggi
void setJariJari(double)
void setTinggi(double)
double getJariJari()
double getTinggi()
double hitungLuas()
double hitungVolume()
Kemudian kita coba membandingkan class Lingkaran terdahulu dengan
class Silinder yang akan kita buat :
Lingkaran
double jariJari
void setJariJari(double)
double getJariJari()
double hitungLuas()
double hitungkeliling()
Silinder
double jariJari
double tinggi
void setJariJari(double)
void setTinggi(double)
double getJariJari()
double getTinggi()
double hitungLuas()
double hitungVolume()
Dari perbandingan tsb, terdapat data dan method yang sama pada kedua
class. Kita juga bisa melihat bahwa class Silinder merupakan superset dari
class Lingkaran. Metode OOP mengijinkan kita membuang data dan
method dari class superset yang ada pada kelas subset-nya. Sehingga
menjadi sbb:
Lingkaran
Silinder
double jariJari
double tinggi
void setJariJari(double)
double getJariJari()
double hitungLuas()
double hitungkeliling()
void setTinggi(double)
double getTinggi()
double hitungLuas()
double hitungVolume()
Catt:
Tidak semua method class Lingkaran kita hilangkan pada class Silinder.
Contoh method hitungLuas() tetap digunakan, hanya saja isinya berbeda,
karena menghitung luas Lingkaran tentu berbeda dengan menghitung luas
Silinder, pada class silinder kita menambahkan method hitungVolume() karena
bangunan Geometris Silinder adalah 3-Dimensi. Sedangkan untuk method
hitungkeliling(), meski pada class Silindersudah kita buang, namun user tetap
bisa menggunakannya karena method ini secara otomatis diwariskan ke class
Silinder. Pada hal kita tahu Silinder tidak mempunyai keliling.
Lingkaran
double jariJari
Kedua struktur class ini bisa
digambarkan secara hirarki,
dengan menggunakan
model Unified Modelling
Language (UML) dari
Rumbaugh dkk:
void setJariJari(double)
double getJariJari()
double hitungLuas()
double hitungkeliling()
Silinder
double tinggi
void setTinggi(double)
double getTinggi()
double hitungLuas()
double hitungVolume()
Implementasi Java untuk class Silinder sbb:
1 class Silinder extends Lingkaran
2 {
3
private double tinggi;
4
public Silinder()
5
{
6
setJariJari (1);
7
setTinggi (1);
8
}
9
public Silinder(double r, double t)
10
{
11
setJariJari (r);
12
SetTinggi (r);
13
}
14
15
Class Silinder merupakan
turunan dari class Lingkaran
16
17
18
19
20
21
22
23
24
25
26
•
28
29
30
31
32 }
public void setTinggi (double t)
{
if (t>0) tinggi = r;
}
public double getTinggi()
{
return (tinggi);
}
public double hitungLuas()
{
Kata kunci super merujuk
kepada class induk
return (super.hitungLuas() * 2.0 + super.hitungKeliling() * tinggi);
}
public double hitungVolume()
{
return (Math.PI * 2.0 * jariJari * tinggi);
}
Secara Lengkap program dapat dilihat sbb:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// --------------------------------------------// Definisi class Lingkaran
// --------------------------------------------class Lingkaran
{
private double jariJari;
public Lingkaran()
{
setJariJari(1);
}
public Lingkaran(double r)
{
if (r > 0)
jariJari = r;
else
jariJari = 1.0;
}
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 }
public void setJariJari (double r)
{
if (r>0)
jariJari=r;
}
public double getJariJari()
{
return (jariJari);
}
public double hitungLuas()
{
return (Math.PI * jariJari * jariJari);
}
public double hitungKeliling()
{
return (Math.PI * 2.0 * jariJari);
}
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// --------------------------------------------// Definisi class Silinder
// --------------------------------------------class Silinder extends Lingkaran
{
private double tinggi;
public Silinder()
{
setJariJari (1);
setTinggi (1);
}
public Silinder(double r, double t)
{
setJariJari (r);
SetTinggi (r);
}
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public void setTinggi (double t)
{
if (t>0) tinggi = r;
}
public double getTinggi()
{
return (tinggi);
}
public double hitungLuas()
{
return (super.hitungLuas() * 2.0 + super.hitungKeliling() * tinggi);
}
public double hitungVolume()
{
return (Math.PI * 2.0 * jariJari * tinggi);
}
}
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// --------------------------------------------// Definisi class utama
// --------------------------------------------public class CobaSilinder
{
public static void main (String[] args)
{
Silinder abc = new Silinder();
Silinder xyz = new Silinder(23.5, 73.1);
System.out.println (“Data Silinder ABC :”);
System.out.println (“-----------------------”);
System.out.println (“Jari-Jari ABC : ” + abc.getJariJari());
System.out.println (“Tinggi ABC
: ” + abc.getTinggi());
System.out.println (“Luas ABC
: ” + abc.hitungLuas());
System.out.println (“Luas ABC
: ” + abc.hitungVolume());
System.out.println ();
85
86
87
88
89
90
91
92
93 }
System.out.println (“Data Silinder XYZ :”);
System.out.println (“-----------------------”);
System.out.println (“Jari-Jari ABC : ” + xyz.getJariJari());
System.out.println (“Tinggi ABC
: ” + xyz.getTinggi());
System.out.println (“Luas ABC
: ” + xyz.hitungLuas());
System.out.println (“Luas ABC
: ” + xyz.hitungVolume());
System.out.println ();
}
TurunanOrang.java
Program penurunan Orang
SapiMamat.java
Program Inheritance dan protected variabel
TurunanAyam.java
Hubungan antara Objek dalam turunan
Konsep polymorpisme
Implementasi polymorpisme
Interface
Polymorphism :
Secara mudah polymorphism bisa disamakan dengan method overloading,
dimana didalam class bisa terdapat beberapa method dengan nama sama.
Contoh:
Sebuah method bernama tulisData() yang berfungsi untuk menampilkan
data string, tentu tidak bisa menangani masukan berupa data yang lain.
Solusi yang dapat diberikan yaitu dengan menyediakan beberapa method
dengan nama yang sama dan masing-masing method memiliki parameter
dengan tipe data yang berbeda.
Method tersebut akan bereaksi dengan satu dari beberapa macam cara
tergantung dari data yung di-passing ke dalamnya, keragaman model aksi
inilah yang disebut Polymorphism, atau banyak bentuk
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// --------------------------------------------// Definisi class TampilData
// --------------------------------------------class TampilData
{
public void tulisData(String data)
{
System.out.println (data);
}
public void tulisData(int data)
{
System.out.println (data);
}
public void tulisData(double data)
{
System.out.println (data);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// --------------------------------------------// Definisi class utama
// --------------------------------------------public class Polymorphism
{
public static void main(String[] args)
{
TampilData abc = new TampilData();
System.out.print (“Cetak data string : “);
abc.tulisData (“Universitas Budi Luhur”);
System.out.print (“Cetak data integer : “);
abc.tulisData (1979);
System.out.print (“Cetak data double : “);
abc.tulisData (25.0);
}
}
3. Package :
Sejauh ini semua class yang dibuat harus menyatu dengan program utama
(class dengan fungsi main()).
Sedangkan sebuah program yang baik haruslah mampu menggunakan
modul atau class dari file yang lain tanpa harus menyalin file tersebut
kedalam file yang sedang diedit.
Hal ini dapat dilakukan oleh Java, sama halnya dilakukan oleh bahasa
pemrograman yang lainnya.
Contoh :
Basic  chain
Pascal  unit
C/C++  include
Java  package
Package adalah sebuah direktory yang berisi sekumpulan file .class
dengan kegunaan spesifik.
Proses pembentukan directory package tidak sama seperti kita membuat directory
pada Windows Explorer atau menggunakan MD pada DOS.
Class yang akan kita masukkan kedalam package harus mencantumkan nama
package di baris pertama. Secara otomatis file hasil compilenya akan dimasukkan
ke dalam directory yang tidak lain nama package tersebut.
Instruksi untuk mengkompile class java menjadi package adalah :
javac –d <directory_target> <nama_file_java>
Directory package tidak sama dengan nama package. Opsi ini digunakan untuk
mengarahkan didirectory mana kita akan membuat directory baru sebagai nama
package.
Nama directory tidak boleh mengandung spasi atau karakter lain yang tidak valid.
Kedua class : lingkaran dan silinder terdahulu kita jadikan package sehingga
program lain yang menggunakannya tidak perlu menyertakan kode class tersebut
didalam filenya.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Package modul
// --------------------------------------------// Definisi class Lingkaran
// --------------------------------------------public class Lingkaran
{
private double jariJari;
public Lingkaran()
{
setJariJari(1);
}
public Lingkaran(double r)
{
if (r > 0)
jariJari = r;
else
jariJari = 1.0;
}
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 }
public void setJariJari (double r)
{
if (r>0)
jariJari=r;
}
public double getJariJari()
{
return (jariJari);
}
public double hitungLuas()
{
return (Math.PI * jariJari * jariJari);
}
public double hitungKeliling()
{
return (Math.PI * 2.0 * jariJari);
}
Kata kunci package digunakan untuk menyatakan nama package yang akan dibuat.
Nama package sengaja dipilih modul agar mudah mengingat bahwa didalam
package ini kita menyimpan modul-modul program.
Karakteristik dari package :
1.
Bersifat public
2.
Diawali dengan huruf kecil
Direktori modul secara otomati dibuat oleh java pada saat kompilasi dilakukan.
Kemudian lakukan hal yang sama pada class Silinder, seperti program dibawah ini,
* dimana class Silinder merupakan turunan dari class Lingkaran.
* Class Lingkaran harusnya sudah dikompilasi terlebih dahulu.
* Didalam class Silinder harus ada instruksi yang mengarahkan agar java
mengambil modul Lingkaran dari directory modul.
* Class Silinder sendiri harus menyertakan package modul agar hasil kompilasi
disimpan didirektory modul.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package modul
import modul.Lingkaran
class Silinder extends Lingkaran
{
private double tinggi;
public Silinder()
{
setJariJari (1);
setTinggi (1);
}
public Silinder(double r, double t)
{
setJariJari (r);
SetTinggi (r);
}
16
17
18
19
20
21
22
23
24
25
26
•
28
29
30
31
32 }
public void setTinggi (double t)
{
if (t>0) tinggi = r;
}
public double getTinggi()
{
return (tinggi);
}
public double hitungLuas()
{
return (super.hitungLuas() * 2.0 + super.hitungKeliling() * tinggi);
}
public double hitungVolume()
{
return (Math.PI * 2.0 * jariJari * tinggi);
}
Implementasi package tidak sulit, cukup dengan mengimport package yang
dikehendaki.
Contoh :
1 import modul.Lingkaran
2
3 public class UjiLingkaran {
4
public static void main (String[] args) {
5
Lingkaran abc = new Lingkaran(5);
6
Lingkaran pqr = new Lingkaran(3.2);
7
System.out.println (“Data Default :”);
8
System.out.println (“-----------------”);
9
System.out.println (“Jari – Jari ABC : ” + abc.getJariJari());
10
System.out.println (“Jari – Jari PQR : ” + pqr.getJariJari());
11
System.out.println ();
12
}
13 }
4. Contoh Kasus (Latihan mandiri) :
Contoh Kasus dapat dilihat pada halaman 40 s/d 58 : pemrograman java jilid 2
Rangsang purnama:
Setelah mempelajari dasar-dasar OOP, pada bagian ini kita berharap bisa
menerapkan metode tersebut dengan mengambil peristiwa sehari-hari dengan
langkah-lahkah sbb :
1.
2.
3.
4.
Mendefinisikan class penduduk
Mendefinisikan class karyawan
Mendefinisikan class mahasiswa
Mendefinisikan class menwa
Lakukan pendefinisian sama seperti materi yang sudah kita pelajari.
PolyMorpheus.java
Polymorphisme dalam Film
Terima Kasih