kontrak praktikum - · pdf filelaporan praktikum dianggap sah apabila praktikan telah...

1/32 Lab. Common Computing – Universitas Trunojoyo Madura

Lab. Pemrograman – Universitas Trunojoyo Madura

Ganjil

2012/2013

Praktikum

Pemrograman Berbasis

Object (PBO) [MODUL]


Daftar Isi

Daftar Isi ............................................................................................................................. 2

KONTRAK PRAKTIKUM ................................................................................................ 3 MODUL 1 KELAS DAN OBJEK ..................................................................................... 6 MODUL 2 INHERITANCE (PEWARISAN) ................................................................. 12 MODUL 3 Override Method ........................................................................................... 16 MODUL 4 Exception ........................................................................................................ 22

MODUL 5 INTERFACE .................................................................................................. 26


KONTRAK PRAKTIKUM

Nama Mata Kuliah : Praktikum Pemrograman Berbasis Objek

Kode Mata Praktikum : TKC 129

SKS : 1

Mata Kuliah Prasyarat : Pemrograman Berbasis Objek

Dosen Penanggung Jawab : M. Kautsar Sophan

Semester / Th Ajaran : Ganjil / 2013-2014

Hari Pertemuan / Jam : Sesuai Jadwal Praktikum

Tempat Pertemuan : Lab. Pemrograman

Gambaran Umum : Praktikum ini merupakan praktek dari mata kuliah Pemrograman Berbasis Objek yang

meliputi Class dan Object, Karakteristik OOP, Access Control, Deploying Java

Application, Class Design, Inherite, Override, Exception dan Interface. Praktikum

disertai dengan latihan-latihan menyelesaikan permasalahan dengan deklarasi dan

penggunaan Class yang tepat.

Mahasiswa diharapkan dapat:

Menyelesaikan masalah dengan menggunakan konsep OOP yang akan dijalankan

oleh komputer, kemudian mengimplementasikannya menjadi sebuah program

komputer

Merepresentasikan data yang digunakan dalam pemrograman OOP (baik data input

atau data output) dengan deklarasi dan penggunaan Class yang tepat.

Mengetahui & membandingkan macam-macam deklarasi class, penggunaan class,

dan sifat kelebihan OOP yang digunakan dalam permasalahan pemrograman yang

diselesaikannya.

Tujuan Pembelajaran Praktimum

Mahasiswa mengerti konsep OOP (Object Oriented Programming) / Pemrograman Berbasis Objek

dan dapat menerapkannya dalam bahasa pemrograman Java

Rumusan kompetensi Dasar

1. Mahasiswa memahami Class dan Objeck

2. Mahasiswa memahami Mengdeploy Aplikasi di Java

3. Mahasiswa memahami Desain Class

4. Mahasiswa memahami Inheritence

5. Mahasiswa memahami Override Method

6. Mahasiswa memahami exception

7. Mahasiswa memahami Interface


Referensi / Bahan Bacaan 1. ―Java for Dummies‖, Barry Burd, Wiley Publishing, 2007

2. ―Java 6 in 21 Days‖, Rogers Cadenhead, SAMS, 2007

3. Rangsang Purnama, Tuntunan Pemrograman Java Jilid 2, Prestasi Pustaka,

2003

4. Jim Keogh and Mario Giannini, OOP Demystified: A Self-Teaching Guide,

McGraw-Hill/Osborne, Ch. 4, 2004

5. Knudsen Jonathan, Niemeyer Pat, Learning Java™, 2nd Edition, O’Reilly, July

2002.

6. Horstmann C, Java Concepts 5th

Edition, Barkeley: John Wiley & Sons, Inc 381,

387, 397, 2005.

7. Lervik E, Java the UML Way, Trondheim: John Wiley & Sons, Inc 372, 2002

8. Savitch W, Absolute Java Second Edition: Addison Wesley 315, 2005

Alur bagi peserta praktikum : 1. Sebelum Pelaksanaan Praktikum, ada Pre Test

2. Pada Tiap Sesi Pelaksanaan Praktikum:

a. Peserta praktikum menerima dan kemudian mempelajari modul

praktikum.

b. Peserta praktikum mengerjakan tugas pendahuluan yang diberikan.

c. Peserta praktikum melakukan asistensi tugas pendahuluan tersebut.

Asistensi ini digunakan sebagai bagi asisten untuk menilai kesiapan

peserta juga berfungsi sebagai ajang diskusi peserta praktikum atas

kesuliatan yang dialaminya.

d. Peserta Praktikum melakukan implementasi Tugas Praktikum di kelas/

e. Peserta praktikum mendemokan implementasi pada asisten. Penilaian

yang dilakukan oleh asisten bersifat WISIWYG (What I see Is What You

Get)

3. Pada akhir pelaksanaan seluruh sesi praktikum, ada Posttest, berupa test program.

Tugas NO KRITERIA INDIVIDU KELOMPOK

1 Jenis Tugas 1. Pre Test

2. Post Test

1. Tugas Pendahuluan

2. Tugas Sesi Praktikum

2 Tujuan 1. Mahasiswa memahami

