MODUL PRAKTIKUM

“PEMROGRAMAN BERORIENTASI OBJEK 1 (JENI 1)”

LABORATORIUM KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS SRIWIJAYA
2015
 Universitas Sriwijaya LEMBAR PENGESAHAN SISTEM MANAJEMEN
Fakultas Ilmu Komputer MODUL PRAKTIKUM MUTU
Laboratorium ISO 9001:2008

No. Dokumen ……. Tanggal

Revisi 0 Halaman 2 DARI 42

MODUL PRAKTIKUM

Mata Kuliah Praktikum : Pemrograman Berorientasi Objek

1 (JENI 1)
Kode Mata Kuliah Praktikum : FJK14208
SKS :1
Program Studi : Teknik Komputer dan Jaringan
Semester : 1(Ganjil)

DIBUAT OLEH DISAHKAN OLEH DIKETAHUI OLEH

TIM LABORAN TIM DOSEN TEKNIK KEPALA LABORATORIUM

LABORATORIUM KOMPUTER DAN
FASILKOM UNSRI JARINGAN FASILKOM
UNSRI

2
 Daftar Isi

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

3
Mengenali Lingkungan Pemrograman Anda
1. Tujuan
 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 Belakang
Dalam 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. Percobaan
Percobaan 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!");
}
}

4
Dasar Dasar Pemrograman
1. Tujuan
 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 Belakang
Pada 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. Percobaan
Percobaan 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;

5
 double y = 7.22;
System.out.println("Variable values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
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));
}
}

6
Percobaan 3 Penggunaan Operator Relasi:
public class RelasiDemo
{
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
7
 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
}
}

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);
}
}

8
Percobaan 5 Penggunaan Operator Logika dan Boolean OR:
public class TestOR
{
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 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);
}
}

9
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);
}
}

Percobaan 8 Penggunaan Operator Kondisi (?:):

Contoh 1 :
public class kondisiOperator
{
public static void main( String[] args ){
String status=””;
int grade = 80;
//mendapatkan status pelajar
status = (grade >= 60)?"Passed":"Fail";
//print status
System.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
11
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 Belakang
Kita sudah mempelajari konsep mendasar pada Java dan menulis beberapa program
sederhana. Sekarang kita akan mencoba membuat program kita lebih interaktif dengan
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. Percobaan
Percobaan 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 +"!");
}
}

12
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)); //green
g.setFont(new Font("Helvetica",Font.PLAIN,16));
g.drawString("Hello GUI World!", 30, 100);
g.setColor(new Color(1.0f,0,0)); //red
g.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);
f.setSize(600, 300);
f.setVisible(true);
}
}

13
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 Belakang
Pada 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.
3. Percobaan
Percobaan 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.");
}
}
}

14
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.");
}
}
}

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;
}

15
 }
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");
}
}

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");
}
}

16
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;
}

17
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 Belakang
Pada 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
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.

18
 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. Percobaan
Percobaan 1 Pengaksesan element array:
public class ArraySample {
public static void main( String[] args )
{
int[] ages = new int[100];
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 array
int[][] twoD = new int[512][128];
// karakter array 8 x 16 x 24
char[][][] threeD = new char[8][16][24];
// String array 4 baris x 2 kolom
String[][] dogs = {{ "terry", "brown" },
{ "Kristin", "white" },

19
 { "toby", "gray"},
{ "fido", "black"}
};
System.out.print( dogs[0][0] );
}
}

20
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 Belakang
Pada 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
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

21
 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.
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. Percobaan
Percobaan 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]);
}
}

22
 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
Klik pada daerah yang dilingkari

Click kanan pada CommandLineExample, kemudian pilih Properties :

23
Dialog Project Properties akan muncul

click Run

24
 Dalam textbox argumen, ketik argumen 5 4 3 2 1. Kemudian tekan click OK.

Run program

Hasil Percobaan 2 Output :

25
26
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 Belakang
Pada 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.
Coba perhatikan table dibawah ini sebagai contoh perbandingan :

27
3. Percobaan
Percobaan 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;
}
}
}

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));
28
 System.out.println("Same value? " + str1.equals(str2));
}
}

29
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 Belakang
Setelah 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 tersebut iimplementasikan

<description> Menandakan bahwa Anda harus memberikan nilai pasti

pada bagian ini

[] Indikasi bagian optional

3. Percobaan
Percobaan 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;
30
 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();
//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 {
31
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;
}
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;

32
 }
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
StudentRecord annaRecord = new StudentRecord();
StudentRecord beahRecord = new StudentRecord();
StudentRecord crisRecord = new StudentRecord();
//versi baru
StudentRecord recordAnna = new StudentRecord("Candra");
StudentRecord recordBeah = new StudentRecord("Bagus","Malang");
StudentRecord recordCris = new StudentRecord(80,90,100);
//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.getStudentRecord());
StudentRecord anna2Record = new StudentRecord();
anna2Record.setName("Anna");
anna2Record.setAddress("Philipina");
anna2Record.setAge(15);
anna2Record.setMathGrade(80);
anna2Record.setEnglishGrade(95.5);

33
anna2Record.setScienceGrade(100);
//overload method
anna2Record.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;
}

34
Pewarisan, Polimorphisme dan Interface
1. Tujuan
 Mendefinisikan superclasses dan subclasses
 Override method dari superclasses
 Membuat method final dan class final
2. Latar Belakang
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. 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

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

35
 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 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.
3. Percobaan
Percobaan 1 Mendefinisikan Subclass dan Superclass :
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
36
 */
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 {
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() {
37
 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;
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(){
38
 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();
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);
}

39
Penanganan Event Handling
1. Tujuan
 Mendefinisikan exception
 Menangani exception menggunakan blok try-catch-finally
2. Latar Belakang
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.
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.
3. Percobaan
Percobaan 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
41
Referensi :

1. Modul Praktikum JENI 1

42