.jpeg)
Pengenalan Pemrograman 1 1
BAB 11
Pewarisan, Polimorfisme, dan Interface
11.1 Tujuan
Dalam bagian ini, kita akan membicarakan bagaimana suatu class dapat mewariskan sifat
dari class yang sudah ada. Class ini dinamakan subclass dan induk class dinamakan
superclass. Kita juga akan membicarakan sifat khusus dari Java dimana kita dapat secara
otomatis memakai method yand tepat untuk setiap object tanpa memperhatikan asal dari
subclass object. Sifat ini dinamakan polimorfisme. Pada akhirnya, kita akan mendiskusikan
tentang interface yang membantu mengurangi penulisan program.
Pada akhir pembelajaran ini, siswa harus mampu untuk:
• Mendefinisikan superclasses dan subclasses
• Override method dari superclasses
• Membuat method final dan class final
11.2 Pewarisan
Dalam Java, semua class, termasuk class yang membangun Java API, adalah subclasses
dari superclass Object. Contoh hirarki class diperlihatkan di bawah ini.
Beberapa class di atas class utama dalam hirarki class dikenal sebagai superclass.
Sementara beberapa class di bawah class pokok dalam hirarki class dikenal sebagai
subclass dari class tersebut.
Gambar 1: Hirarki class
Pewarisan adalah keuntungan besar dalam pemrograman berbasis object karena suatu
sifat atau method didefinisikan dalam superclass, sifat ini secara otomatis diwariskan dari
semua subclasses. Jadi, Anda dapat menuliskan kode method hanya sekali dan mereka
Pengenalan Pemrograman 1 2
dapat digunakan oleh semua subclass. Subclass hanya butuh mengimplementasikan
perbedaannya sendiri dan induknya.
11.2.1 Mendefinisikan Superclass dan Subclass
Untuk memperoleh suatu class, kita menggunakan kata kunci extend. Untuk
mengilustrasikan ini, kita akan membuat contoh class induk. Dimisalkan kita mempunyai
class induk yang dinamakan Person.
public class Person
{
protected String name;
protected String address;
/**
* Default constructor
*/
public Person(){
System.out.println(“Inside Person:Constructor”);
name = "";
address = "";
}
/**
* Constructor dengan dua parameter
*/
public Person( String name, String address ){
this.name = name;
this.address = address;
}
/**
* Method accessor
*/
public String getName(){
return name;
}
public String getAddress(){
return address;
}
public void setName( String name ){
this.name = name;
}
public void setAddress( String add ){
this.address = add;
}
}
Pengenalan Pemrograman 1 3
Perhatikan bahwa atribut name dan address dideklarasikan sebagai protected. Alasannya
kita melakukan ini yaitu, kita inginkan atribut-atribut ini untuk bisa diakses oleh subclasses
dari superclassess. Jika kita mendeklarasikan sebagai private, subclasses tidak dapat
menggunakannya. Catatan bahwa semua properti dari superclass yang dideklarasikan
sebagai public, protected dan default dapat diakses oleh subclasses-nya.
Sekarang, kita ingin membuat class lain bernama Student. Karena Student juga sebagai
Person, kita putuskan hanya meng-extend class Person, sehingga kita dapat mewariskan
semua properti dan method dari setiap class Person yang ada. Untuk melakukan ini, kita
tulis,
public class Student extends Person
{
public Student(){
System.out.println(“Inside Student:Constructor”);
//beberapa kode di sini
}
// beberapa kode di sini
}
Ketika object Student di-instantiate, default constructor dari superclass secara mutlak
meminta untuk melakukan inisialisasi yang seharusnya. Setelah itu, pernyataan di dalam
subclass dieksekusi. Untuk mengilustrasikannya, perhatikan kode berikut,
public static void main( String[] args ){
Student anna = new Student();
}
Dalam kode ini, kita membuat sebuah object dari class Student. Keluaran dari program
adalah,
Inside Person:Constructor
Inside Student:Constructor
Gambar 2: Alur Program
Pengenalan Pemrograman 1 4
Alur program ditunjukkan sebagai berikut.
11.2.2 Kata Kunci Super
Subclass juga dapat memanggil constructor secara explicit dari superclass terdekat. Hal ini
dilakukan dengan pemanggil construktor super. Pemanggil constructor super dalam
constructor dari subclass akan menghasilkan eksekusi dari superclass constructor yang
bersangkutan, berdasar dari argumen sebelumnya.
Sebagai contoh, pada contoh class sebelumnya. Person dan Student, kita tunjukkan contoh
dari pemanggil constructor super. Diberikan kode berikut untuk Student,
public Student(){
super( "SomeName", "SomeAddress" );
System.out.println("Inside Student:Constructor");
}
Kode ini memanggil constructor kedua dari superclass terdekat(yaitu adalah Person) dan
mengeksekusinya. Contoh kode lain ditunjukkan sebagai berikut,
public Student(){
super();
System.out.println("Inside Student:Constructor");
}
Pengenalan Pemrograman 1 5
Kode ini memanggil default constructor dari superclass terdekat(yaitu Person) dan
mengeksekusinya.
Ada beberapa hal yang harus diingat ketika menggunakan pemanggil konstuktor super:
1. Pemanggil super() HARUS DIJADIKAN PERNYATAAN PERTAMA DALAM constructor.
2. Pemanggil super() hanya dapat digunakan dalam definisi constructor.
3. Termasuk constructor this() dan pemanggil super() TIDAK BOLEH TERJADI DALAM
constructor YANG SAMA.
Pemakaian lain dari super adalah untuk menunjuk anggota dari superclass(seperti referensi
this). Sebagai contoh,
public Student()
{
super.name = “somename”;
super.address = “some address”;
}
11.2.3 Overriding Method
Untuk beberapa pertimbangan, kadang-kadang class asal perlu mempunyai implementasi
berbeda dari method yang khusus dari superclass tersebut. Oleh karena itulah, method
overriding digunakan. Subclass dapat mengesampingkan method yang didefinisikan dalam
superclass dengan menyediakan implementasi baru dari method tersebut.
Misalnya kita mempunyai implementasi berikut untuk method getName dalam superclass
Person,
public class Person
{
:
:
public String getName(){
System.out.println("Parent: getName");
return name;
}
:
}
Untuk override, method getName dalam subclass Student, kita tulis,
public class Student extends Person
{
:
:
public String getName(){
System.out.println("Student: getName");
return name;
}
Pengenalan Pemrograman 1 6
:
}
Jadi, ketika kita meminta method getName dari object class Student, method overridde
akan dipanggil, keluarannya akan menjadi,
Student: getName
11.2.4 Method final dan class final
Dalam Java, juga memungkinkan untuk mendeklarasikan class-class yang tidak lama
menjadi subclass. Class ini dinamakan class final. Untuk mendeklarasikan class untuk
menjadi final kita hanya menambahkan kata kunci final dalam deklarasi class. Untuk
contohnya, jika kita ingin class Person untuk dideklarasikan final, kita tulis,
public final class Person
{
//area kode
}
Beberapa class dalam Java API dideklarasikan secara final untuk memastikan sifatnya tidak
dapat di-override. Contoh-contoh dari class ini adalah Integer, Double, dan String.
Ini memungkinkan dalam Java membuat method yang tidak dapat di-override. Method ini
dapat kita panggil method final. Untuk mendeklarasikan method untuk menjadi final, kita
tambahkan kata kunci final ke dalam deklarasi method. Contohnya, jika kita ingin method
getName dalam class Person untuk dideklarasikan final, kita tulis,
public final String getName(){
return name;
}
Method static juga secara otomatis final. Ini artinya Anda tidak dapat membuatnya
override.
Pengenalan Pemrograman 1 7
11.3 Polimorfisme
Sekarang, class induk Person dan subclass Student dari contoh sebelumnya, kita
tambahkan subclass lain dari Person yaitu Employee. Di bawah ini adalah hierarkinya,
Person
Student Employee
Dalam Java, kita dapat membuat referensi yang merupakan tipe dari superclass ke sebuah
object dari subclass tersebut. Sebagai contohnya,
public static main( String[] args )
{
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person menunjuk kepada
// object Student
//beberapa kode di sini
}
Sekarang dimisalkan kita punya method getName dalam superclass Person kita, dan kita
override method ini dalam kedua subclasses Student dan Employee,
public class Person
{
public String getName(){
System.out.println(“Person Name:” + name);
return name;
}
}
public class Student extends Person
{
public String getName(){
System.out.println(“Student Name:” + name);
return name;
}
}
Gambar 3: Hirarki dari class induk Person
Pengenalan Pemrograman 1 8
public class Employee extends Person
{
public String getName(){
System.out.println(“Employee Name:” + name);
return name;
}
Kembali ke method utama kita, ketika kita mencoba memanggil method getName dari
referensi Person ref, method getName dari object Student akan dipanggil. Sekarang, jika
kita berikan ref ke object Employee, method getName dari Employee akan dipanggil.
public static main( String[] args )
{
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person menunjuk kepada
// object Student
String temp = ref.getName(); //getName dari Student
//class dipanggil
System.out.println( temp );
ref = employeeObject; //Person menunjuk kepada
// object Employee
String temp = ref.getName(); //getName dari Employee
//class dipanggil
System.out.println( temp );
}
Kemampuan dari referensi untuk mengubah sifat menurut object apa yang dijadikan acuan
dinamakan polimorfisme. Polimorfisme menyediakan multiobject dari subclasses yang
berbeda untuk diperlakukan sebagai object dari superclass tunggal, secara otomatis
menunjuk method yang tepat untuk menggunakannya ke particular object berdasar
subclass yang termasuk di dalamnya.
Contoh lain yang menunjukkan properti polimorfisme adalah ketika kita mencoba melalui
referensi ke method. Misalkan kita punya method statis printInformation yang
mengakibatkan object Person sebagai referensi, kita dapat me-referensi dari tipe Employee
dan tipe Student ke method ini selama itu masih subclass dari class Person.
public static main( String[] args )
{
Student studentObject = new Student();
Employee employeeObject = new Employee();
printInformation( studentObject );
printInformation( employeeObject );
}
Pengenalan Pemrograman 1 9
public static printInformation( Person p ){
. . . .
}
11.4 Abstract Class
Misalnya kita ingin membuat superclass yang mempunyai method tertentu yang berisi
implementasi, dan juga beberapa method yang akan di-overridden oleh subclasses nya.
Sebagai contoh, kita akan membuat superclass bernama LivingThing. class ini mempunyai
method tertentu seperti breath, eat, sleep, dan walk. Akan tetapi, ada beberapa method di
dalam superclass yang sifatnya tidak dapat digeneralisasi. Kita ambil contoh, method walk.
Tidak semua kehidupan berjalan(walk) dalam cara yang sama. Ambil manusia sebagai
misal, kita manusia berjalan dengan dua kaki, dimana kehidupan lainnya seperti anjing
berjalan dengan empat kaki. Akan tetapi, beberapa ciri umum dalam kehidupan sudah
biasa, itulah kenapa kita inginkan membuat superclass umum dalam hal ini.
Kita dapat membuat superclass yang mempunyai beberapa method dengan implementasi
sedangkan yang lain tidak. Class jenis ini yang disebut dengan class abstract.
Sebuah class abstract adalah class yang tidak dapat di-instantiate. Seringkali muncul di
atas hirarki class pemrograman berbasis object, dan mendefinisikan keseluruhan aksi yang
mungkin pada object dari seluruh subclasses dalam class.
Method ini dalam class abstract yang tidak mempunyai implementasi dinamakan method
abstract. Untuk membuat method abstract, tinggal menulis deklarasi method tanpa tubuh
class dan digunakan menggunakan kata kunci abstract. Contohnya,
public abstract void someMethod();
Gambar 4: class abstract
Pengenalan Pemrograman 1 10
Sekarang mari membuat contoh class abstract.
public abstract class LivingThing
{
public void breath(){
System.out.println("Living Thing breathing...");
}
public void eat(){
System.out.println("Living Thing eating...");
}
/**
* abstract method walk
* Kita ingin method ini di-overridden oleh subclasses
*/
public abstract void walk();
}
Ketika class meng-extend class abstract LivingThing, dibutuhkan untuk override method
abstract walk(), atau lainnya, juga subclass akan menjadi class abstract, oleh karena itu
tidak dapat di-instantiate. Contohnya,
public class Human extends LivingThing
{
System.out.println("Human walks...");
public void walk(){
}
}
Jika class Human tidak dapat overridde method walk, kita akan menemui pesan error
berikut ini,
Human.java:1: Human is not abstract and does not override
abstract method walk() in LivingThing
public class Human extends LivingThing
^
1 error
Petunjuk penulisan program:
Gunakan class abstract untuk mendefinisikan secara luas sifat-sifat dari class
tertinggi pada hirarki pemrograman berbasis object, dan gunakan subclassesnya
untuk menyediakan rincian dari class abstract.
Pengenalan Pemrograman 1 11
11.5 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.
11.5.1 Kenapa Kita Memakai Interface?
Kita akan menggunakan interface jika kita ingin class yang tidak berhubungan
mengimplementasikan method yang sama. Melalui interface-interface, kita dapat
menangkap kemiripan diantara class yang tidak berhubungan tanpa membuatnya seolah-
olah class yang berhubungan.
Mari kita ambil contoh class Line dimana berisi method yang menghitung panjang dari
garis dan membandingkan object Line ke object dari class yang sama. Sekarang, misalkan
kita punya class yang lain yaitu MyInteger dimana berisi method yang membandingkan
object MyInteger ke object dari class yang sama. Seperti yang kita lihat disini, kedua
class-class mempunyai method yang mirip dimana membandingkan mereka dari object lain
dalam tipe yang sama, tetapi mereka tidak berhubungan sama sekali. Supaya dapat
menjalankan cara untuk memastikan bahwa dua class-class ini mengimplementasikan
beberapa method dengan tanda yang sama, kita dapat menggunakan sebuah interface
untuk hal ini. Kita dapat membuat sebuah class interface, katakanlah interface Relation
dimana mempunyai deklarasi method pembanding. Relasi interface dapat dideklarasikan
sebagai,
public interface Relation
{
public boolean isGreater( Object a, Object b);
public boolean isLess( Object a, Object b);
public boolean isEqual( Object a, Object b);
}
Alasan lain dalam menggunakan interface pemrograman object adalah untuk menyatakan
sebuah interface pemrograman object tanpa menyatakan classnya. Seperti yang dapat kita
lihat nanti dalam bagian Interface vs class, kita dapat benar-benar menggunakan interface
sebagai tipe data.
Pada akhirnya, kita perlu menggunakan interface untuk pewarisan model jamak dimana
menyediakan class untuk mempunyai lebih dari satu superclass. Pewarisan jamak tidak
ditunjukkan di Java, tetapi ditunjukkan di bahasa berorientasi object lain seperti C++.
Pengenalan Pemrograman 1 12
11.5.2 Interface vs. Class Abstract
Berikut ini adalah perbedaan utama antara sebuah interface dan sebuah class abstract:
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.
11.5.3 Interface vs. Class
Satu ciri umum dari sebuah interface dan class adalah pada tipe mereka berdua. Ini artinya
bahwa sebuah interface dapat digunakan dalam tempat-tempat dimana sebuah class dapat
digunakan. Sebagai contoh, diberikan class Person dan interface PersonInterface, berikut
deklarasi yang benar:
PersonInterface pi = new Person();
Person pc = new Person();
Bagaimanapun, Anda tidak dapat membuat instance dari sebuah interface.
Contohnya:
PersonInterface pi = new PersonInterface(); //COMPILE
//ERROR!!!
Ciri umum lain adalah baik interface maupun class dapat mendefinisikan method.
Bagaimanapun, sebuah interface tidak punya sebuah kode implementasi sedangkan class
memiliki salah satunya.
11.5.4 Membuat Interface
Untuk membuat interface, kita tulis,
public interface [InterfaceName]
{
//beberapa method tanpa isi
}
Sebagai contoh, mari kita membuat sebuah interface yang mendefinisikan hubungan antara
dua object menurut urutan asli dari object.
public interface Relation
{
public boolean isGreater( Object a, Object b);
public boolean isLess( Object a, Object b);
public boolean isEqual( Object a, Object b);
}
Pengenalan Pemrograman 1 13
Sekarang, penggunaan interface, kita gunakan kata kunci implements. Contohnya,
/**
* Class ini mendefinisikan segmen garis
*/
public class Line implements Relation
{
private double x1;
private double x2;
private double y1;
private double y2;
public Line(double x1, double x2, double y1, double y2){
this.x1 = x1;
this.x2 = x2;
this.y1 = y1;
this.y2 = y2;
}
public double getLength(){
double length = Math.sqrt((x2-x1)*(x2-x1) +
(y2-y1)* (y2-y1));
return length;
}
public boolean isGreater( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen > bLen);
}
public boolean isLess( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen < bLen);
}
public boolean isEqual( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen == bLen);
}
}
Pengenalan Pemrograman 1 14
Ketika class Anda mencoba mengimplementasikan sebuah interface, selalu pastikan bahwa
Anda mengimplementasikan semua method dari interface, jika tidak, Anda akan
menemukan kesalahan ini,
Line.java:4: Line is not abstract and does not override abstract
method isGreater(java.lang.Object,java.lang.Object) in
Relation
public class Line implements Relation
^
1 error
11.5.5 Hubungan dari Interface ke Class
Seperti yang telah kita lihat dalam bagian sebelumnya, class dapat mengimplementasikan
sebuah interface selama kode implementasi untuk semua method yang didefinisikan dalam
interface tersedia.
Hal lain yang perlu dicatat tentang hubungan antara interface ke class-class yaitu, class
hanya dapat mengEXTEND SATU superclass, tetapi dapat mengIMPLEMENTASIkan BANYAK
interface. Sebuah contoh dari sebuah class yang mengimplementasikan interface adalah,
public class Person implements PersonInterface,
LivingThing,
WhateverInterface {
//beberapa kode di sini
}
Contoh lain dari class yang meng-extend satu superclass dan mengimplementasikan
sebuah interface adalah,
public class ComputerScienceStudent extends Student
implements PersonInterface,
LivingThing {
//beberapa kode di sini
}
Catatan bahwa sebuah interface bukan bagian dari hirarki pewarisan class. Class yang tidak
berhubungan dapat mengimplementasikan interface yang sama.
Petunjuk penulisan program:
Gunakan interface untuk mendefinisikan method standar yang sama dalam class-
class berbeda yang memungkinkan. Sekali Anda telah membuat kumpulan definisi
method standar, Anda dapat menulis method tunggal untuk memanipulasi semua class-
class yang mengimplementasikan interface.
Pengenalan Pemrograman 1 15
11.5.6 Pewarisan Antar Interface
Interface bukan bagian dari hirarki class. Bagaimanapun, interface dapat mempunyai
hubungan pewarisan antara mereka sendiri. Contohnya, misal kita punya dua interface
StudentInterface dan PersonInterface. Jika StudentInterface meng-extend
PersonInterface, maka ia akan mewariskan semua deklarasi method dalam PersonInterface.
public interface PersonInterface {
. . .
}
public interface StudentInterface extends PersonInterface {
. . .
}
Pengenalan Pemrograman 1 16
11.6 Latihan
11.6.1 Extend StudentRecord
Dalam latihan ini, kita ingin untuk membuat catatan siswa yang lebih khusus yang berisi
informasi tambahan tentang pengetahuan komputer siswa. Tugasnya adalah meng-extend
class StudentRecord yang mengimplementasikan pelajaran sebelumnya. Cobalah untuk
meng-override beberapa method yang ada dalam superclass StudentRecord, jika Anda
benar-benar membutuhkannya.
11.6.2 Bentuk Abstract Class
Cobalah untuk membuat class abstract yang dinamai Shape dengan method abstract
getArea() dan getName(). Tulis dua subclasses-nya yaitu Circle dan Square. Anda dapat
menambahkan method tambahan ke dalam subclasses jika diinginkan.
BAB 12
Dasar Exception Handling
12.1 Tujuan
Dalam bagian ini, kita akan mempelajari teknik yang dipakai dalam Java dalam menangani kondisi
yang tidak biasa dalam menjalankan operasi normal dalam program. Teknik ini dinamakan
exception handling.
Pada akhir pembelajaran, siswa mampu untuk:
• Mendefinisikan exception
• Menangani exception menggunakan blok try-catch-finally
12.2 Apa itu Exception?
Exception adalah sebuah peristiwa yang menjalankan alur proses normal pada program. Peristiwa
ini biasanya berupa kesalahan(error) dari beberapa bentuk. Ini disebabkan program kita berakhir
tidak normal.
Beberapa contoh dari exception yang Anda mungkin jumpai pada latihan-latihan sebelumnya
adalah: exception ArrayIndexOutOfBounds, yang terjadi jika kita mencoba mengakses elemen
array yang tidak ada, atau NumberFormatException, yang terjadi ketika kita mencoba melalui
parameter bukan angka dalam method Integer.parseInt.
12.3 Menangani Exception
Untuk menangani exception dalam Java, kita gunakan blok try-catch-finally. Apa yang kita
lakukan dalam program kita adalah kita menempatkan pernyataan yang mungkin menghasilkan
exception dalam blok ini.
Bentuk umum dari blok try-catch-finally adalah,
try{
//tulis pernyataan yang dapat mengakibatkan exception
//dalam blok ini
}
catch( <exceptionType1> <varName1> ){
//tulis aksi apa dari program Anda yang dijalankan jika ada
//exception tipe tertentu terjadi
}
. . .
Pengenalan Pemrograman 1 1
catch( <exceptionTypen> <varNamen> ){
//tulis aksi apa dari program Anda yang dijalankan jika ada
//exception tipe tertentu terjadi
}
finally{
//tambahkan kode terakhir di sini
}
Exception dilemparkan selama eksekusi dari blok try dapat ditangkap dan ditangani dalam blok
catch. Kode dalam blok finally selalu di-eksekusi.
Berikut ini adalah aspek kunci tentang sintak dari konstruksi try-catch-finally:
• Notasi blok bersifat perintah
• Setiap blok try, terdapat satu atau lebih blok catch, tetapi hanya satu blok finally.
• Blok catch dan blok finally harus selalu muncul dalam konjungsi dengan blok try, dan
diatas urutan
• Blok try harus diikuti oleh paling sedikit satu blok catch ATAU satu blok finally, atau
keduanya.
• Setiap blok catch mendefinisikan sebuah penanganan exception. Header dari blok catch
harus membawa satu argumen, dimana exception pada blok tersebut akan ditangani.
Exception harus menjadi class pelempar atau satu dari subclassesnya.
Pengenalan Pemrograman 1 2
Gambar 1: Alur kejadian blok try-catch-finally
Marilah mengambil contoh kode yang mencetak argumen kedua ketika kita mencoba menjalankan
kode menggunakan argumen command-line. Perkirakan, tidak ada pengecekan dalam kode Anda
untuk angka dari argumen dan kita hanya mengakses argumen kedua args[1] segera, kita akan
mendapatkan exception berikut.
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 1
at ExceptionExample.main(ExceptionExample.java:5)
Untuk mencegah kejadian ini, kita dapat menempatkan kode ke dalam blok try-catch. Blok finally
hanya sebagai pilihan lain saja. Sebagai contoh, kita tidak akan menggunakan blok finally.
public class ExceptionExample
{
public static void main( String[] args ){
try{
System.out.println( args[1] );}catch( ArrayIndexOutOfBoundsException exp ){
System.out.println("Exception caught!");}
}
}
Jadi kita akan menjalankan program lagi tanpa argumen, keluarannya akan menjadi,
Exception caught!
Pengenalan Pemrograman 1 3
12.4 Latihan
12.4.1 Menangkap Exception 1
Diberikan kode berikut:
public class TestExceptions{
public static void main( String[] args ){
for( int i=0; true; i++ ){
System.out.println("args["+i+"]="+
args[i]);
}
}
}
Compile dan jalankan program TestExceptions. Keluarannya akan tampak seperti ini:
javac TestExceptions one two three
args[0]=one
args[1]=two
args[2]=three
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 3
at TestExceptions.main(1.java:4)
Ubah program TestExceptions untuk menangani exception, keluaran program setelah ditangkap
exception-nya akan seperti ini:
javac TestExceptions one two three
args[0]=one
args[1]=two
args[2]=three
Exception caught:
java.lang.ArrayIndexOutOfBoundsException: 3
Quiting...
12.4.2 Menangkap Exception 2
Melakukan percobaan pada beberapa program yang telah Anda tulis adalah hal yang baik sebelum
menghadapi exception. Karena pada program di atas Anda tidak menangkap exception, maka
eksekusi dengan mudahnya berhenti mengeksekusi program Anda. Kembali kepada program
diatas dan gunakan penanganan exception.
Pengenalan Pemrograman 1 4
Bab 1
Review Konsep Dasar dalam Java
1.1 Tujuan
Sebelum melangkah pada fitur-fitur menarik yang ada pada Java, mari kita meninjau beberapa
hal yang telah Anda pelajari pada pelajaran pemograman pertama Anda. Pelajaran ini menyajikan
diskusi tentang perbedaan konsep-konsep berorientasi object dalam Java.
Sebelum melengkapi pelajaran ini, Anda sebaiknya mampu untuk:
1. Mengetahui dan menggunakan konsep dasar beorientasi object.
• class
• object
• atribut
• method
• konstruktor
2. Mengetahui dengan jelas tentang konsep lanjutan berorientasi object dan menggunakannya
dengan baik
• package
• enkapsulasi
• abstraksi
• pewarisan
• polimorfisme
• interface
3. Mengetahui dengan jelas penggunaan kata kunci this, super, final dan static
4. Membedakan antara method overloading dan method overridding
1.2 Konsep Berorientasi object
1.2.1 Desain Berorientasi object
Desain berorientasi object adalah sebuah teknik yang memfokuskan desain pada object dan class
berdasarkan pada skenario dunia nyata. Hal ini menegaskan keadaan(state), behaviour dan
interaksi dari object. Selain itu juga menyediakan manfaat akan kebebasan pengembangan,
meningkatkan kualitas, mempermudah pemeliharaan, mempertinggi kemampuan dalam
modifikasi dan meningkatkan penggunaan kembali software.
Pengenalan Pemrograman 2 1
1.2.2 Class
Class mengizinkan Anda dalam mendeklarasikan tipe data baru. Ia dijalankan sebagai blueprint,
dimana model dari object yang Anda buat berdasarkan pada tipe data baru ini.
1.2.3 Object
Sebuah object adalah sebuah entiti yang memiliki keadaan, behaviour dan identitas yang yang
tugasnya dirumuskan dalam suatu lingkup masalah dengan baik. Inilah instance sebenarnya dari
sebuah class. Ini juga dikenal sebagai instance. Instance dibuat sewaktu Anda meng-instantiate
class menggunakan kata kunci new. Dalam sistem registrasi siswa, contoh dari sebuah object
yaitu entiti Student.
1.2.4 Atribut
Atribut menunjuk pada elemen data dari sebuah object. Atribut menyimpan informasi tentang
object. Dikenal juga sebagai member data, variabel instance, properti atau sebuah field data.
Kembali lagi ke contoh sistem registrasi siswa, atribut dari sebuah siswa adalah nomor siswa.
1.2.5 Method
Sebuah method menjelaskan behaviour dari sebuah object. Method juga dikenal sebagai fungsi
atau prosedur. Sebagai contoh, method yang mungkin tersedia untuk entiti siswa adalah method
register.
1.2.6 Konstruktor
Konstruktor adalah sebuah tipe khusus dari method yang digunakan untuk membuat dan
menginisialisasi sebuah object baru. Ingat bahwa konstruktor bukan member(yaitu atribut,
method atau inner class dari sebuah object).
1.2.7 Package
Package menunjuk pada pengelompokkan class dan/atau subpackages. Strukturnya dapat
disamakan dengan direktorinya.
1.2.8 Enkapsulasi
Enkapsulasi menunjuk pada prinsip dari menyembunyikan desain atau mengimplementasikan
informasi yang tidak sesuai pada object yang ada.
1.2.9 Abstraksi
Sementara enkapsulasi menyembunyikan detail, abstraksi mengabaikan aspek dari subyek yang
tidak sesuai dengan tujuan yang ada supaya lebih banyak mengkonsentrasikan yang ada.
1.2.10 Pewarisan
Pewarisan adalah hubungan antara class dimana dalam satu class ada superclass atau class induk
dari class yang lain. Pewarisan menunjuk pada properti dan behaviour yang diterima dari nenek
Pengenalan Pemrograman 2 2
moyang dari class. Ini dikenal juga sebagai hubungan “is-a”. Perhatikan pada hirarki berikut.
Gambar 1.1: Contoh Pewarisan
SuperHero adalah superclass dari class FlyingSuperHero dan UnderwaterSuperHero. Catatan
bahwa FlyingSuperHero “is-a” SuperHero. Sebagaimana juga UnderwaterSuperHero “is-a”
SuperHero
1.2.11 Polimorfisme
Polimorfisme adalah kemampuan dari sebuah object untuk membolehkan mengambil beberapa
bentuk yang berbeda. Secara harfiah, “poli” berarti banyak sementara “morph” berarti bentuk.
Menunjuk pada contoh sebelumnya pada pewarisan, kita lihat bahwa object SuperHero dapat juga
menjadi object FlyingSuperHero atau object UnderwaterSuperHero.
1.2.12 Interface
Sebuah interface adalah sebuah contract dalam bentuk kumpulan method dan deklarasi
konstanta. Ketika sebuah class implements sebuah interface, ini mengimplementasikan semua
method yang dideklarasikan dalam interface.
1.3 Struktur Program Java
Pada bagian ini meringkaskan syntax dasar yang digunakan dalam pembuatan aplikasi Java.
1.3.1 Mendeklarasikan class Java
<classDeclaration> ::=
<modifier> class <name> {
<attributeDeclaration>*
<constructorDeclaration>*
<methodDeclaration>*
}
dimana <modifier> adalah sebuah access modifier, yang mana boleh dikombinasikan dengan tipe
yang laen dari modifier.
Pengenalan Pemrograman 2 3
SuperHero
FlyingSuperHero UnderwaterSuperHero
Petunjuk Penulisan Program:
* = berarti bahwa boleh ada 0 atau lebih kejadian dari deret tersebut yang menggunakannya
juga.
<description> = menunjukkan bahwa Anda harus mengganti nilai sebenarnya untuk bagian ini
daripada menguranginya penulisannya.
Ingat bahwa untuk class teratas, acces modifier yang valid hanyalah public dan package(yakni
jika tidak ada acces modifier mengawali kata kunci class).
Contoh berikut ini mendeklarasikan blueprint SuperHero.
Class SuperHero {
String superPowers[];
void setSuperPowers(String superPowers[]) {
this.superPowers = superPowers;
}
void printSuperPowers() {
for (int i = 0; i < superPowers.length; i++) {
System.out.println(superPowers[i]);
}
}
}
1.3.2 Mendeklarasikan Atribut
<attributeDeclaration> ::=
<modifier> <type> <name> [= <default_value>];
<type> ::=
byte | short | int | long | char | float | double | boolean
| <class>
Petunjuk Penulisan Program:
[] = Menunjukkan bahwa bagian ini hanya pilihan.
Inilah contohnya.
public class AttributeDemo {
private String studNum;
public boolean graduating = false;
protected float unitsTaken = 0.0f;
String college;
}
1.3.3 Mendeklarasikan Method
<methodDeclaration> ::=
<modifier> <returnType> <name>(<parameter>*) {
<statement>*
}
<parameter> ::=
<parameter_type> <parameter_name>[,]
Pengenalan Pemrograman 2 4
Sebagai contoh:
class MethodDemo {
int data;
int getData() {
return data;
}
void setData(int data) {
this.data = data;
}
void setMaxData(int data1, int data2) {
data = (data1>data2)? data1 : data2;
}
}
1.3.4 Mendeklarasikan sebuah Konstruktor
<constructorDeclaration> ::=
<modifier> <className> (<parameter>*) {
<statement>*
}
Jika tidak ada konstruktor yang disediakan secara jelas, konstruktor default secara otomatis
membuatkannya untuk Anda. Konstruktor default tidak membawa argumen dan tidak berisi
pernyataan pada tubuh class.
Petunjuk Penulisan Program:
Nama konstruktor harus sama dengan nama class.
<modifier> yang valid untuk konstruktor adalah public, protected, dan private.
Konstruktor tidak memiliki nilai return.
Perhatikan contoh berikut.
class ConstructorDemo {
private int data;
public ConstructorDemo() {
data = 100;
}
ConstructorDemo(int data) {
this.data = data;
}
}
1.3.5 Meng-instansiasi sebuah class
Untuk meng-instantiate sebuah class, dengan sederhana kita gunakan kata kunci new diikuti
dengan pemanggilan sebuah konstruktor. Mari lihat langsung ke contohnya.
class ConstructObj {
int data;
ConstructObj() {
/* menginisialisasi data */
Pengenalan Pemrograman 2 5
}
public static void main(String args[]) {
ConstructObj obj = new ConstructObj(); //di-instantiate
}
}
1.3.6 Mengakses Anggota object
Untuk mengakses anggota dari sebuah object, kita gunakan notasi “dot”. Penggunaanya seperti
berikut:
<object>.<member>
Contoh selanjutnya berdasar pada sebelumnya dengan pernyataan tambahan untuk mengakses
anggota dan method tambahan.
class ConstructObj {
int data;
ConstructObj() {
/* inisialisasi data */
}
void setData(int data) {
this.data = data;
}
public static void main(String args[]) {
ConstructObj obj = new ConstructObj(); //instantiation
obj.setData = 10; //access setData()
System.out.println(obj.data); //access data
}
}
1.3.7 Package
Untuk menunjukkan bahwa file asal termasuk package khusus, kita gunakan syntax berikut:
<packageDeclaration> ::=
package <packageName>;
Untuk mengimpor package lain, kita gunakan syntax berikut:
<importDeclaration> ::=
import <packageName.elementAccessed>;
Dengan ini, source code Anda harus memiliki format berikut:
[<packageDeclaration>]
<importDeclaration>*
<classDeclaration>+
Pengenalan Pemrograman 2 6
Petunjuk Penulisan Program:
+ menunjukkan bahwa boleh ada 1 atau lebih kejadian pada baris ini dalam pengaplikasiannya.
Sebagai contoh.
package registration.reports;
import registration.processing.*;
import java.util.List;
import java.lang.*; //imported by default
class MyClass {
/* rincian dari MyClass */
1.3.8 Acces Modifier
Table berikut meringkas acces modifier dalam Java.
private default/package protected public
class yang sama Yes Yes Yes Yes
package yang sama Yes Yes Yes
package yang
berbeda (subclass)
Yes Yes
package yang
berbeda (non-
subclass)
Yes
Tabel 1.2: Acces Modifier
1.3.9 Enkapsulasi
Menyembunyikan elemen dari penggunaan sebuah class dapat dilakukan dengan pembuatan
anggota yang ingin Anda sembunyikan secara private.
Contoh berikut menyembunyikan field secret. Catatan bahwa field ini tidak langsung diakses oleh
program lain menggunakan method getter dan setter.
class Encapsulation {
private int secret; //field tersembunyi
public boolean setSecret(int secret) {
if (secret < 1 || secret > 100) {
return false;
}
this.secret = secret;
return true;
}
public getSecret() {
return secret;
}
}
Pengenalan Pemrograman 2 7
1.3.10 Pewarisan
Untuk membuat class anak atau subclass berdasarkan class yang telah ada, kita gunakan kata
kunci extend dalam mendeklarasikan class. Sebuah class hanya dapat meng-extend satu class
induk.
Sebagai contoh, class Point di bawah ini adalah superclass dari class ColoredPoint.
import java.awt.*;
class Point {
int x;
int y;
}
class ColoredPoint extends Point {
Color color;
}
1.3.11 Method Overriding
Method subclass override terhadap method superclass ketika subclass mendeklarasikan method
yang signaturenya serupa ke method dalam superclass. Signature dari method hanyalah informasi
yang ditemukan dalam definisi method bagian atas. Signature mengikutkan tipe return, nama dan
daftar parameter method tetapi itu tidak termasuk acces modifier dan tipe yang lain dari kata
kunci seperti final dan static.
Inilah perbedaan dari method overloading. Method overloading secara singkat didiskusikan dalam
sub bagian pada kata kunci this.
class Superclass {
void display(int n) {
System.out.println("super: " + n);
}
}
class Subclass extends Superclass {
void display(int k) { //method overriding
System.out.println("sub: " + k);
}
}
class OverrideDemo {
public static void main(String args[]) {
Subclass SubObj = new Subclass();
Superclass SuperObj = SubObj;
SubObj.display(3);
((Superclass)SubObj).display(4);
}
}
Ini akan menghasilkan keluaran sebagai berikut.
sub: 3
sub: 4
Pemanggilan method ditentukan oleh tipe data sebenarnya dari object yang diminta method.
Pengenalan Pemrograman 2 8
Acces modifier untuk method yang dibutuhkan tidak harus sama. Bagaimanapun, acces modifier
dari method overridding mengharuskan salah satunya punya acces modifier yang sama seperti itu
dari method overridden atau acces modifier yang kurang dibatasi.
Perhatikan contoh selanjutnya. Periksa yang mana dari method overridding berikut akan
menyebabkan waktu meng-compile akan menyebabkan error.
class Superclass {
void overriddenMethod() {
}
}
class Subclass1 extends Superclass {
public void overriddenMethod() {
}
}
class Subclass2 extends Superclass {
void overriddenMethod() {
}
}
class Subclass3 extends Superclass {
protected void overriddenMethod() {
}
}
class Subclass4 extends Superclass {
private void overriddenMethod() {
}
}
1.3.12 Class Abstract dan Method
Bentuk umum dari sebuah method abstract adalah sebagai berikut:
abstract <modifier> <returnType> <name>(<parameter>*);
Sebuah class yang berisi method abstract harus dideklarasikan sebagai sebuah class abstract.
abstract <modifier> <returnType> <name>(<parameter>*);abstract class
<name> {
/* constructors, fields and methods */
}
Kata kunci tidak dapat digunakan pada konstruktor atau method static. Ini juga penting untuk
diingat bahwa class abstract tidak dapat di-instantiate.
Class yang meng-extends sebuah class abstract harus mengimplementasikan semua method
abstract. Jika tidak subclass sendiri dapat dideklarasikan sebagai abstract.
Petunjuk Penulisan Program:
catatan bahwa mendeklarasikan sebuah method abstract hampir mirip dalam mendeklarasikan
class normal kecuali itu suatu method abstract yang tidak memiliki tubuh dan kepala sehingga
dengan segera diakhiri dengan semicolon(;).
Pengenalan Pemrograman 2 9
Sebagai contoh:
abstract class SuperHero {
String superPowers[];
void setSuperPowers(String superPowers[]) {
this.superPowers = superPowers;
}
void printSuperPowers() {
for (int i = 0; i < superPowers.length; i++) {
System.out.println(superPowers[i]);
}
}
abstract void displayPower();
}
class UnderwaterSuperHero extends SuperHero {
void displayPower() {
System.out.println("Communicate with sea creatures...");
System.out.println("Fast swimming ability...");
}
}
class FlyingSuperHero extends SuperHero {
void displayPower() {
System.out.println("Fly...");
}
}
1.3.13 Interface
Mendeklarasikan sebuah interface pada dasarnya mendeklarasikan sebuah class tetapi sebagai
penggantinya menggunakan kata kunci class, kata kunci interface digunakan. Berikut syntaxnya.
<interfaceDeclaration> ::=
<modifier> interface <name> {
<attributeDeclaration>*
[<modifier> <returnType> <name>(<parameter>*);]*
}
Anggotanya adalah public ketika interface dideklarasikan public.
Petunjuk Penulisan Program:
Secara mutlak atribut adalah static dan final dan harus diinisialisasi dengan nilai konstanta.
Seperti mendeklarasikan class teratas, acces modifier yang valid hanyalah public dan
package(yakni jika tidak ada acces modifier mengawali kata kunci class).
Class mengimplementasikan sebuah interface yang telah ada dengan menggunakan kata kunci
implements. Class ini dibuat untuk mengimplementasikan semua method interface. Sebuah class
boleh mengimplementasikan lebih dari satu interface.
Pengenalan Pemrograman 2 10
Contoh berikut menunjukkan bagaimana mendeklarasikan dan menggunakan sebuah interface.
interface MyInterface {
void iMethod();
}
class MyClass1 implements MyInterface {
public void iMethod() {
System.out.println("Interface method.");
}
void myMethod() {
System.out.println("Another method.");
}
}
class MyClass2 implements MyInterface {
public void iMethod() {
System.out.println("Another implementation.");
}
}
class InterfaceDemo {
public static void main(String args[]) {
MyClass1 mc1 = new MyClass1();
MyClass2 mc2 = new MyClass2();
mc1.iMethod();
mc1.myMethod();
mc2.iMethod();
}
}
1.3.14 Kata kunci this
Kata kunci this dapat digunakan untuk beberapa alasan berikut:
1. Adanya ambigu pada atribut lokal dari variabel lokal
2. Menunjuk pada object yang meminta method non-static
3. Menunjuk pada konstruktor lain.
Sebagai contoh pada maksud pertama, perhatikan kode berikut dimana variabel data disediakan
sebagai sebuah atribut dan parameter lokal pada saat yang sama.
class ThisDemo1 {
int data;
void method(int data) {
this.data = data;
/* this.data menunjuk ke atribut
sementara data menunjuk ke variabel lokal */
}
}
Pengenalan Pemrograman 2 11
Contoh berikut menunjukkan bagaimana object this secara mutlak menunjuk ketika anggota non-
static dipanggil.
class ThisDemo2 {
int data;
void method() {
System.out.println(data); //this.data
}
void method2() {
method(); //this.method();
}
Sebelum melihat ke contoh yang lain, mari pertama meninjau pengertian method overloading.
Konstruktor seperti juga method dapat juga menjadi overload. Method yang berbeda dalam class
dapat memberi nama yang sama asalkan list parameter juga berbeda. Method overloaded harus
berbeda dalam nomor dan/atau tipe dari parameternya. Contoh selanjutnya memiliki konstruktor
overloaded dan referensi this yang dapat digunakan untuk menunjuk versi lain dari konstruktor.
class ThisDemo3 {
int data;
ThisDemo3() {
this(100);
}
ThisDemo3(int data) {
this.data = data;
}
}
Petunjuk Penulisan Program:
Memanggil this() harus ada pernyataan pertama dalam konstruktor.
1.3.15 Kata kunci super
Penggunaan kata kunci super berhubungan dengan pewarisan. Super digunakan untuk meminta
konstruktor superclass. Super juga dapat digunakan seperti kata kunci this untuk menunjuk pada
anggota dari superclass.
Program berikut mendemonstrasikan bagaimana referensi super digunakan untuk memanggil
konstruktor superclass.
class Person {
String firstName;
String lastName;
Person(String fname, String lname) {
firstName = fname;
lastName = lname;
}
}
class Student extends Person {
String studNum;
Student(String fname, String lname, String sNum) {
Pengenalan Pemrograman 2 12
super(fname, lname);
studNum = sNum;
}
}
Petunjuk Penulisan Program:
super() menunjuk pada superclass dengan segera. Ini harus berada pada pernyataan pertama
dalam konstruktor superclass.
Kata kunci dapat juga digunakan untuk menunjuk anggota superclass seperti yang ditunjukkan
pada contoh berikut.
class Superclass{
int a;
void display_a(){
System.out.println("a = " + a);
}
}
class Subclass extends Superclass {
int a;
void display_a(){
System.out.println("a = " + a);
}
void set_super_a(int n){
super.a = n;
}
void display_super_a(){
super.display_a();
}
}
class SuperDemo {
public static void main(String args[]){
Superclass SuperObj = new Superclass();
Subclass SubObj = new Subclass();
SuperObj.a = 1;
SubObj.a = 2;
SubObj.set_super_a(3);
SuperObj.display_a();
SubObj.display_a();
SubObj.display_super_a();
System.out.println(SubObj.a);
}
}
Program tersebut akan menampilkan hasil berikut.
a = 1
a = 2
a = 3
2
Pengenalan Pemrograman 2 13
1.3.16 Kata Kunci static
Kata kunci static dapat digunakan untuk anggota dari sebuah class. Kata kunci ini menyediakan
static atau anggota class untuk diakses sama sebelum beberapa instance dari class dibuat.
Variabel class bersifat seperti variabel umum. Ini artinya bahwa variabel dapat diakses oleh
semua instance dari class.
Method class mungkin dapat diambil tanpa membuat sebuah object dari class tersebut.
Bagaimanapun, mereka hanya dapat mengakses anggota static dari class. Ditambahkan juga,
mereka tidak dapat menunjuk this dan super.
Kata kunci static dapat juga diaplikasikan pada blok. Ini dinamakan dengan blok static. Blok ini
dieksekusi hanya sekali, ketika class diisi. Hal ini biasanya digunakan untuk menginisialisasi
variabel class.
class Demo {
static int a = 0;
static void staticMethod(int i) {
System.out.println(i);
}
static { //blok static
System.out.println("This is a static block.");
a += 1;
}
}
class StaticDemo {
public static void main(String args[]) {
System.out.println(Demo.a);
Demo.staticMethod(5);
Demo d = new Demo();
System.out.println(d.a);
d.staticMethod(0);
Demo e = new Demo();
System.out.println(e.a);
d.a += 3;
System.out.println(Demo.a+", " +d.a +", " +e.a);
}
}
Keluaran dari source kode ditunjukkan di bawah ini.
This is a static block.
1
5
1
0
1
4, 4, 4
1.3.17 Kata Kunci final
Kata kunci final dapat diaplikasikan pada variabel, method dan class. Untuk mengingat fungsi dari
kata kunci, ingat bahwa itu secara mudah dibatasi apa yang kita dapat lakukan dengan variabel,
method dan class.
Nilai dari variabel final dapat tidak lama diubah sesudah nilainya telah diatur. Sebagai contoh,
Pengenalan Pemrograman 2 14
final int data = 10;
Pernyataan berikut akan menyebabkan terjadi compilation error:
data++;
Method final tidak dapat di-override dalam class anak.
final void myMethod() { //in a parent class
}
myMethod tidak dapat lama di-override dalam class anak.
class final tidak dapat diwariskan tidak seperti class yang biasanya.
final public class MyClass {
}
Petunjuk Penulisan Program:
Perintah penulisan kata kunci final dan public memungkinkan bertukar tempat.
Pernyataan ini akan menyebabkan kesalahan compilation terjadi karena MyClass dapat tidak lama
di-extended.
public WrongClass extends MyClass {
}
1.3.18 Inner Classes
Sebuah inner class secara mudah dideklarasikan dalam class lain.
class OuterClass {
int data = 5;
class InnerClass {
int data2 = 10;
void method() {
System.out.println(data);
System.out.println(data2);
}
}
public static void main(String args[]) {
OuterClass oc = new OuterClass();
InnerClass ic = oc.new InnerClass();
System.out.println(oc.data);
System.out.println(ic.data2);
ic.method();
}
}
Untuk mampu mengakses anggota dari inner class, kita butuh sebuah instance dari inner class.
Method-method dari inner class dapat secara langsung mengakses anggota dari outer class.
Pengenalan Pemrograman 2 15
1.4 Latihan
1.4.1 Tabel Perkalian
Tulis program yang mempunyai masukkan size dari user dan mencetak tabel perkalian dengan
size yang ditetapkan.
Size untuk tabel perkalian : 5
Tabel perkalian dari size 5:
1 2 3 4 5
1 1
2 2 4
3 3 6 9
4 4 8 12 16
5 5 10 15 20 25
1.4.2 Greatest Common Factor(GCF)
Tulis sebuah program yang mempunyai tiga integer dan menghitung nilai GCF dari tiga angka.
GCF adalah angka terbesar yang secara rata dibagi ke semua angka yang diberikan.
Input 1: 25 Input 1: 1 Input 1: 9
Input 2: 15 Input 2: 2 Input 2: 27
Input 3: 35 Input 3: 3 Input 3: 12
GCF: 5 GCF: 1 GCF: 3
1.4.3 Shape
Buatlah class Shape. class memiliki dua field String: name dan size. class mempunyai method
printShapeInfo, dimana hanya mengeluarkan nilai name dan field size dari object Shape. Juga
memiliki method printShapeName dan printShapeSize, dimana mencetak nama dan size dari
object, berturut-turut.
Menggunakan pewarisan, buat class Square dengan field yang sama dan method seperti itu dari
class Shape. Class ini mempunyai dua tambahan field integer: length dan width. Method
printShapeLength dan printShapeWidth yang mencetak panjang dan lebar object yang juga
termasuk dalam class ini. Anda juga harus meng-override printShapeInfo untuk mencetak
keluaran field tambahan dalam subclass juga.
1.4.4 Binatang
Buatlah interface Animal yang mempunyai tiga method:eat dan move. Semua method ini tidak
punya argumen atau nilai return. Method ini hanya mengeluarkan bagaimana object Animal
makan dan bergerak. Sebagai contoh, seekor kelinci memakan wortel dan bergerak dengan
melompat. Buat class Fish dan Bear yang menggunakan interface Animal. Terserah kepada Anda
bagaimana menggunakan method eat dan move.
Pengenalan Pemrograman 2 16
.jpeg&description=Java programming 24){kind=link}