Konsep Struktu Data

Mampu menyelesaikan

masalah yang diberikan

dengan program

3 Jadwal Pengumpulan 1. Diawal Praktikum

2. Diakhir Praktikum

1. Di Awal Sesi Praktikum

2. Di akhir sesi praktikum

4 Keluaran Tugas 1. Program + Penjelasan

1. Program

2. Listing Program beserta

penjelasan

Bobot Prosentase Penilaian Praktikum : 1. Pre Test 5%

2. Pelaksanaan Praktikum – 6 Sesi / Modul

a. Tugas pendahuluan 15%

b. Kehadiran dan tugas praktikum 35%

c. Asistensi dan laporan praktikum 35%

3. Posttest + Laporan resmi 10%

Form Nilai


Kelas : A

n1 n2 n3 n1 n2 n3 n1 n2 n3 n1 n2 n3 n1 n2 n3 n1 n2 n3

1 010041110000 34 85 80 78 85 83 84 83 82 78 85 80 76 83 79 76 84,33 80,33 77,67 78 77,45 B+

2 008041110010 27 83 78 79 85 79 72 81 75 75 84 77 74 85 70 71 83,67 75,17 73,67 65 72,49 B

3 010041110005 65 87 85 88 86 85 87 85 87 86 86 88 87 87 78 79 86,17 83,50 84,00 83 83,10 A

4 010041110009 57 85 80 78 84 82 83 84 78 80 85 80 79 84 72 73 84,50 77,67 77,67 73 77,19 B+

5 010041110007 46 85 79 78 85 83 85 85 80 78 84 78 80 83 74 76 84,33 78,50 78,67 78 77,76 B+

6 010041110009 45 85 79 78 85 83 83 85 78 79 83 79 78 85 75 75 84,33 78,33 78,00 78 77,42 B+

7

Presentase Nilai

Kegiatan % KET

Pre Test 5% pre test

Tugas Pendahuluan 15% n1

Kehadiran + Tugas Praktikum35% n2

Asistensi + Laporan 35% n3

Posttest + Lapres 10% post test

Asdos :

No NRP NAMA PretestModul 1 Modul 2 Nilai

Akhir

Nilai

Huruf

Modul 3 Modul 4 Modul 5 Rata-rata Posttest

+ Lapres

Akhir

Nilai Point Range

A 4 > 80

B+ 3,5 >75 – 80

B 3 >70 – 75

C+ 2,5 > 65 – 70

C 2 >60 – 65

D 1 50 - 60

E 0 < 50

Catatan : Range Nilai bisa berubah sesuai dengan kondisi kelas

Peraturan Praktikum : 1. Praktikan harus menghadiri setiap sesi praktiku, tidak hadir tanpa keterangan akan

menyebabkan hak menjadi praktikan gugur (nilai E).

2. Tugas pendahuluan diserahkan sebelum praktikum dimulai.

3. Laporan praktikum dianggap sah apabila praktikan telah melakukan asistensi sesuai

dengan materi praktikum.

4. Laporan resmi adalah gabungan dari semua laporan praktikum tiap sesi.

5. Perbuatan Plagiat / Copy –Paste / Mencontoh sangat dilarang. Jika ada indikasi, akan

di beri nilai E.

Lain – Lain Pengumuman : kautsarsophan.wordpress.com

Pertanyaan : [email protected]

Ketua Koordinator Asisten Praktikum / HP :

Bahasa Pemrograman : Java

Tool

o Eclipse

mailto:[email protected]


MODUL 1 KELAS DAN OBJEK

I. TEORI DASAR 1. Class dan Object

Perbedaan Class dan Object Pada dunia Pemrograman Berorientasi Obyek (PBO), sebuah obyek adalah

sebuah komponen yang stukturnya mirip dengan obyek pada dunia nyata. Setiap

obyek dibangun dari sekumpulan data (atribut) yang disebut variabel untuk

menjabarkan karakteristik khusus dari obyek, dan juga terdiri dari sekumpulan

method yang menjabarkan tingkah laku dari obyek. Bisa dikatakan bahwa obyek

adalah sebuah perangkat lunak yang berisi sekumpulan variabel dan method yang

secara bersama-sama merepresentasikan obyek dunia nyata.

Obyek diinstansiasi/instantiate (diciptakan) dari class. Dalam dunia nyata, class

mirip dengan cetak biru/blue-print. Sebuah jembatan (obyek) dibuat dari cetak

biru(class)-nya.

Berikut contoh class – obyek: kita memiliki sebuah cetak biru/class mobil. Dari

class ini, kita dapat membuat beberapa obyek mobil. Class memiliki field nomor,

plat, warna, manufaktur dan kecepatan yang diisi dengan nilai pada obyek mobil

A dan mobil B. Mobil juga dapat berakselerasi, berbelok dan melakukan rem.

+akselerasi()+belok()+rem()

-nomor-plat-warna-manufaktur-kecepatan

mobil

mobilA mobilB

Ketika diinstansiasi, setiap obyek mendapat satu set variabel yang sama dengan

yang dimiliki classnya. Programmer dapat menggunakan sebuah kelas beberapa

