8
Pewarisan
Pewarisan
merupakan salah satu fitur inti dari pemrograman berorientasi-objek karena
mekanisme ini memampukan penciptaan klasifikasi hirarkis. Dengan pewarisan,
Anda dapat menciptakan kelas umum yang mendefinisikan sifat/watak umum. Kelas
ini kemudian dapat diwarisi oleh kelas-kelas lain, yang merupakan kelas-kelas
yang lebih spesifik, dengan menambahkan hal-hal unik. Dalam terminologi Java,
sebuah kelas yang diwarisi dikenal dengan superkelas. Kelas yang mewarisi
dikenal dengan subkelas. Oleh karena itu, subkelas merupakan versi
terspesialisasi dari superkelas. Subkelas mewarisi semua variabel dan metode
instans yang didefinisikan oleh superkelas.
Soal dan Penyelesaian
1.
Untuk mewarisi sebuah kelas, Anda hanya perlu menggunakan katakunci extends. Tulislah sebuah program
sederhana yang mendemonstrasikan pewarisan.
Penyelesaian
// Sebuah contoh pewarisan sederhana.
// Menciptakan sebuah superkelas.
class A {
int i, j;
void tampilij() {
System.out.println("i dan j: " + i + " " +
j);
}
}
// Menciptakan sebuah subkelas dengan mewarisi kelas A.
class B extends A {
int k;
void tampilk() {
System.out.println("k: " + k);
}
void jum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
public class
DemoPewarisan {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
// Superkelas dapat
menggunakan dirinya sendiri.
superOb.i = 10;
superOb.j = 20;
System.out.println("Isi dari superOb: ");
superOb.tampilij();
System.out.println();
// Subkelas dapat mengakses
semua anggota publik dari superkelasnya
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Isi darisubOb: ");
subOb.tampilij();
subOb.tampilk();
System.out.println();
System.out.println("Penjumlahan atas i, j dan k di dalam subOb:
");
subOb.jum();
}
}
Keluaran Program
Isi dari superOb:
i dan j: 10 20
Isi darisubOb:
i dan j: 7 8
k: 9
Penjumlahan atas i, j dan k di dalam subOb:
i+j+k: 24
2.
Subkelas
tidak dapat mengakses anggota-anggota dari superkelas yang dideklarasikan private. Tulislah sebuah program yang
mengilustrasikan situasi ini.
Penyelesaian
/* Di dalam suatu hirarki kelas, anggota-anggota private
tetap menjadi private di dalam
kelasnya.
Program ini memuat satu error dan
tidak akan dapat
dikompilasi
*/
// Menciptakan sebuah superkelas.
class A {
int i; // public secara default
private int j; //
private di dalam A
void setij(int x, int y) {
i = x;
j = y;
}
}
// j dari A tidak dapat diakses di sini
class B extends A {
int total;
void jum() {
total = i + j; // ERROR, j tidak dapat diakses di sini
}
}
public class
DemoPewarisan2 {
public static void main(String args[]) {
B subOb = new B();
subOb.setij(10, 12);
subOb.jum();
System.out.println("Total adalah " + subOb.total);
}
}
3.
Tulis-ulanglah
versi terakhir dari kelas Kotak pada
bab sebelumnya yang diwarisi untuk memuat komponen keempat yang dinamakan berat. Jadi, kelas baru ini akan memuat
lebar, tinggi, dalam, dan berat.
Penyelesaian
// Program ini menggunakan pewarisan untuk mewarisi Kotak.
class Kotak {
double lebar;
double tinggi;
double dalam;
// Perhatikan konstruktor ini.
Ia mengambil sebuah objek bertipe Kotak.
Kotak(Kotak ob) { // melewatkan
objek kepada konstruktor
lebar = ob.lebar;
tinggi = ob.tinggi;
dalam = ob.dalam;
}
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
// Di sini, Kotak diwarisi untuk memuat berat.
class BeratKotak extends Kotak {
double berat; // berat dari kotak
// konstruktor untuk BeratKotak
BeratKotak(double w, double h, double d, double m) {
lebar = w;
tinggi = h;
dalam = d;
berat = m;
}
}
public class
DemoKotakPewarisan {
public static void main(String args[]) {
BeratKotak kotakKu1 = new BeratKotak(10, 20, 15, 34.3);
BeratKotak kotakKu2 = new BeratKotak(2, 3, 4, 0.076);
double vol;
vol = kotakKu1.volume();
System.out.println("Volume dari kotakKu1 adalah " +
vol);
System.out.println("Berat dari kotakKu1 adalah " +
kotakKu1.berat);
System.out.println();
vol = kotakKu2.volume();
System.out.println("Volume dari kotakKu2 adalah " +
vol);
System.out.println("Berat dari kotakKu2 adalah " +
kotakKu2.berat);
}
}
Keluaran Program
Volume dari kotakKu1 adalah 2000.0
Berat dari kotakKu1 adalah 34.3
Volume dari kotakKu2 adalah 12.0
Berat dari kotakKu2 adalah 0.076
4.
Sebuah variabel
referensi dari superkelas dapat ditugasi suatu referensi dari sembarang
subkelas yang mewarisi superkelas tersebut. Tulislah sebuah program untuk
mengilustrasikan situasi ini.
Penyelesaian
// Program ini menggunakan pewarisan untuk mewarisi Kotak.
class Kotak {
double lebar;
double tinggi;
double dalam;
// Perhatikan konstruktor ini.
Ia mengambil sebuah objek bertipe Kotak.
Kotak(Kotak ob) { // melewatkan
objek kepada konstruktor
lebar = ob.lebar;
tinggi = ob.tinggi;
dalam = ob.dalam;
}
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
// Di sini, Kotak diwarisi untuk memuat berat.
class BeratKotak extends Kotak {
double berat; // berat dari kotak
// konstruktor untuk BeratKotak
BeratKotak(double w, double h, double d, double m) {
lebar = w;
tinggi = h;
dalam = d;
berat = m;
}
}
public class
DemoPewarisanRef {
public static void main(String args[]) {
BeratKotak beratkotak = new BeratKotak(3, 5, 7, 8.37);
Kotak kotaksederhana = new Kotak();
double vol;
vol = beratkotak.volume();
System.out.println("Volume dari beratkotak adalah " +
vol);
System.out.println("Berat dari beratkotak adalah " +
beratkotak.berat);
System.out.println();
// menugaskan referensi
BeratKotak ke referensi Kotak
kotaksederhana = beratkotak;
vol =
kotaksederhana.volume(); // OK, volume()
didefinisikan di dalam Kotak
System.out.println("Volume dari kotaksederhana adalah
" + vol);
/* Statemen berikut tidak
valid karena kotaksederhana
tidak mendefinisikan
anggota berat. */
//
System.out.println("Berat dari kotaksederhana adalah "
+
kotaksederhana.berat);
}
}
Keluaran Program
Volume dari beratkotak adalah 45.0
Berat dari beratkotak adalah 8.37
Volume dari kotaksederhana adalah 45.0
5.
Subkelas
dapat memanggil konstruktor yang didefinisikan oleh superkelasnya menggunakan
katakunci super. Tulis-ulanglah kode
pada soal no 4 untuk mengilustrasikan situasi ini.
Penyelesaian
// Program ini menggunakan pewarisan untuk mewarisi Kotak.
class Kotak {
double lebar;
double tinggi;
double dalam;
// Perhatikan konstruktor ini.
Ia mengambil sebuah objek bertipe Kotak.
Kotak(Kotak ob) { // melewatkan
objek kepada konstruktor
lebar = ob.lebar;
tinggi = ob.tinggi;
dalam = ob.dalam;
}
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
// BeratKotak sekarang mengimplementasikan semua konstruktor.
class BeratKotak extends Kotak {
double berat; // berat dari kotak
// mengkloning sebuah objek
kotak
BeratKotak(BeratKotak ob) { //
melewatkan objek kepada konstruktor
super(ob);
berat = ob.berat;
}
// konstruktor ketika semua
parameter ditetapkan
BeratKotak(double w, double h, double d, double m) {
super(w, h, d); // memanggil konstruktor superkelas
berat = m;
}
// konstrukto default
BeratKotak() {
super();
berat = -1;
}
// konstruktor digunakan ketika
kotak sama sisi diciptakan
BeratKotak(double len, double m) {
super(len);
berat = m;
}
}
public class
DemoPewarisanSuper {
public static void main(String args[]) {
BeratKotak kotakKu1 = new BeratKotak(10, 20, 15, 34.3);
BeratKotak kotakKu2 = new BeratKotak(2, 3, 4, 0.076);
BeratKotak kotakKu3 = new BeratKotak(); // default
BeratKotak kubikKu = new BeratKotak(3, 2);
BeratKotak kloningKu = new BeratKotak(kotakKu1);
double vol;
vol = kotakKu1.volume();
System.out.println("Volume dari kotakKu1 adalah " +
vol);
System.out.println("Berat dari kotakKu1 adalah " +
kotakKu1.berat);
System.out.println();
vol = kotakKu2.volume();
System.out.println("Volume dari kotakKu2 adalah " +
vol);
System.out.println("Berat dari kotakKu2 adalah " +
kotakKu2.berat);
System.out.println();
vol = kotakKu3.volume();
System.out.println("Volume dari kotakKu3 adalah " +
vol);
System.out.println("Berat dari kotakKu3 adalah " +
kotakKu3.berat);
System.out.println();
vol = kloningKu.volume();
System.out.println("Volume dari kloningKu adalah " +
vol);
System.out.println("Berat dari kloningKu adalah " +
kloningKu.berat);
System.out.println();
vol = kubikKu.volume();
System.out.println("Volume dari kubikKu adalah " +
vol);
System.out.println("Berat dari kubikKu adalah " +
kubikKu.berat);
System.out.println();
}
}
Keluaran Program
Volume dari kotakKu1 adalah 2000.0
Berat dari kotakKu1 adalah 34.3
Volume dari kotakKu2 adalah 12.0
Berat dari kotakKu2 adalah 0.076
Volume dari kotakKu3 adalah -1.0
Berat dari kotakKu3 adalah -1.0
Volume dari kloningKu adalah 2000.0
Berat dari kloningKu adalah 34.3
Volume dari kubikKu adalah 27.0
Berat dari kubikKu adalah 2.0
6.
Kegunaan
kedua dari super adalah mirip
seperti this, kecuali bahwa
katakunci super selalu menunjuk ke
superkelas dari subkelas dimana di dalamnya katakunci ini digunakan. Tulislah
sebuah program sederhana untuk mengilustrasikan situasi ini.
Penyelesaian
// Menggunakan super untuk mengatasi penyembunyian nama.
class A {
int i;
}
// Menciptakan sebuah subkelas dengan mewarisi kelas A.
class B extends A {
int i; // i ini menyembunyikan i di dalam A
B(int a, int b) {
super.i = a; // i di dalam A
i = b; // i di dalam B
}
void tampil() {
System.out.println("i di dalam superkelas: " +
super.i);
System.out.println("i di dalam subkelas: " + i);
}
}
public class
MenggunakanSuper {
public static void main(String args[]) {
B subOb = new B(1, 2);
subOb.tampil();
}
}
Keluaran Program
i di dalam superkelas: 1
i di dalam subkelas: 2
7.
Sampai sejauh
ini, Anda telah menggunakan hirarki-hirarki kelas sederhana yang hanya memuat
satu superkelas dan satu subkelas. Namun, Anda dapat membangun hirarki yang
dapat memuat banyak tingkat pewarisan sebanyak yang Anda inginkan. Sebagai
contoh, diberikan kelas A, B, dan C. Kelas C dapat merupakan subkelas dari B,
dimana B merupakan subkelas dari A. Ketika situasi ini terjadi, setiap subkelas
mewarisi semua watak dari superkelasnya. Pada kasus ini, C mewarisi semua aspek
dari B dan A. Tulislah sebuah program untuk mengilustrasikan hirarki pewarisan
level jamak ini.
Penyelesaian
// Program ini mendemonstrasikan pewarisan jamak
class Kotak {
double lebar;
double tinggi;
double dalam;
// Perhatikan konstruktor ini.
Ia mengambil sebuah objek bertipe Kotak.
Kotak(Kotak ob) { // melewatkan
objek kepada konstruktor
lebar = ob.lebar;
tinggi = ob.tinggi;
dalam = ob.dalam;
}
// konstruktor ini dipakai
ketika semua dimensi ditetapkan
Kotak(double l, double t, double d) {
lebar = l;
tinggi = t;
dalam = d;
}
// konstruktor ini dipakai
ketika tidak ada dimensi ditetapkan
Kotak(){
lebar = -1; // menggunakan
-1 untuk mengindikasikan
tinggi = -1; // bahwa kotak
dalam = -1; // tidak
diinisialisasi
}
// konstruktor ini dipakai jika
semua sisi kotak sama
Kotak(double pjg) {
lebar = tinggi = dalam =
pjg;
}
// menghitung volume sebuah
kotak
double volume() {
return lebar * tinggi * lebar;
}
}
// Menambahkan berat.
class BeratKotak extends Kotak {
double berat; // berat dari kotak
// mengkloning sebuah objek kotak
BeratKotak(BeratKotak ob) { //
melewatkan objek kepada konstruktor
super(ob);
berat = ob.berat;
}
// konstruktor ketika semua
parameter ditetapkan
BeratKotak(double w, double h, double d, double m) {
super(w, h, d); // memanggil konstruktor superkelas
berat = m;
}
// konstrukto default
BeratKotak() {
super();
berat = -1;
}
// konstruktor digunakan ketika
kotak sama sisi diciptakan
BeratKotak(double len, double m) {
super(len);
berat = m;
}
}
// menambahkan biaya pengiriman.
class Pengiriman extends BeratKotak
{
double biaya;
// menciptakan kloning dari
sebuah objek
Pengiriman(Pengiriman ob) { //
melewatkan objek kepada konstruktor
super(ob);
biaya = ob.biaya;
}
// konstruktor ketika semua
parameter ditetapkan
Pengiriman(double w, double h, double d,
double m, double c) {
super(w, h, d, m); // memanggil konstruktor superkelas (kelas BeratKotak)
biaya = c;
}
// konstruktor default
Pengiriman() {
super();
biaya = -1;
}
// konstruktor digunakan ketika
kotak sama sisi diciptakan
Pengiriman(double len, double m, double c) {
super(len, m);
biaya = c;
}
}
public class
PewarisanJamak {
public static void main(String args[]) {
Pengiriman pengiriman1 =
new Pengiriman(10, 20, 15, 10, 50000);
Pengiriman pengiriman2 =
new Pengiriman(2, 3, 4, 0.76, 15000);
double vol;
vol = pengiriman1.volume();
System.out.println("Volume dari pengiriman1 adalah " +
vol);
System.out.println("Berat dari pengiriman1 adalah "
+ pengiriman1.berat);
System.out.println("Biaya pengiriman: Rp. " +
pengiriman1.biaya);
System.out.println();
vol = pengiriman2.volume();
System.out.println("Volume dari pengiriman2 adalah " +
vol);
System.out.println("Berat dari pengiriman2 adalah "
+ pengiriman2.berat);
System.out.println("Biaya pengiriman: Rp. " +
pengiriman2.biaya);
}
}
Keluaran Program
Volume dari pengiriman1 adalah 2000.0
Berat dari pengiriman1 adalah 10.0
Biaya pengiriman: Rp. 50000.0
Volume dari pengiriman2 adalah 12.0
Berat dari pengiriman2 adalah 0.76
Biaya pengiriman: Rp. 15000.0
8.
Ketika
sebuah hirarki kelas diciptakan, urutan bagaimanakah konstruktor-konstruktor
pada hirarki tersebut dipanggil? Sebagai contoh, diberikan sebuah subkelas B
dan superkelas A. Apakah konstruktor kelas A dipanggil sebelum konstruktor
kelas B?, atau sebaliknya? Jawabannya adalah bahwa di dalam suatu hirarki
kelas, konstruktor-konstruktor dipanggil sesuai urutan pewarisan, dari
superkelas ke subkelas. Tulislah sebuah program untuk mengilustrasikan situasi
ini.
Penyelesaian
// Mendemonstrasikan kapan konstruktor-konstruktor dipanggil.
// Menciptaan sebuah superkelas.
class A {
A() {
System.out.println("Di dalam konstruktor A.");
}
}
// Menciptakan sebuah subkelas dengan mewarisi kelas A.
class B extends A {
B() {
System.out.println("Di dalam konstruktor B.");
}
}
// Menciptakan subkelas lain dengan mewarisi B.
class C extends B {
C() {
System.out.println("Di dalam konstruktor C.");
}
}
public class
KonstruktorPewarisan {
public static void main(String args[]) {
C c = new C();
}
}
Keluaran Program
Di dalam konstruktor A.
Di dalam konstruktor B.
Di dalam konstruktor C.
9.
Di
dalam suatu hirarki kelas, ketika sebuah metode di dalam subkelas memiliki nama
dan sidik tipe sama dengan sebuah metode di dalam superkelasnya, maka metode di
dalam subkelas dikatakan perlu mendefinisikan-ulang (override) metode yang ada di dalam superkelas. Tulislah program
untuk mengilustrasikan situasi ini.
Penyelesaian
// mendefinisikan-ulang metode.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// menampilkan i dan j
void tampil() {
System.out.println("i dan j: " + i + " " +
j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// menampilkan k – ini
mendefinisikan-ulang tampil() di dalam A
void tampil() {
System.out.println("k: " + k);
}
}
public class
PendefinisianUlangMetode {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.tampil(); // ini
memanggil tampil() di dalam B
}
}
Keluaran Program
k: 3
10.
Pada
soal no 9, jika Anda ingin mengakses versi superkelas dari metode yang
didefinisikan-ulang, maka Anda dapat melakukannya menggunakan super. Tulislah program untuk
mengilustrasikan situasi ini.
Penyelesaian
// mendefinisikan-ulang metode.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// menampilkan i dan j
void tampil() {
System.out.println("i dan j: " + i + " " +
j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// menampilkan k – ini
mendefinisikan-ulang tampil() di dalam A
void tampil() {
super.tampil(); // ini memanggil tampil() di dalam A
System.out.println("k: " + k);
}
}
public class
PendefinisianUlangMetode2 {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.tampil(); // ini
memanggil tampil() di dalam B
}
}
Keluaran Program
i dan j: 1 2
k: 3
11.
Pendefinisian-ulang
hanya terjadi ketika nama dan sidik tipe (jumlah dan tipe parameter) dari kedua
metode sama. Jika tidak, maka kedua metode hanya dioverload. Tulislah program untuk mengilustrasikan situasi ini.
Penyelesaian
// Metode-metode dengan sidik tipe berbeda akan dioverload.
// Bukan didefinisikan-ulang.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// menampilkan i dan j
void tampil() {
System.out.println("i dan j: " + i + " " +
j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// mengoverload tampil()
void tampil(String
pesan) {
System.out.println(pesan +
k);
}
}
public class
PewarisanMetodeOverload {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.tampil("Ini adalah k: "); // ini memanggil
tampil() di dalam B
subOb.tampil(); // ini
memanggil tampil() di dalam A
}
}
Keluaran Program
Ini adalah k: 3
i dan j: 1 2
12.
Tulis
dan ujilah sebuah program lain dimana di dalamnya pendefinisian-ulang metode dipakai
dalam konteks pewarisan.
Penyelesaian
class Bangun {
double dim1;
double dim2;
Bangun(double a, double b) {
dim1 = a;
dim2 = b;
}
double luas() {
System.out.println("Luas bangun tidak terdefinisi.");
return 0;
}
}
class PersegiPanjang extends Bangun
{
PersegiPanjang(double a, double b) {
super(a, b);
}
// mendefinisikan-ulang luas
untuk persegipanjang
double luas() {
System.out.println("Luas untuk PersegiPanjang.");
return dim1 * dim2;
}
}
class Segitiga extends Bangun {
Segitiga(double a, double b) {
super(a, b);
}
// mendefinisikan-ulang luas
untuk segitiga
double luas() {
System.out.println("Luas untuk Segitiga.");
return dim1 * dim2 / 2;
}
}
class PewarisanLuas {
public static void main(String args[]) {
Bangun f = new Bangun(10, 10);
PersegiPanjang r = new PersegiPanjang(9, 5);
Segitiga t = new Segitiga(10, 8);
Bangun bangunf;
bangunf = r;
System.out.println("Luas adalah " + bangunf.luas());
bangunf = t;
System.out.println("Luas adalah " + bangunf.luas());
bangunf = f;
System.out.println("Luas adalah " + bangunf.luas());
}
}
Keluaran Program
Luas untuk PersegiPanjang.
Luas adalah 45.0
Luas untuk Segitiga.
Luas adalah 40.0
Luas bangun tidak terdefinisi.
Luas adalah 0.0
13.
Sembarang
kelas yang memuat satu atau lebih metode abstrak harus dideklarasikan abstrak.
Untuk mendeklarasikan sebuah kelas abstrak, Anda hanya perlu menggunakan
katakunci abstract di depan
katakunci class di awal deklarasi
kelas. Tidak ada objek yang bisa diciptakan dari kelas abstrak. Jadi, kelas
abstrak tidak dapat secara langsung diinstansiasi dengan operator new. Selain itu, Anda tidak dapat
mendeklarasikan konstruktor abstrak, atau metode statik abstrak. Setiap
subkelas yang mewarisi kelas superkelas abstrak harus mengimplementasikan semua
metode abstrak pada superkelasnya, atau jika tidak setiap subkelas tersebut
harus dideklarasikan abstrak juga. Tulislah program untuk mengilustrasikan
situasi ini.
Penyelesaian
// Demonstrasik kelas abstrak sederhana.
abstract class A {
abstract void
panggilSaya();
// metode konkrit masih
diperbolehkan di dalam kelas abstrak
void panggilSayaJuga() {
System.out.println("Ini adalah sebuah metode konkrit.");
}
}
class B extends A {
void panggilSaya() {
System.out.println("Implementasi untuk metode abstrak
panggilSaya.");
}
}
class DemoKelasAbstrak {
public static void main(String args[]) {
B b = new B();
b.panggilSaya();
b.panggilSayaJuga();
}
}
Keluaran Program
Implementasi untuk metode abstrak panggilSaya.
Ini adalah sebuah metode konkrit.
14.
Dengan
sebuah kelas abstrak, Anda dapat memperbaiki kelas Bangun yang telah didefinisikan pada soal no 12.
Penyelesaian
//menggunakan metode dan kelas abstrak
abstract class
Bangun {
double dim1;
double dim2;
Bangun(double a, double b) {
dim1 = a;
dim2 = b;
}
// luas sekarang menjai metode
abstrak
abstract double luas();
}
class PersegiPanjang extends Bangun {
PersegiPanjang(double a, double b) {
super(a, b);
}
// mendefinisikan-ulang luas
untuk persegipanjang
double luas() {
System.out.println("Luas untuk PersegiPanjang.");
return dim1 * dim2;
}
}
class Segitiga extends Bangun {
Segitiga(double a, double b) {
super(a, b);
}
// mendefinisikan-ulang luas
untuk segitiga
double luas() {
System.out.println("Luas untuk Segitiga.");
return dim1 * dim2 / 2;
}
}
public class
KelasBangunAbstrak {
public static void main(String args[]) {
// Bangun f = new Bangun(10, 10); // sekarang ilegal
PersegiPanjang r = new
PersegiPanjang(9, 5);
Segitiga t = new Segitiga(10, 8);
Bangun bangunf; // ini OK,
tidak ada objek yang diciptakan
bangunf = r;
System.out.println("Luas adalah " + bangunf.luas());
bangunf = t;
System.out.println("Luas adalah " + bangunf.luas());
}
}
Keluaran Program
Luas untuk PersegiPanjang.
Luas adalah 45.0
Luas untuk Segitiga.
Luas adalah 40.0
No comments:
Post a Comment