comlab.ilkom.unsri.ac.idcomlab.ilkom.unsri.ac.id/.../2016/10/modul-pbo-tkj-d3.docx · web viewdi...
TRANSCRIPT
MODUL PRAKTIKUM
“PEMROGRAMAN BERORIENTASI OBJEK 1 (JENI 1)”
LABORATORIUM KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS SRIWIJAYA
2015
Universitas Sriwijaya Fakultas Ilmu Komputer Laboratorium
LEMBAR PENGESAHAN MODUL PRAKTIKUM
SISTEM MANAJEMEN MUTU
ISO 9001:2008
No. Dokumen ……. TanggalRevisi 0 Halaman 2 DARI 42
MODUL PRAKTIKUM
Mata Kuliah Praktikum : Pemrograman Berorientasi Objek 1 (JENI 1)
Kode Mata Kuliah Praktikum : FJK14208
SKS : 1Program Studi : Teknik Komputer dan Jaringan Semester : 1(Ganjil)
DIBUAT OLEH DISAHKAN OLEH DIKETAHUI OLEH
TIM LABORAN LABORATORIUM FASILKOM UNSRI
TIM DOSEN TEKNIK KOMPUTER DAN JARINGAN
FASILKOM UNSRI
KEPALA LABORATORIUM
Daftar Isi2
Cover ...................................................................................................... 1
Lembar Pengesahan ................................................................................ 2
Daftar Isi ................................................................................................. 3
Mengenali Lingkungan Pemrograman Anda.......................................... 4
Dasar Dasar Pemrogrmana...................................................................... 5
Input From Key....................................................................................... 12
Struktur Kontrol...................................................................................... 14
Java Array............................................................................................... 18
Argumen Comman Line.......................................................................... 21
Java Class Library................................................................................... 27
Membuat Class Sendiri........................................................................... 30
Pewarisan, Polimorphisme dan Interface................................................ 35
Penanganan Event Handling................................................................... 40
Referensi.................................................................................................. 42
Mengenali Lingkungan Pemrograman Anda
1. Tujuan
3
Membuat program Java menggunakan text editor dan console dalam linux (Ubuntu
Dapper)
Membedakan antara syntax-errors dan runtime-errors
Membuat program Java menggunakan NetBeans
2. Latar BelakangDalam sesi ini, kita akan membahas tentang bagaimana menulis, meng-compile dan
menjalankan(run) program Java. Terdapat 2 cara dalam melakukannya, yang pertama
menggunakan console dan text editor. Sedangkan cara kedua adalah dengan menggunakan
NetBeans yang merupakan Integrated Development Environment atau yang disebut
IDE.IDE adalah sebuah peralatan dalam pemrograman yang diintegrasikan kedalam aplikasi
software yang mendukung pembangunan GUI, text atau penulisan kode, compiler dan
debugger.
Tutorial ini menggunakan Ubuntu Dapper sebagai sistem operasinya. Sebelum
menggunakan tutorial ini, pastikan bahwa telah menginstal Java dan NetBeans dalam sistem
yang anda gunakan. Untuk instruksi dalam bagaimana cara menginstal Java dan NetBeans,
dapat dilihat pada Appendix A. Untuk versi Windows Xp dalam sesi ini, dapat dilihat pada
Appendix B.
Sebelum membahas lebih detail, pada awalnya akan kita lihat program Java pertama yang
akan anda tulis.
3. PercobaanPercobaan 1 HelloWorld :public class Hello { /** * My first java program */ public static void main(String[] args) {
//Menampilkan kata "Hello world" dilayar System.out.println("Hello world!"); } }
Dasar Dasar Pemrograman
1. Tujuan 4
Mengidentifikasi bagian dasar dari program java
Membedakan mana yang termasuk ke dalam java literals, tipe data dasar, tipe
variabel, pengidentifikasian dan operator.
Mengembangkan program java sederhana menggunakan konsep pembelajaran pada
bab ini.
Menganalisa program java pertama
2. Latar BelakangPada bagian ini, kita akan mendiskusikan mengenai bagian dasar pemrograman
java.Kita akan memulai dengan mencoba menjelaskan bagian dasar dari program
Hello.java yang telah diperkenalkan pada bab sebelumnya. Kita juga akan mendiskusikan
beberapa pedoman cara menulis script atau petunjuk penulisan kode dalam penulisan
program lebih efektif dan mudah dibaca.
3. PercobaanPercobaan 1 Menampilkan Data Variabel :public class OutputVariable { public static void main( String[] args ){ int value = 10; char x; x = 'A'; System.out.println( value ); System.out.println("The value of x=" + x ); } }
Percobaan 2 Penggunaan Operator Aritmatika :public class aritmatikaDemo { public static void main(String[] args) { //sedikit angka int i = 37; int j = 42; double x = 27.475; double y = 7.22; System.out.println("Variable values..."); System.out.println(" i = " + i); System.out.println(" j = " + j);
5
System.out.println(" x = " + x); System.out.println(" y = " + y); //penjumlahan angka System.out.println("Adding..."); System.out.println(" i + j = " + (i + j)); System.out.println(" x + y = " + (x + y)); //pengurangan angka System.out.println("Subtracting..."); System.out.println(" i - j = " + (i - j)); System.out.println(" x - y = " + (x - y)); //perkalian angka System.out.println("Multiplying..."); System.out.println(" i * j = " + (i * j)); System.out.println(" x * y = " + (x * y)); //pembagian angka System.out.println("Dividing..."); System.out.println(" i / j = " + (i / j)); System.out.println(" x / y = " + (x / y)); //menghitung hasil modulus dari pembagian System.out.println("Computing the remainder..."); System.out.println(" i % j = " + (i % j)); System.out.println(" x % y = " + (x % y)); //tipe penggabungan System.out.println("Mixing tipes..."); System.out.println(" j + y = " + (j + y)); System.out.println(" i * x = " + (i * x)); } }
Percobaan 3 Penggunaan Operator Relasi: public class RelasiDemo {
6
public static void main(String[] args) { //beberapa nilai int i = 37; int j = 42; int k = 42; System.out.println("Nilai variabel..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" k = " + k); //lebih besar dari System.out.println("Lebih besar dari..."); System.out.println(" i > j = " + (i > j)); //false System.out.println(" j > i = " + (j > i)); //true System.out.println(" k > j = " + (k > j)); //false //lebih besar atau sama dengan System.out.println("Lebih besar dari atau sama dengan..."); System.out.println(" i >= j = " + (i >= j)); //false System.out.println(" j >= i = " + (j >= i)); //true System.out.println(" k >= j = " + (k >= j)); //true //lebih kecil dari System.out.println("Lebih kecil dari..."); System.out.println(" i < j = " + (i < j)); //true System.out.println(" j < i = " + (j < i)); //false System.out.println(" k < j = " + (k < j)); //false //lebih kecil atau sama dengan System.out.println("Lebih kecil dari atau sama dengan..."); System.out.println(" i <= j = " + (i <= j)); //true System.out.println(" j <= i = " + (j <= i)); //false System.out.println(" k <= j = " + (k <= j)); //true //sama dengan System.out.println("Sama dengan..."); System.out.println(" i == j = " + (i == j)); //false System.out.println(" k == j = " + (k == j)); //true //tidak sama dengan System.out.println("Tidak sama dengan..."); System.out.println(" i != j = " + (i != j)); //true System.out.println(" k != j = " + (k != j)); //false } }
7
Percobaan 4 Penggunaan Operator Logika dan Boolean AND: public class TestAND{
public static void main( String[] args ){int i = 0;int j = 10;boolean test= false;//demonstrasi &&test = (i > 10) && (j++ > 9);System.out.println(i);System.out.println(j);System.out.println(test);//demonstrasi &test = (i > 10) & (j++ > 9);System.out.println(i);System.out.println(j);System.out.println(test);}
}
Percobaan 5 Penggunaan Operator Logika dan Boolean OR: public class TestOR{
public static void main( String[] args ){int i = 0;int j = 10;
8
boolean test = false;//demonstrasi ||test = (i < 10) || (j++ > 9);System.out.println(i);System.out.println(j);System.out.println(test);//demonstrasi |test = (i < 10) | (j++ > 9);System.out.println(i);System.out.println(j);System.out.println(test);}
}
Percobaan 6 Penggunaan Operator Logika Eksklusive OR: public class TestXOR{
public static void main( String[] args ){boolean val1 = true;boolean val2 = true;System.out.println(val1 ^ val2);val1 = false;val2 = true;System.out.println(val1 ^ val2);val1 = false;val2 = false;System.out.println(val1 ^ val2);val1 = true;val2 = false;System.out.println(val1 ^ val2);}
}
Percobaan 7 Penggunaan Operator Logika NOT: public class TestNOT{
public static void main( String[] args ){boolean val1 = true;boolean val2 = false;System.out.println(!val1);System.out.println(!val2);}
9
}
Percobaan 8 Penggunaan Operator Kondisi (?:): Contoh 1 :public class kondisiOperator{
public static void main( String[] args ){String status=””;int grade = 80;//mendapatkan status pelajarstatus = (grade >= 60)?"Passed":"Fail";//print statusSystem.out.println( status );}
}
Contoh 2:class kondisiOperator{
public static void main( String[] args ){int score = 0;char answer = 'a';score = (answer == 'a') ? 10 : 0;System.out.println("Score = " + score );}
}
10
Input From Key
1. Tujuan Membuat program Java yang interaktif yang bisa mendapatkan input dari keyboard
Menggunakan kelas BufferedReader untuk mendapatkan input dari keyboard melalui
layar console
Menggunakan kelas JOptionPane untuk mendapatkan input dari keyboard melalui
GUI
2. Latar BelakangKita sudah mempelajari konsep mendasar pada Java dan menulis beberapa program
sederhana. Sekarang kita akan mencoba membuat program kita lebih interaktif dengan
11
menggunakan input dari keyboard. Pada bab ini, kita akan mempelajari dua cara
memberikan input, yang pertama adalah menggunakan kelas BufferedReader dan melalui
GUI (Graphical User Interface) dengan menggunakan kelas JOptionPane.
3. PercobaanPercobaan 1 Menggunakan class BufferedReader: import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class GetInputFromKeyboard{
public static void main( String[] args ){
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in) );
String name = "";System.out.print("Please Enter Your Name:");try{
name = dataIn.readLine();}catch( IOException e ){
System.out.println("Error!");}System.out.println("Hello " + name +"!");
}}
Percobaan 2 MenggunakanJoptionPane: import java.awt.Frame;public class GraphicPanel extends Panel {public GraphicPanel() {
setBackground(Color.black);}public void paint(Graphics g) {
g.setColor(new Color(0,255,0)); //greeng.setFont(new Font("Helvetica",Font.PLAIN,16));g.drawString("Hello GUI World!", 30, 100);g.setColor(new Color(1.0f,0,0)); //redg.fillRect(30, 100, 150, 10);
}public static void main(String args[]) {
Frame f = new Frame("Testing Graphics Panel");GraphicPanel gp = new GraphicPanel();f.add(gp);
12
f.setSize(600, 300);f.setVisible(true);}
}
Struktur Kontrol
1. Tujuan Menggunakan struktur kontrol keputusan (if, else, switch) yang digunakan
untukmemilih blok kode yang akan dieksekusi
Menggunakan struktur kontrol pengulangan (while, do-while, for) yang digunakan
untuk melakukan pengulangan pada blok kode yang akan dieksekusi
Menggunakan statement percabangan (break, continue, return) yang digunakan untuk
mengatur redirection dari program
2. Latar BelakangPada bab sebelumnya, kita sudah mendapatkan contah dari program sequential,
dimana statement dieksekusi setelah statement sebelumnya dengan urutan tertentu. Pada
bagian ini, kita mempelajari tentang struktur kontrol yang bertujuan agar kita dapat
menentukan urutan statement yang akan dieksekusi. Struktur kontrol keputusan adalah
statement dari Java yang mengijinkan user untuk memilih dan mengeksekusi blok kode
dan mengabaikan blok kode yang lain.
13
3. PercobaanPercobaan 1 Statement if : public class Grade {
public static void main( String[] args ){ double grade = 92.0; if( grade >= 90 ){
System.out.println( "Excellent!" ); } else if( (grade < 90) && (grade >= 80)){
System.out.println("Good job!" ); } else if( (grade < 80) && (grade >= 60)){
System.out.println("Study harder!" ); } else{
System.out.println("Sorry, you failed."); } }
}
Percobaan 2 Statement switch: public class Grade2{
public static void main( String[] args ){
int grade = 92; switch(grade){ case 100:
System.out.println( "Excellent!" ); break; case 90:
System.out.println("Good job!" ); break;case 80: System.out.println("Study harder!" ); break;default:
System.out.println("Sorry, you failed.");}
} }
14
Percobaan 3 Statement break: public class Grade3{
public static void main( String[] args ){ String names[] = { "Beah", "Bianca", "Lance", "Belle",
"Nico", "Yza", "Gem", "Ethan"}; String searchName = "Yza"; boolean foundName = false; for( int i=0; i< names.length; i++ ){
if( names[i].equals( searchName )){
foundName = true;break;}
}if( foundName ){ System.out.println( searchName + " found!" );}Else{ System.out.println( searchName + " not found." );}
}}
Percobaan 4 Labeled break statement: public class Grade4{
public static void main( String[] args ){
String names[] = {"Beah", "Bianca", "Lance", "Beah"};int count = 0;for( int i=0; i<names.length; i++ ){
if( !names[i].equals("Beah") ){continue; // skip next statement}
Count++;}System.out.println("There are " + count + " Beahs in the list");
15
} }
Percobaan 5 Continue statement:
public class Grade5{
public static void main( String[] args ){ String names[] = {"Beah","Bianca","Lance","Beah"};
int count = 0;for( int i=0; i<names.length; i++ ){if( !names[i].equals("Beah") ){continue; //skip next statement}count++;
} System.out.println("There are " + count +" Beahs in the list");}
}
Percobaan 6 Labeled statement continue: public class Grade6{
public static void main( String[] args ){ outerLoop:
for( int i=0; i<5; i++ ){for( int j=0; j<5; j++ ){
System.out.println("Inside for(j) loop");if( j == 2 ) continue outerLoop;
}
16
Java Array
1. Tujuan Mendeklarasikan dan membuat array
Mengakses elemen-elemen didalam array
Menentukan jumlah element didalam sebuah array
Mendeklarasikan dan membuat array multidimensi
2. Latar BelakangPada bagian ini, kita akan mendiskusikan mengenai array dalam Java.
Pertama, kita akan mendefinisikan apa yang dimaksud dengan array, kemudian kita
juga akan mendefinisikan bagaimana mendeklarasikannya dan menggunakannya 17
dalam Java.
Dibagian sebelumnya, kita telah mendiskusikan bagaimana cara
pendeklarasian berbagai macam variabel dengan menggunakan tipe data primitif.
Dalam pendeklarasian variabel, kita sering menggunakan sebuah tipe data beserta
nama variabel atau identifier yang unik, dimana untuk menggunakan variabel
tersebut, kita akan memanggil dengan nama identifier-nya.
Sebagai contoh, kita memiliki tiga variabel dengan tipe data int yang memiliki
identifier yang berbeda untuk tiap variabel.
int number1;
int number2;
int number3;
number1 = 1;
number2 = 2;
number3 = 3;
Seperti yang dapat Anda perhatikan pada contoh diatas, hanya untuk
menginisialisasi dan menggunakan variabel terutama pada saat variabel-variabel
tersebut memiliki tujuan yang sama, dirasa sangat membingungkan. Di Java maupun
di bahasa pemrograman yang lain, mereka memiliki kemampuan untuk menggunakan
satu variabel yang dapat menyimpan sebuah data list dan kemudian memanipulasinya
dengan lebih efektif. Tipe variabel inilah yang disebut sebagai array.
Sebuah array akan menyimpan beberapa item data yang memiliki tipe data
sama didalam sebuah blok memori yang berdekatan yang kemudian dibagai menjadi
beberapa slot. Bayangkanlah array adalah sebuah variabel – sebuah lokasi memori
tertentu yang memiliki satu nama sebagai identifier, akan tetapi ia dapat menyimpan
lebih dari sebuah value.
3. PercobaanPercobaan 1 Pengaksesan element array: public class ArraySample {
public static void main( String[] args ){
int[] ages = new int[100];
18
for( int i=0; i<100; i++ ){System.out.print( ages[i] );
} }
}
Percobaan 2 Panjang Array: public class ArraySample2 {
public static void main( String[] args ){
int[] ages =new int[100];for(int i=0; i<ages.length; i++ ){System.out.print( ages[i] );}
}}
Percobaan 3 Array Multidimensi: public class ArraySample3 {
public static void main( String[] args ){
// Elemen 512 x 128 dari integer arrayint[][] twoD = new int[512][128];// karakter array 8 x 16 x 24char[][][] threeD = new char[8][16][24];// String array 4 baris x 2 kolomString[][] dogs = {{ "terry", "brown" }, { "Kristin", "white" },{ "toby", "gray"},{ "fido", "black"}};System.out.print( dogs[0][0] );
}}
19
Argumen Comman Line
1. Tujuan Mengetahui dan menjelaskan mengenai argumen command-line
Mendapatkan input dari user dengan menggunakan argumen command-line
Mempelajari bagaimana memberikan argumen kedalam program pada
NetBeans
2. Latar BelakangPada bagian ini, kita akan mempelajari bagaimana untuk memproses sebuah
input dari command-line dengan menggunakan argumen yang diberikan kepada
program Java.
Sebuah aplikasi Java dapat menerima berbagai argumen dari command-line.
Argumen dari command line memberikan kesempatan bagi user untuk
20
mempengaruhi operasi dari sebuah aplikasi dalam sekali invokasi. User
memasukkan argumen command line pada saat meng-invoke aplikasi dan
memberikan spesifikasi kepada aplikasi tersebut setelah nama kelas untuk
dijalankan.
Sebagai contoh, apabila Anda memiliki sebuah aplikasi Java dengan nama
Sort, yang akan mengurutkan lima nomor, Anda dapat menjalankannya seperti
berikut ini:
Gambar 1:Menjalankan argument dari Command-Line
Perhatikan bahwa sebuah argumen akan dipisahkan oleh spasi. Di bahasa Java,
apabila Anda akan memanggil sebuah aplikasi, sebuah runtime system akan
memberikan argumen command-line ke main method lewat array dari String,
dimana tiap String dalam array terdiri dari sebuah argumen commmand-line.
Perhatikan deklarasi dari main method,
public static void main( String[] args )
Argumen yang diberikan kepada program Anda akan disimpan kedalam sebuah
array String dengan identifier args.
Pada contoh sebelumnya, argumen dari command-line yang akan diberikan
kepada aplikasi sort command adalah lima buah String yaitu “5”,”4”,”3”,”2”, dan
“1”. Anda dapat mengetahaui berapa banyak argumen dari command-line dengan
cara melihat panjang dari attribute array.
21
Sebagai contoh,
int numberOfArgs = args.length;
Jika program Anda membutuhkan support sebuah argumen command-line
yang numeric. Anda harus mengkonversi String argumen tersebut untuk
merepresantasikan sebuah nomor, misalnya “34” menjadi sebuah nomor. Kode
dibawah ini adalah sebuah potongan untuk mengkonversi sebuah argumen
command-line menjadi integer.
int firstArg = 0;
if (args.length > 0){
firstArg = Integer.parseInt(args[0]);
}
parseInt akan mendapatkan NumberFormatException (ERROR) jika format
args[0] tidak valid (bukan sebuah nomor).
3. PercobaanPercobaan 1 Contoh program pada Command Line: public class CommandLineExample{
public static void main( String[] args ){System.out.println("Number of arguments=" + args.length);System.out.println("First Argument="+ args[0]);
}}
Percobaan 2 Contoh Program pada Netbeans: public class CommandLineExample{
public static void main( String[] args ){ System.out.println("Number of arguments=" + args.length); System.out.println("First Argument="+ args[0]);
}}
Langkah-langkah
22
Klik pada daerah yang dilingkari
Click kanan pada CommandLineExample, kemudian pilih Properties :
Dialog Project Properties akan muncul
23
click Run
Dalam textbox argumen, ketik argumen 5 4 3 2 1. Kemudian tekan click OK.
Run program
24
Hasil Percobaan 2 Output :
25
Java Class Library
1. Tujuan menjelaskan OOP dan beberapa konsepnya
perbedaan antara class dan object
pebedaan antara instance variables/method dan class (static) variable/method
menjelaskan method apa dan bagaimana memanggil method parameter
mengidentifikasi beberapa jangkauan dari sebuah variable
memilih tipe data primitive dan object
membandingkan objects dan menjabarkan class dari objects
2. Latar BelakangPada sesi ini, kita akan mengantarkan beberapa konsep dasar dari Object-Oriented
objcts, dan Programming (OOP). Selanjutnya kita akan membahas konsep dari classes
dan bagaimana menggunakan class dan anggotanya. Perubahan dan pemilihan object juga
akan dibahas. Sekarang, kita akan focus dalam menggunakan class yang telah dijabarkan
dalam Java Class library, kita akan membahas nanti tentang bagaimana membikin class
anda sendiri.
OOP berputar pada konsep dari object sebagai dasar element dari program anda.
Ketika kita membandingkan dengan dunia nyata, kita dapat menemukan beberapa objek
disekitar kita, seperti mobil, singa, manusia dan seterusnya. Object ini dikarakterisasi oleh
sifat / attributnya dan tingkah lakunya.
Contohnya, objek sebuah mobil mempunyai sifat tipe transmisi, warna dan
manufaktur. Mempunyai kelakuan berbelok, mengerem dan berakselerasi. Dengan cara
yang sama pula kita dapat mendefinisikan perbedaan sifat dan tingkah laku dari singa.
26
Coba perhatikan table dibawah ini sebagai contoh perbandingan :
3. PercobaanPercobaan 1 Pass By Value: public class TestPastByValue {
public static void main(String[] args) {int i = 10;System.out.println(i);test(i);System.out.println(i);
}public static void test(int j){
j = 33;}
}
Percobaan 2 Pass by reference : public class TestPassByReference {
public static void main(String[] args) {int []ages = {10,11,12};for(int i=0;i<ages.length;i++){
System.out.println(ages[i]);}test(ages);for(int i=0;i<ages.length;i++){
System.out.println(ages[i]);}
}public static void test(int []arr){
for(int i=0;i<arr.length;i++){arr[i]=i+50;}
}}
27
Percobaan 3 Perbandingan Object : class EqualsTest {
public static void main(String[] arguments) {String str1, str2; str1 = "Free the bound periodicals."; str2 = str1; System.out.println("String1: " + str1); System.out.println("String2: " + str2); System.out.println("Same object? " + (str1 == str2)); str2 = new String(str1); System.out.println("String1: " + str1); System.out.println("String2: " + str2); System.out.println("Same object? " + (str1 == str2)); System.out.println("Same value? " + str1.equals(str2));
} }
28
Membuat Class Sendiri
1. Tujuan Membuat kelas mereka sendiri
Mendeklarasikan atribut dan method pada class
Menggunakan referensi this untuk mengakses instance data
Membuat dan memanggil overloaded method
Mengimport dan membuat package
Menggunakan access modifiers untuk mengendalikan akses terhadap class
memberr
2. Latar BelakangSetelah kita mempelajari penggunaan class dari Java Class Library, kita akan
mempelajari bagaimana menuliskan sebuah class sendiri. Pada bagian ini, untuk
mempermudah pemahaman pembuatan class, kita akan membuat contoh class dimana
akan ditambahkan beberapa data dan fungsi – fungsi lain.
Kita akan membuat class yang mengandung informasi dari Siswa dan operasi –
operasi yang dibutuhkan pada record siswa.
Beberapa hal yang perlu diperhatikan pada syntax yang digunakan pada bab ini dan
bagian lainnya :* Menandakan bahwa terjadi lebih dari satu kejadian dimana elemen
29
tersebut iimplementasikan
<description> Menandakan bahwa Anda harus memberikan nilai pasti pada bagian
ini
[] Indikasi bagian optional
3. PercobaanPercobaan 1 Membuat Class Student Record : public class StudentRecord{ private String name; private String address; private int age; private double mathGrade; private double englishGrade; private double scienceGrade; private double average; private static int studentCount; /** * Menghasilkan nama dari Siswa */ public String getName(){ return name; } /** * Mengubah nama siswa */ public void setName( String temp ){ name = temp; } // area penulisan kode lain /** * Menghitung rata – rata nilai Matematik, Bahasa Inggris, * * Ilmu Pasti */ public double getAverage(){ double result = 0; result = ( mathGrade+englishGrade+scienceGrade )/3; return result; } /** * Menghasilkan jumlah instance StudentRecord */ public static int getStudentCount(){ return studentCount; } }Percobaan 2 Membuat Class Student Record Example : public class StudentRecordExample { public static void main( String[] args ){ //membuat 3 object StudentRecord StudentRecord annaRecord = new StudentRecord();StudentRecord beahRecord = new StudentRecord();StudentRecord crisRecord = new StudentRecord();
30
//Memberi nama siswa annaRecord.setName("Anna"); beahRecord.setName("Beah"); crisRecord.setName("Cris"); //Menampilkan nama siswa “Anna” System.out.println( annaRecord.getName() ); //Menampilkan jumlah siswa System.out.println("Count="+StudentRecord.getStudentCount()); } } Hasil Percobaan 1 dan 2 :Output Class Student Record Example dengan memanfaatkan class Student Record:
Percobaan 3 Membuat Class Student Record yang telah dimodifikasi: public class StudentRecord { private String name; private String address; private int age; private double mathGrade; private double englishGrade; private double scienceGrade; private double average; private static int studentCount; public StudentRecord(){ //constructor default studentCount++;}public StudentRecord(String temp){ this.name = temp; studentCount++;}public StudentRecord(String name, String Address){ this.name = name; this.address = Address; studentCount++;}public StudentRecord(double mGrade,double eGrade,double sGrade){ mathGrade = mGrade; englishGrade = eGrade; scienceGrade = sGrade; studentCount++;}/*** Menghasilkan nama dari siswa*/public String getName(){return name;}/*** mengubah nama siswa*/ public void setName(String temp){
name = temp; }
31
public String getAddress(){return address;
} public void setAddress(String temp){
address = temp; } public int getAge(){return age; } public void setAge(int temp){
age = temp; } //area penulisan kode lain /** * Menghitung rata-rata nilai matematika, bahasa inggris, ilmu pengetahuan */ public double getAverage(){
double result =0;result = (mathGrade+englishGrade+scienceGrade)/3;return result;
}public static int getStudentRecord(){ return studentCount;}public void print(String temp){ System.out.println("Name : "+name ); System.out.println("Address : "+address); System.out.println("Age : "+age);}public void print(double eGrade, double mGrade, double sGrade){ System.out.println("Name : "+name); System.out.println("Math Grade : "+mGrade); System.out.println("English Grade : "+eGrade); System.out.println("Science Grade : "+sGrade);}public double getEnglishGrade() { return englishGrade;}public void setEnglishGrade(double englishGrade) { this.englishGrade = englishGrade;}public double getMathGrade() { return mathGrade;}public void setMathGrade(double mathGrade) { this.mathGrade = mathGrade;}public double getScienceGrade() { return scienceGrade;}public void setScienceGrade(double scienceGrade) { this.scienceGrade = scienceGrade;}}Percobaan 4 Membuat Class Student Record Example yang telah dimodifikasi : public class StudentRecordExample {public static void main(String[] args) {//membuat 3 object StudentRecord
32
StudentRecord annaRecord = new StudentRecord();StudentRecord beahRecord = new StudentRecord();StudentRecord crisRecord = new StudentRecord();//versi baruStudentRecord recordAnna = new StudentRecord("Candra");StudentRecord recordBeah = new StudentRecord("Bagus","Malang");StudentRecord recordCris = new StudentRecord(80,90,100);//memberi nama siswaannaRecord.setName("Anna");beahRecord.setName("Beah");crisRecord.setName("Cris");//menampilkan nama siswa "Anna"System.out.println(annaRecord.getName());//menampilkan jumlah siswaSystem.out.println("Count="+StudentRecord.getStudentRecord());StudentRecord anna2Record = new StudentRecord();anna2Record.setName("Anna");anna2Record.setAddress("Philipina");anna2Record.setAge(15);anna2Record.setMathGrade(80);anna2Record.setEnglishGrade(95.5);anna2Record.setScienceGrade(100);//overload methodanna2Record.print(anna2Record.getName());anna2Record.print(anna2Record.getEnglishGrade(), anna2Record.getMathGrade(), anna2Record.getScienceGrade());recordAnna.print(recordAnna.getName());}}
Hasil Percobaan 3 dan 4 :Output membuat Class Student Record Example yang telah dimodifikasi dengan memanfaatkan Class Student Student Record yang telah dimodifikasi:
Percobaan 5 Package : package schoolClasses;public class StudentRecord {
private String name; private String address; private int age;
}
33
Pewarisan, Polimorphisme dan Interface
1. Tujuan Mendefinisikan superclasses dan subclasses
Override method dari superclasses
Membuat method final dan class final
2. Latar BelakangDalam 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. 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
34
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
dapat digunakan oleh semua subclass. Subclass hanya butuh mengimplementasikan
perbedaannya sendiri dan induknya.
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.
Sekarang, class induk Person dan subclass Student dari contoh sebelumnya, kita
tambahkan subclass lain dari Person yaitu Employee. Di bawah ini adalah hierarkinya,
Dalam Java, kita dapat membuat referensi yang merupakan tipe dari superclass ke sebuah
object dari subclass tersebut.
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 statisprintInformation 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.
3. PercobaanPercobaan 1 Mendefinisikan Subclass dan Superclass :
35
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;}}
public class Student extends Person{public Student(){//super( "SomeName", "SomeAddress"); //super(); //super.name = "name";System.out.println("Inside Student:Constructor");} public static void main( String[] args) { Student anna = new Student(); } }
Hasil Percobaan 1 Output Definisi Superclass dan Subclass :
Percobaan 2 Polimorphisme :
public class Person {
36
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() { System.out.println("Person Name : " +name);return name;}public String getAddress() {return address;}public void setName(String name) { this.name = name;}public void setAddress(String add) { this.address = add;}}public class Student extends Person{ public Student(){//super( "SomeName", "SomeAddress");//super(); //super.name = "name";System.out.println("Inside Student:Constructor"); } public String getName() { System.out.println("Student Name : " +name); return name; } public static void main( String[] args) { Student anna = new Student(); }}public class Employee extends Person{ public String getName() { System.out.println("Employee Name:" +name); return name; } public static void main(String[] args) { Person ref;
37
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
temp = ref.getName(); //getName dari Employee class dipanggil System.out.println(temp); } }
Hasil Percobaan 2 Polimorphisme :
Percobaan 3 Menampilkan Abstract Class:
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(); }
public class Human extends LivingThing{ public void walk(){ System.out.println("Human walks..."); } }Percobaan 4 Interface: 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();
38
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); } }Relation.java bertindak sebagai interface :public interface Relation { public boolean isGreater( Object a, Object b); public boolean isLess( Object a, Object b); public boolean isEqual( Object a, Object b); }
Penanganan Event Handling
1. Tujuan Mendefinisikan exception
Menangani exception menggunakan blok try-catch-finally
2. Latar BelakangDalam 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.
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.
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.
39
3. PercobaanPercobaan 1 Menangani Exception handling:
public class ExceptionExample { public static void main( String[] args ){ try{ System.out.println( args[1] ); }catch( ArrayIndexOutOfBoundsException exp ){ System.out.println("Exception caught!");
} }}Hasil Percobaan 1 Output Exception Handling
40
Referensi :
1. Modul Praktikum JENI 1
41