kali untuk membuat banyak objek.

Instansiasi Class Untuk membuat sebuah objek atau sebuah instance pada sebuah class. Kita

menggunakan operator new. Sebagai contoh, jika kita ingin membuat instance

dari class string, kita menggunakan kode berikut :

String str2 = new String(“Hello world!”);

Khusus untuk tipe data String, kita dapat juga menggunakan perintah berikut

untuk menginstansiasi variabel string:

String str2 = "Hello";

2. Method


Apakah Method itu dan mengapa menggunakan Method? Di dalam Java, sebuah method adalah bagian-bagian kode yang dapat dipanggil

oleh program utama atau dari method lainnya untuk menjalankan fungsi yang

spesifik. Berikut adalah karakteristik dari method :

1. dapat mengembalikan satu nilai atau tidak sama sekali.

2. dapat menerima beberapa parameter yang dibutuhkan atau tidak ada parameter

sama sekali. Parameter bisa juga disebut sebagai argumen dari fungsi.

3. setelah method selesai dieksekusi, dia akan kembali pada method yang

memanggilnya.

Mungkin muncul pertanyaan: mengapa programmer butuh membuat banyak

method? Mengapa programmer tidak menuliskan semua kode pada satu buah

method saja? Hal ini karena cara penyelesaian masalah yang efektif adalah

dengan memecah masalah-masalah tersebut menjadi beberapa bagian. Tiap bagian

permasalahan diselesaikan dengan sebuah method singkat. Dari gabungan banyak

method singkat inilah sebuah permasalahan besar dapat diselesaikan dengan baik.

/* Disimpan dalam file ―Manusia.java‖ */

//Class Deklarasi

public class manusia

{

//Variabel

public String nama;

//Konstruktor

public manusia(String n)

{

this.nama = n;

}

//Method

public String tampilkanNama()

{

return nama;

}

public void belajar()

{

System.out.println(" Belajar PBO, Matematika, Fisika ");

}

public void kerja()

{

System.out.println("Kerja...kerjaaa...");

}

}

Adapun contoh kode untuk menginstansiasi kelas manusia menjadi objek Andi yang

mengimplementasikan metode: tampilkanNama dan belajar adalah sebagai berikut.

/* Disimpan dalam file ―budi.java‖

*/

class budi

{

public static void main(String arg[])


{

manusia budi= new manusia("Budi");

System.out.println("Nama= "+ budi.tampilkanNama());

budi.belajar();

}

}

Hasil eksekusi terhadap class budi adalah sebagai berikut:

Variabel nama akan diisi dengan nilai ‖Budi‖.

Lalu layar akan menampilkan tulisan:

Nama= Budi Belajar PBO, Matematika, Fisika

Deploying Java Application

Objectives

In this lesson, you will learn how to:

Describe the concept of packages

Describe how to deploy an application

Describe a complete Java application that includes a database back end

Programmers use packages to make types easier to find and use, to avoid naming

conflicts, and to control access. Programmers bundle groups of related types into

packages. You will want to understand how packages are organized so that you can take

advantage of this system of organization.

Preparing your Java program to run outside of the IDE environment is the process of

deployment. You will want multiple users to access and run your java application.

Understanding how to deploy a program is essential to delivering your application to

users.

A package is a collection of Java classes.

Think of a package as a folder on your hard drive. To define a package specify the

package name in the first line of a class definition using the keyword package. For

example:

package graphics; // Rectangle will be part of the graphics package

class Rectangle{

}

When you want your program to use the Java files that are stored in a package, make sure

that the package is listed in the CLASSPATH setting. This way the files can be found and

used. A class can only be in one package.

Naming a Package

With programmers worldwide writing classes and interfaces using the Java programming

language, it is likely that many programmers will use the same name for different types.

In fact, the previous example does just that: It defines a Rectangle class when there is

already a Rectangle class in the java.awt package. Still, the compiler allows both classes

to have the same name if they are in different packages.

The fully qualified name of each Rectangle class includes the package name. That is, the

fully qualified name of the Rectangle class in the graphics package is graphics.Rectangle,

and the fully qualified name of the Rectangle class in the java.awt package is

java.awt.Rectangle.

This works well unless two independent programmers use the same name for their

packages.

Package Naming Conventions


Package names are written in all lower case to avoid conflict with the names of classes or

interfaces. Companies use their reversed Internet domain name to begin their package

names—for example,

com.example.mypackage for a package named mypackage

created by a programmer at example.com.

Name collisions that occur within a single company need to be handled by convention

within that company, perhaps by including the region or the project name after the

company name (for example, com.example.region.mypackage).

Packages in the Java language itself begin with java. or javax. In some cases, the internet

domain name may not be a valid package name. This can occur if the domain name

contains a hyphen or other special character, if the package name begins with a digit or

other character that is illegal to use as the beginning of a Java name, or if the package

name contains a reserved Java keyword, such as "int". In this event, the suggested

convention is to add an underscore.

How to Use a Package

To use a public package member from outside its package, you must do one of the

following:

• Refer to the member by its fully qualified name

• Import the package member

• Import the member's entire package

Referring to a Package Member by Name

In the past you have imported packages to get certain classes for use in your programs.

You could skip importing and refer to a package by the fully qualified name. The fully

qualified name for the Rectangle class declared in the graphics package in the earlier

examples is:

graphics.Rectangle

To refer to it in your program without importing the class or package you would do the

following:

graphics.Rectangle myRect = new graphics.Rectangle();

Qualified names are fine for infrequent use. When a name is used repetitively, however,

typing the name repeatedly becomes tedious and the code becomes difficult to read. As

an alternative, you can import the member or its package and then use its simple name.

Importing a Package Member

To import a specific member into the current file, put an import statement at the

beginning of the file before any type definitions but after the package statement, if there

is one. Here's how you would import the Rectangle class from the graphics package

created in the previous section.


import graphics.Rectangle;

Now you can refer to the Rectangle class by its simple name.

Rectangle myRectangle = new Rectangle();

This approach works well if you use just a few members from the graphics package. But

if you use many types from a package, you should import the entire package.

Importing the Entire Package

To import all the types contained in a particular package, use the import statement with

the asterisk (*) wildcard character.

import graphics.*

Now you can refer to any class or interface in the graphics package by its simple name.

Circle myCircle = new Circle();

Rectangle myRectangle = new Rectangle();

The asterisk in the import statement can be used only to specify all the classes within a

package.

Hierarchies of Packages

At first, packages appear to be hierarchical, but they are not. For example, the Java API

includes a java.awt package, a java.awt.color package, a java.awt.font package, and many

others that begin with java.awt. However, the java.awt.color package, the java.awt.font

package, and other java.awt.xxxx packages are not included in the java.awt package.

The prefix java.awt (the Java Abstract Window Toolkit) is used for a number of related

packages to make the relationship evident, but not to show inclusion.

Importing java.awt.* imports all of the types in the java.awt package, but it does not

import java.awt.color, java.awt.font, or any other java.awt.xxxx packages. If you plan to

use the classes and other types in java.awt.color as well as those in java.awt, you must

import both packages with all their files:

import java.awt.*;

import java.awt.color.*;

II. TUGAS PENDAHULUAN

1. Jelaskan perbedaan antara Class dan Objek !

2. Buatlah program menggunakan class dan objek dengan nama motor.java, jika

program di jalankan hasilnya seperti di bawah ini :

Object ―motor-1‖ :

Merk : Yamaha

Pemilik : Pak Darmawan

Object ―motor-2‖ :

Merk : Honda

Pemilik : Pak Nasiruddin

3. Create a design that uses packages to organize related classes

III. KEGIATAN PRAKTIKUM

1. Buatlah kelas mahasiswa dengan atribut/variablel = nama dan npm dan

mempunyai metodh: tampilkanNama, tampilkanNpm, belajar, olahRaga, makan,

minum.

Buatlah 3 objek untuk menginstantiasi kelas mahasiswa dengan atribut nama dan

npm Anda sendiri dan 2 teman Anda dan mengimplementasikan beberapa metodh

yang telah Anda definisikan dalam kelas mahasiswa


2. Take the following java code and place it into a package named greeting:

public class MyName {

private String name = "Jane";

public getName() {

return name;

}

public setName(String name) {

this.name = name;

}

public sayHello() {

System.out.println(“Hi” + this.name);

}

}

3. You have a program that needs to use the sayHello method. What do you need to

include in the java program to get things to work?

4. How could you call the setName in a program without using an import statement

for the package?

Create JARs and set the main class

IV. TUGAS AKHIR

Buat program dengan nama televisi.java dengan spesifikasi sebagai berikut :

Class : Televisi

Object : Televisiku

Attribute

- Merek

- Tipe

- Ukuran

- Tombol volume

- Tombol Channel

Method

- Menyalakan TV

- Memindahkan Channel

- Membesarkan volume

- Mematikan Televisi

Hasil :

Merek Televisi : Samsung

Tipe Televisi : LCD TV

Ukuran Televisi : 52 inchi

Saat ini televisi sudah on.....

Channel berpindah

Volume bertambah besar.

Press any key to continue . . .

V. CATATAN

Referensi [1] Rangsang Purnama, Tuntunan Pemrograman Java Jilid 2, Prestasi Pustaka, 2003.


MODUL 2 INHERITANCE (PEWARISAN)

I. Teori

A class:

• Can declare constants and variables

• Can inherit methods from another class

• Can define and implement methods

• Can override inherited methods when the method is public or protected

Can't override inherited methods when the method is final

• Can be instantiated by:

– A public or protected constructor

– A public or protected static method or nested class

A class can be subclassed when:

• The class is not declared final

• The methods are public or protected

A class can be immutable by:

• Making it final

• Limiting instantiation to the class constructors

• Eliminating any methods that change instance variables

Inheritance merupakan pewarisan atribut dan method pada sebuah class yang

diperoleh dari class yang telah terdefinisi tersebut. Setiap subclass akan mewarisi state

(variabel-variabel) dan behaviour (method-method) dari superclass-nya. Subclass

kemudian dapat menambahkan state dan behaviour baru yang spesifik dan dapat pula

memodifikasi (override) state dan behaviour yang diturunkan oleh superclass-nya.

1. Keuntungan dari inheritance adalah :

Subclass menyediakan state/behaviour yang spesifik yang membedakannya dengan

superclass, hal ini akan memungkinkan programmer Java untuk menggunakan ulang

source code dari superclass yang telah ada. Programmer Java dapat mendefinisikan

superclass khusus yang bersifat generik, yang disebut abstract class, untuk

mendefinisikan class dengan behaviour dan state secara umum.

2. Istilah dalam inheritance yang perlu diperhatikan :

Extends : Keyword ini harus kita tambahkan pada definisi class yang menjadi subclass.

Superclass : Superclass digunakan untuk menunjukkan hirarki class yang berarti class

dasar dari subclass/class anak.

Subclass : Subclass adalah class anak atau turunan secara hirarki dari superclass.

Super : Keyword ini digunakan untuk memanggil konstruktor dari superclass atau

menjadi variabel yang mengacu pada superclass. Ada beberapa hal yang harus diingat

ketika menggunakan pemanggil constuktor super:


II. Prepraktikum 1. Apa yang perbedaan antara Induk Kelas (SuperClass) dengan Kelas Turunan

(SubClass) ?

2. Jelaskan keyword super dan extends dalam Pewarisan (inheritence) ?

III. Kegiatan Praktikum Pada bagian kegiatan praktikum ini, kita akan belajar membuat class yang

dikelompokkan dalam package kemudian menggunakan package ini dari class lain.

/*langkah ke-1: Membuat Class Rumah*/

class Rumah

{

private String a = " Rumahmewah ";

public void info()

{

//System.out.println (" Dipanggil pada = "+this);

System.out.println (" ");

System.out.println (" Rumah = "+a);

}

}

}

/*langkah ke-2: Membuat Class rumahindah turunan dari Rumah*/

class rumahindah extends Rumah

{

private String b = " tombol alarm ";

public void info()

{

System.out.println (" ");

super.info();

System.out.println (" rumahindah = "+b);

}

}


/*langkah ke-3: Membuat Main Program dengan Nama Class TipeRumah */

public class TipeRumah

{

public static void main ( String[]args )

{

Rumahindah C = new rumahindah();

C.info();

}

}

IV. Tugas Akhir 1. Buatlah program java yang menurunkan 1 buah kelas turunan dari kelas induk

yang lingkaran. Kelas turunan nya adalah kelas tabung. Program ini dapat

menghitung luas dan keliling lingkaran, dan Luas dan Keliling tabung !

V. Catatan Praktikum


Referensi [1] Knudsen Jonathan, Niemeyer Pat, Learning Java™, 2nd Edition, O’Reilly, July

2002.

[2] Rangsang Purnama, Tuntunan Pemrograman Java Jilid 2,Prestasi Pustaka, 2003.


MODUL 3

Override Method

I. Teori

Immutable Classes

...

public final class Car extends Vehicle {

...

Immutable classes:

• Make the class final, which means that other classes can't extend its behavior.

• Only allow instance variable assignments in the default or overloaded constructor.

Override Method Metode disebut polimorfis jika aksi yang dilakukan oleh suatu metode berbeda-beda

tergantung pada objek aktual pada saat metode itu dijalankan. Polimorfisme adalah salah

satu fitur utama dalam pemrograman berorientasi objek. Sebagai contoh, sebuah class

induk dengan nama Student mempunyai subclass StudentGrad, dan ditambahkan class

lain dengan nama StudentInfo.

Gambar 1 : Class Student dan subclass nya

Dari gambar diatas class StudentInfo digambarkan mempunyai hubungan

polymorfisme dengan class StudentGrad dan tentunya dengan class induk dari

StudentGrad yaitu class induk Student..

Enkapsulasi adalah suatu cara untuk menyembunyikan informasi detail dari suatu

class. Dua hal yang mendasar dalam enkapsulasi yakni : Information hiding , Interface to

access data.

Enkapsulasi menunjuk pada prinsip dari menyembunyikan desain atau

mengimplementasikan informasi yang tidak sesuai pada object yang ada.

Menyembunyikan elemen dari penggunaan sebuah class dapat dilakukan dengan

pembuatan anggota yang ingin Anda sembunyikan secara private.

Hak akses public memungkinkan semua kelas mengaksesnya, hak akses protected

hanya diberikan kepada kelasnya sendiri dan turunannya, serta kelas-kelas dalam satu

paket. sedangkan private hanya boleh diakses oleh kelasnya sendiri.

II. Prepraktikum

1. Apa yang anda ketahui tentang Information hiding ?


2. Jelaskan tentang Interface to access data dalam konsep Pengkapsulan?

3. Jelaskan mengenai keyword public, protected dan private ?

III. Kegiatan Praktikum

Perhatikan kelas manusia dibawah ini!

/*

Disimpan dalam file ―manusia.java‖

*/

class manusia

{

public String nama;

public manusia(String n)

{

this.nama = n;

}

public String tampilkanNama()

{

return nama;

}

public void makan()

{

System.out.println("Nyam... nyam... nyam...");

}

public void kerja()

{

System.out.println("Kerja... kerjaaa...");

}

private void bunuhDiri()

{

System.out.println("Dor…bruk...");

}

}

Andi adalah objek bentukan dari kelas manusia

(9)

/*

Disimpan dalam file ―andi.java‖

*/

class andi

{

public static void main(String arg[])

{

manusia andi= new manusia("Andi");

System.out.println("Nama= "+ andi.tampilkanNama());

andi.makan();

}

}

Apa yang terjadi jika hak akses private diakses oleh kelas lain?

I. Kompile dan jalankan kelas manusia dan andi!

II. Ubah hak akses makan dari public menjadi protected dan ulangi praktikum nomor 1!

Apayang terjadi? Jelaskan!

III. Tambahkan pada kelas andi untuk memanggil metodh bunuh diri, ulangi praktikum

no 1. Apa yang terjadi? Jelaskan!


Pada gambar 1 kita membuat tiga object class dengan nama Student, subclass

StudentGrad dan class StudentInfo. Class Student mempunyai method Write yang

digunakan untuk melewatkan argumen untuk kemudian ditampilkan dengan

menggunakan method Display.

class Student {

public void Write(int ID, int Grad, String Fname, String Lname) {

m_ID = ID;

m_Graduation = Grad;

m_First = Fname;

m_Last = Lname;

}

public void Display(){

System.out.println( "Student: " + m_ID + " " + m_First + " " +

m_Last + " Graduated: " + m_Graduation);

}

private int m_ID, m_Graduation;

private String m_First;

private String m_Last;

}

Subclass Student dengan nama StudentGrad berisi sintaks untuk menampilkan

info kelulusan. Polimorfisme terjadi antara kedua class StudentGrad dan Student dimana

pada kedua class mempunyai dua method yang sama tetapi mempunyai bentuk yang

berbeda sesuai dengan object yang digunakan untuk memanggilnya, yaitu Write() dan

Display();

class StudentGrad extends Student {

public void Write(int ID, int Grad, String Fname, String Lname, int

yrGrad, String unSch, String major) {

super.Write(ID, Grad, Fname, Lname);

m_UndergradSchool = unSch;

m_Major = major;

m_Grad = Grad;

YearGraduated = yrGrad;

}

public void Display(){

super.Display();

System.out.println(" Graduated: " + m_Grad + " " +

m_UndergradSchool + " " + m_Major + " " + YearGraduated);

}

private Integer YearGraduated,m_Grad;

private String m_UndergradSchool;

private String m_Major;

}

Class lain yaitu StudentInfo yang digunakan untuk memasukan agumen ke kedua

methd pada masing-masing class Student dan StudentGrad.

class StudentInfo {


public static void main (String args[]) {

StudentGrad myStudent = new StudentGrad();

myStudent.Write(10, 1,"Bob","Smith", 2000,"Columbia

University","CS");

myStudent.Display();

}

}

1. Kucing, Ayam, dan Anjing merupakan makhluk hidup yang masuk kategori

hewan, tiap hewan pasti mempunyai identitas baik itu berupa tipe hewan dan

suaranya.

Gambar 2 : Class Hewan dan subclass nya

Potongan sintaks bisa dituliskan seperti dbawah ini:

class Hewan {

private String tipe;

public Hewan(String tipe){

this.tipe = tipe;

}

public String toString(){

return "Ini adalah "+tipe;

}

public void bersuara(){

}

}

Sintaks class polimorfisme

import java.util.Random;

class Polimorfisme{

public static void main(String args[]){

Hewan[] hewannya = {

new Anjing("Broni", "Herder"),

new Kucing("Kiti", "Persia"),

new Ayam("Toki", "Buras")

};

Hewan pilihHewan;

Random pilih = new Random();

for (int i = 0; i<5 ; i++){

pilihHewan = hewannya[pilih.nextInt(hewannya.length)];

System.out.println("\nPilihan Anda:\n" + pilihHewan);

pilihHewan.bersuara();


}

}

}

Sintaks class Anjing

class Anjing extends Hewan{

//sintaks private object

public Anjing(String nama){

//sintaks menampilkan nama

}

public Anjing(String nama, String jenis){

//sintaks menampilkan nama dan jenis hewan

}

public void bersuara(){

//sintaks menampilkan suara hewan

}

public String toString(){

return super.toString()+"/nIni adalah "+jenis+" bernama "+nama;

}

}

Lanjutkan potongan kode program diatas sampai muncul output seperti di

bawah ini:

Pilihan Anda:

Ini adalah Ayam

Ini adalah Buras bernama Toki

Kukuruyuk petok petok

Pilihan Anda:

Ini adalah Kucing

Ini adalah Persia bernama Kiti

Meong meong meong

Pilihan Anda:

Ini adalah Ayam

Ini adalah Buras bernama Toki

Kukuruyuk petok petok

Pilihan Anda:

Ini adalah Anjing

Ini adalah Herder bernama Broni

Guk guk guk

Pilihan Anda:

Ini adalah Anjing

Ini adalah Herder bernama Broni

Guk guk guk

Pilihan diwakilkan dengan data array pada class polimorfisme.

IV Tugas Akhir


Buat Class RumahMakan dengan methode menu untuk menampilkan pilihan menu

nasi goreng dan teh hangat.

Buat Class Kantin extends RumahMakan dengan methode menu untuk

menampilkan menu nasi pecel, nasi bebek, air putih, es teh.

Buat program kasir Kantin yang menggunakan class kantin yang mencatat

transaksi pembelian dan harga yang harus di bayar oleh seorang pembeli.


MODUL 4 EXCEPTION

Objectives In this lesson, you will learn how to:

• Use exception handling syntax to create reliable applications

• Use try and throw statements

• Use the catch, multi-catch, and finally statements

• Recognize common exception classes and categories

• Create custom exception and auto-closeable resources

Purpose The user experience and programming functionality are very important components to a

well designed program. Imagine requesting a software from a major company, paying

lots of money for it, and it breaks every time you enter the wrong input. Would that

product be very successful? Probably not. The user would prefer a handler that

addresses the exception and prompts the user with the issue and continues functioning.

Exceptions and assertions allow for an elegant, consistent way of debugging Java code as

well handling errors that may occur throughout execution.

Exceptions

Exceptions, or run-time errors, should be handled by the programmer prior to execution.

Handling exceptions involves one of the following:

• Try-catch statements

• Throw statement

Try-Catch Statements

Try-Catch statements are used to handle errors and exceptions in Java. In the following

code example, the program will run through the try code block first. In no exception

occurs, the program will continue through the code without executing the catch block.

try {

System.out.println("About to open a file");

InputStream in =

new FileInputStream("missingfile.txt");

System.out.println("File open");

} catch (Exception e) {

System.out.println("Something went wrong!");

}

If an exception is found, the program will search for a catch statement that catches the

exception. In the code segment below, an exception can be expected if the file

―missingfile.txt‖ does not exist (a reference is being made to a non-existent object).

When the exception occurs, the catch statement is prepared to handle it by noting the user

with ―something went wrong‖.

try {


InputStream in = new FileInputStream("missingfile.txt");



System.out.println("Something went wrong!");

}


Note: If no catch statement is found, and the exception is not handled in any other way,

your program will crash during run-time.

The action that occurs when the catch statement is reached is up to the programmer and

how s/he decides the program should operate. For example, rather than displaying

―something went wrong‖ the programmer could prompt the user with ―File not found,

please provide file name.‖ With this information, the program will be able to use another

file and attempt to open that one.

try {


InputStream in = new FileInputStream("missingfile.txt");



System.out.println("File not found, please provide file

name");

//read file name from user input

}

Using Multiple Catch Statements

You may find that using multiple catch statements is very effective in making catch

statements more specific to the certain exception that occurs. Multiple catch statements

can be used for one try statement in order to catch more specific exceptions.

try {

//try some code that may possibly cause an exception

} catch (FileNotFoundException e) {

//code that executes when a FileNotFoundException

occurs

} catch (IOException e) {

//code that executes when an IOException occurs

}

Using Multiple Catch Statements

In the code segment below, the try statement is executed first. There are 2 possible

threats for exceptions:

1. FileNotFoundException – this may occur if ―missingfile.txt‖ does not

exist

2. IOException – this may occur if no data is found in ―missingfile.txt‖ when

the code attempts to access it.

If FileNotFoundException occurs, the first catch statement is triggered.

If this exception does not occur, the program will continue to execute in the try statement

until it reaches the IOException threat.


If the IOException occurs, the second catch statement is triggered.

If no exceptions occur, the program will skip over the catch statements and continue

executing the rest of the program.

catch (FileNotFoundException e) {

System.out.println(e.getClass().getName());

System.out.println("Quitting");


System.out.println(e.getClass().getName());

System.out.println("Quitting");

}

Finally Clause

Try-Catch statements can optionally include a finally clause that will always execute if an

exception was found or not.

InputStream in = null;

try {


in = new FileInputStream("missingfile.txt");


int data = in.read();


System.out.println(e.getMessage());

} finally {

try {

if(in != null) in.close();

} catch(IOException e) {

System.out.println("Failed to close file");

}

}

Multi-Catch Statement

There's a multi-catch statement that allows you to catch multiple exception types in the

same catch clause.

• Each type should be separated with a vertical bar: |

ShoppingCart cart = null;

try (InputStream is = new FileInputStream(cartFile);

ObjectInputStream in = new

ObjectInputStream(is)) {

cart = (ShoppingCart)in.readObject();

} catch (ClassNotFoundException | IOException e) {

System.out.println("Exception deserializing " +

cartFile);

System.out.println(e);

System.exit(-1);

}


Prepaktikum 1. Buat Program untuk mencoba menginputkan string ke sebuah variabel yang

bertype data Integer

2. Coba tangkap error yang terjadi menggunakan try … catch…

Tugas Praktikum

1. You would like to write a program that will open a simple file text called

―myFile.txt‖. Write a try catch statement to open the file and catch the error that

the file fails to open.

2. Write program to Write Lines of String to file text


MODUL 5 INTERFACE

I. Teori

An interface is a Java construct that helps define the roles that an object can assume. It is

implemented by a class or extended by another interface. Interfaces define collections of

related methods without implementations.

An interface:

• Can declare public constants

• Defines methods without implementation

• Can only refer to its constants and defined methods

• Can be used with the instanceof operator

While a class can only inherit a single super class, a class can implement more than one

interface. Implement is a keyword in java that is used when a class inherits an interface.

Public class className implements interfaceName{

...class implementation...}

An interface method:

• In an interface, each method is public even when you forget to declare it as public

• Is implicitly abstract but you can also use the abstract Keyword

Declaring an Interface

To declare a class as interface you must replace the keyword class with the keyword

interface. This will declare your interface and force all methods to be abstract and make

the default access modifier public.


The steps to implementing an interface are shown in the example shown below:


Why use an interface? You may be wondering why you would ever want to create a class that has no

mplementation. One reason could be to force all classes that implement the interface to

have specific qualities.

Consider this: A store owner wants to create a website that displays all items in the store.

We know:

• Each item has a name

• Each item has a price

• Each item is organized by department

It would be in the store owner's best interest to create an interface for what defines an

item. This will serve as the blueprints for all items in the store, requiring all items to at

least have the defined qualities above.

Now consider that the owner is adding a new item to his store:

• The new item is named cookie.

• Each cookie is 1 US Dollar

• The cookies can be found in the Bakery department.

• Each cookie is identified bya type.

The owner may create a Cookie class that implements the Item interface such as shown to

the right, adding a method or two that is specific to cookie items.


The owner is adding Chocolate Chip Cookies to his online store. He would create a

cookie such as shown below:

Cookie chocChip = new Cookie(“Chocolate Chip”);

He can use the Item interface in a similar way with all of the other items in his store to

assure that every item has the qualities that makes it an item. This will help him as he

creates his online store, by allowing for things such as searching items by departments or

by price.

II. Prepraktikum 1. Apa yang dimaksud dengan abstract method?

2. Apa yang dimaksud dengan overriding method?

3. Apa yang dimaksud dengan instansiasi?

III. Kegiatan Praktikum Pada bagian kegiatan praktikum ini, kita akan belajar membuat interface dan

mengimplementasikannya dalam sebuah class.

/*interface berisi abstract method atau method header*/

interface MyComparable {

boolean greaterThan(Object obj);

boolean lessThan(Object obj);

boolean equal(Object obj);

}


/*interface berisi konstanta*/

interface Constants {

int min = 1000;

int max = 9999;

}

/*class mengimplementasikan dua interface*/

class FourDigitsNumber implements Constants, MyComparable {

private int value;

public FourDigitsNumber(int initValue) {

/*latihan 1: atur agar nilai yang diinputkan dalam

constructor hanya berada di antara min – max

*/

}

/*latihan 2: tambahkan method get untuk mengakses value*/

/*overriding method greaterThan*/

public boolean greaterThan(Object obj) {

/*casting from superclass to subclass*/

FourDigitsNumber number = (FourDigitsNumber)obj;

return ( value > number.getValue() );

}

/*latihan 3: lengkapi overriding method interface*/

}

/*Contoh penggunaan class*/

class ExInterface {

public static void main(String [] args) {

FourDigitsNumber number1 = new FourDigitsNumber(700);



System.out.println(number1.getValue());



System.out.println(number1.greaterThan(number2));

System.out.println(number1.lessThan(number2));

System.out.println(number1.equal(number2));

/*latihan 4: modifikasi agar user dapat

menginputkan data*/

}

}


IV. Tugas Akhir 1. Segitiga, Lingkaran dan Segiempat adalah bentuk geometri yang dapat dihitung

luasnya. Gambarkan diagram hirarki class untuk kasus ini. Kemudian tulis kode

program untuk class dan buat program sederhana untuk keperluan pengujian:

atur array dengan elemen berisi referensi ke setiap bentuk geometri di atas,

masukkan data ke dalamnya dan gunakan untuk memanggil method guna

menghitung luas dari setiap bentuk geometri tersebut.

2. Buatlah sebuah interface dengan nama mtkDasar yang berisi dua buah method

head atau abstract

String tambah(int a, int b);

String kurang(int a, int b);

Buatlah sebuah class dengan nama Pecahan yang terdiri dari: dua variabel

bertipe int yaitu pembilang dan penyebut, sebuah constructor dengan dua

parameter bertipe int, method set( ) / get( ), method toString( ). Pecahan harus

mengimplementasikan interface MtkDasar.

Buatlah sebuah class CobaPecahan yang berfungsi menguji class Pecahan.

Referensi [1] Horstmann C, Java Concepts 5

th Edition, Barkeley: John Wiley & Sons, Inc 381, 387,

397, 2005.

[2] Lervik E, Java the UML Way, Trondheim: John Wiley & Sons, Inc 372, 2002.

kontrak praktikum - · pdf filelaporan praktikum dianggap sah apabila praktikan telah...

Documents