LAPORAN MODUL IV

PRAKTIKUM PEMROGRAMAN BERORIENTASI OBJEK

“POLYMORPHISM”

Disusun untuk Memenuhi Matakuliah Praktikum Pemrograman Berorientasi Objek

Dibimbing oleh Heru Wahyu Herwanto, S.T., M.Kom.

Oleh:
Azizah Tri Novanti 170533628613

S1 PTI ‘17 OFF A

UNIVERSITAS NEGERI MALANG

FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI S1 PENDIDIKAN TEKNIK INFORMATIKA
Oktober 2018
I. Tujuan Praktikum
1. Menerapkan konsep polymorphism.
2. Menggunakan constructor method.
3. Melakukan overloading terhadap constructor method.
4. Melakukan overloading terhadap method.
5. Menggunakan class JTextField
II. Dasar Teori
1. Konsep polymorphism.
Polymorphism merupakan konsep sederhana dalam bahasa pemrograman
berorientasi objek yang berarti kemampuan sebuah objek untuk menghasilkan
aksi yang berbeda. Bila method yang sama dipanggil, maka aksi method yang
akan dikerjakan tergantung pada tipe objeknya.

2. Pengenalan constructor method.

Sifat constructor method:
a. Namanya sama dengan nama class.

b. Tidak memiliki nilai balik atau tidak boleh menggunakan tipe data void.

Constructor method atau biasa disebut dengan konstruktor saja adalah

method yang dapat digunakan untuk memberikan nilai awal saat objek
diciptakan. Method ini akan dipanggil secara otomatis oleh Java ketika keyword
new dipakai untuk menciptakan instan kelas

3. Overloading terhadap constructor method.

Overloading terhadap konstruktor merupakan suatu mekanisme pembuatan
konstruktor yang memiliki bentuk lebih dari satu. Dalam hal ini pembeda antara
satu konstruktor dengan konstruktor yang lain berupa jumlah atau tipe
parameter.
 4. Pengenalan overloading method.
Terkadang di dalam sebuah class ada lebih dari satu method yang namanya
sama, tetapi memiliki parameter yang berbeda sehingga fungsinya pun berbeda.
Method dengan kemampuan seperti ini disebut sebagai overloading method

5. Overriding pada Java

Overriding adalah sebuah fungsi atau mathod dari superclass (kelas induk)
yang ditulis kembali pada subclassnya (kelas anak), ada beberapa aturan pada
fungsi Overriding yang perlu kalian ketahui:

1. Parameter pada fungsi atau mothod overriding di subclass/kelas anak

harus sama dengan parameter yang terdapat pada superclass/kelas induka.

2. Aturan hak akses pada fungsi overriding di subclass tidak boleh lebih
ketat di bandingkan dengan hak akses method atau fungsi pada class induk.

6. Keuntungan Ketika Overriding Method

Terdapat keuntungan ketika meng-override method yaitu super class selaku
pemilik overriden method, kodenya tidak perlu mengalami perubahan sama
sekali, sementara itu di sisi lainnya sub class dapat mengimplementasikan kode
tersebut sesuai dengan kebutuhan.
Bisa dibayangkan jika suatu superclass memiliki banyak subclass. Ketika
sub class - sub class tersebut perlu untuk menggunakan method dari super class,
mereka dapat menggunakannya karena sub class dapat menggunakan method
super class pada konsep inheritance.
Dan jika mereka perlu mengimplementasikannya dengan berbeda mereka
tinggal meng-override method dari super class tanpa sama sekali menyentuh
kode method dari super class.
 7. Pengenalan class JTextField.
Class JTextField merupakan class dari package javax.swing yang digunakan
untuk membuat komponen berupa text field. Komponen ini berfungsi untuk
memasukkan data satu baris saja. Jika data yang dimasukkan tergolong sebagai
password, maka dapat digunakan JPasswordField dan dilengkapi dengan
penggunaan method getPassword() untuk memperoleh string pada objeknya.
Data yang dimasukkan melalui text field memiliki tipe data String. Jika
membutuhkan data berupa bilangan yang akan dilakukan perhitungan, maka
dapat dikonversi ke dalam tipe data lain, misalnya dikonversi ke dalam tipe data
integer dengan perintah Integer.parseInt(objek.getText()). Kemudian agar dapat
menampilkan hasilnya kembali pada text field, maka bisa digunakan perintah
objek.setText(String.valueOf(nilai))

III. Tugas Latihan

1. Nama Program : Menggunakan contructor method
Source Code :
class Mahasiswa
{
private String nama;
private int angkatan;
public Mahasiswa(String nama, int angkatan)
{
this.nama=nama;
this.angkatan=angkatan;
}
public void info()
{
System.out.println("Identitas Mahasiswa : ");
System.out.println("Nama \t\t: "+this.nama);
System.out.println("Angkatan \t:
"+this.angkatan);
}
}

public class Konstruktor

{
public static void main(String[] args)
{
 Mahasiswa mhs = new Mahasiswa("Surya",2012);

System.out.println("\n*************************************
********");
System.out.println("\n\tPENGENALAN
KONSTRUKTOR\n");

System.out.println("\n*************************************
********\n");
mhs.info();
}
}

Hasil Program :

Penjelasan :
Program diatas adalah program yang menggunakan konstruktor method
dimana terdapat method dengan nama yang sama dengan nama kelasnya
yaitu public Mahasiswa. Pada class Mahasiswa terdapat private
String nama dan private int angkatan yang digunakan agar dapat
diakses di dalam class Mahasiswa saja. Pada konstruktor class
Mahasiswa dengan parameter (String nama, int angkatan) terdapat
keyword this yang akan merefer ke objek dari class tersebut, sehingga
ketika parameter dan nama variable yang didelarasi sama akan dapat diakses
didalam konstruktor tersebut. Kemudan pada method public void info()
akan menampilkan identitas mahasiswa yang berisi pemanggilan variable
 pada contructor. Agar dapat di eksekusi, maka dibuatlah class baru yaitu
public class Konstruktor dimana class ini memiliki fungsi utama untuk
memanggil class Mahasiswa yang simpan pada objek baru yaitu
Mahasiswa mhs = new Mahasiswa("Surya",2012), didalam deklarasi
tersebut, telah diisi parameter yang sudah dideklarasi pada class
Mahasiswa. Ketika objek memanggil method info() maka akan
menampilkan pmanggilan variable yang telah diisi ketika pembuatan objek
yaitu("Surya",2012). Sehingga akan tampil hasil seperti gambar diatas.

2. Nama Program : Menerapkan overloading pada contructor method

Source Code :
class Mahasiswa
{
private String nama;
private int angkatan;
public Mahasiswa()
{
this.nama="Siwi";
this.angkatan=2013;
}
public Mahasiswa(String nama, int angkatan)
{
this.nama=nama;
this.angkatan=angkatan;
}
public void info()
{
System.out.println("\nidentitas Mahasiswa \t:
");
System.out.println("Nama \t\t\t: "+this.nama);
System.out.println("Angkatan \t\t:
"+this.angkatan);
}
}

public class OverloadConstructor1

{
public static void main(String[] args)
{

System.out.println("\n*************************************
**********");
System.out.println("\n\tOVERLOAD TERHADAP
 KONSTRUKTOR #1\n");

System.out.println("\n*************************************
**********");

Mahasiswa mhs1=new Mahasiswa("Surya",2012);

mhs1.info();

Mahasiswa mhs2=new Mahasiswa();

mhs2.info();
}
}

Hasil Program :

Penjelasan :

Program merupakan penerapan konsep overloading pada constructor

method, dimana terdapat beberapa constructor dengan nama yang sama
namun parameter yang digunakan berbeda. Pada class Mahasiswa terdapat
deklarasi nama dengan tipe data String dan angkatan dengan tipe data
interger yang sama sama memiliki control akses private. Didalam
constructor public Mahasiswa() tanpa parameter akan dideklarasi ulang
nama dan angkatan dengan menggunakan keyword this yang berfungsi
untuk merefer nama dan angkatan ke constructor agar dapat diakses.
 Kemudian variable tersebut menyimpan data nama dari mahasiswa dan
angkatannya. Pada contrucor kedua yaitu overloadingnya public

Mahasiswa(String nama, int angkatan) yang memiliki parameter

menggunakan keyword this untuk mengakses nama dan angkatan yang
sudah dideklarasi diluar contructor. Kemudian variable akan menyimpan
parameter yang telah ditentukan. Untuk menentukan parameter ini dilakukan
ketika pemanggilan constructor pada fungsi utama. Dan juga terdapat
method info() yang akan menampilkan data identitas mahasiswa dengan
memanggil variable yang sudah menyimpan data. Agar program dapat
dieksekusi dibutuhkan class baru yang memiliki fungsi utama didalamnya,
dimana akan dibuat objek Mahasiswa mhs1=new

Mahasiswa("Surya",2012); yang berfungsi untuk memanggil constructor

yang memiliki parameter dan membuat objek baru lagi yaitu Mahasiswa
mhs2=new Mahasiswa(); yang menyimpan constructor pada objek tersebut
dimana objek yang digunakan adalah objek yang tidak memiliki parameter.
Masing masing objek akan memanggil method info() untuk menampilkan
data sesuai tujuan dari objeknya.

3. Nama Program : Melakukan overloading terhadap contruktor method

Source Code :

class Lingkaran
{
double radius;

Lingkaran()
{
radius=1.0;
}

Lingkaran(double r)
{
radius=r;
}

double luas()
{
return radius*radius*Math.PI;
}
}
 public class Overloading
{
public static void main(String[] args)
{
System.out.println("\n\tMenghitung Luas
Lingkaran");

Lingkaran L1=new Lingkaran();

L1.luas();
System.out.println("\nDiketahui : \nr =
"+L1.radius);
System.out.println("phi = "+Math.PI);
System.out.println("Ditanya : L1");
System.out.println("L1 \t= phi*r*r\n \t=
"+L1.luas());

Lingkaran L2=new Lingkaran(10);

L2.luas();
System.out.println("\nDiketahui r =
"+L2.radius);
System.out.println("phi = "+Math.PI);
System.out.println("Ditanya : L2");
System.out.println("L2 \t= phi*r*r\n \t=
"+L2.luas());

Lingkaran L3=new Lingkaran(100);

L3.luas();
System.out.println("\nDiketahui r =
"+L3.radius);
System.out.println("phi = "+Math.PI);
System.out.println("Ditanya : L3");
System.out.println("L3 \t= phi*r*r\n \t=
"+L3.luas());
}
}

Hasil Program :
Penjelasan :
Program diatas adalah program untuk menghitung luas lingkaran dengan
radius yang berbeda beda dengan menerapkan konsep overloading
contructor. Pada class Lingkaran dideklarasi radius dengan tipe dat
double. Kemudian pada constructor tanpa parameter Lingkaran() variable
radius menyimpan data yaitu 1.0 sehigga constructor tersebut memiliki
radius sama dengan 1.0. Pada constructor kedua Lingkaran(double r)
yang memiliki parameter, radiusnya akan menyimpan panjang parameter
pada constructor tersebut. Lalu terdapat luas() yang akan mengembalikan
nilai radius dimana sebelumnya telah menyimpan panjang parameter dan
juga nilai PI dengan memanggil Math.PI. Kemudian membuat class baru
yang berisikan method main agar program dapat dieksekusi. Didalam class
tersebut akan dibuat tiga objek dengan nama yang berbeda dimana masing
masing objek digunakan untuk constructor dan parameter yang berbeda.
Objek pertama yaitu Lingkaran L1=new Lingkaran(); akan menghitung
luas lingkaran dengan radius pada constructor tanpa parameter, yaitu 1.0.
kemudian untuk objek kedua da ketiga memanggil constructor yang sama
 yaitu yang memiliki parameter, namun panjang atau banyaknya parameter
yang digunakan berbeda. Pada Lingkaran L2=new Lingkaran(10);
membuat objek baru dimana terdapat pemanggilan constructor yang
memiliki parameter sebanyak 10. Sehingga radiusnya akan menyimpan
parameter sebanyak 10 begitupula pada Lingkaran L3=new

Lingkaran(100); yang memanggil contructor yang sama namun

parameternya berbeda yaitu 100. Walaupun sama sama memanggil contructo
yang sama namun parameternya berbeda akan mempengaruhi hasil akhirnya
yaitu perhitungan luas lingkaran tersebut. Sehingga ketika method luas()
dipanggil pada masing masing objek maka hasilnya akan berbeda sesuai
parameter yang disimpan oleh radius tiap objeknya.

4. Nama Program : Menerapkan overloading terhadap method

Source Code :
class Pilihan
{
public void jurusan()
{
String jrs="Pendidikan Teknik Informatika";
System.out.println("\nPilihan 1: \nJurusan
"+jrs);
}

public void jurusan(String jrs)

{
System.out.println("\nPilihan 2:
\nJurusan"+jrs);
}
}

public class OverloadMethod1

{
public static void main(String[] args)
{

System.out.println("\n*************************************
******");
System.out.println("\n\tOVERLOAD TERHADAP
METHOD #1\n");
 System.out.println("\n*************************************
******");

Pilihan pilih = new Pilihan();

pilih.jurusan();
pilih.jurusan("Pendidikan Matematika");
}
}

Hasil Program :

Penjelasan :
Program diatas merupaka penerapan overloading terhadap method dimana
method memilliki konsep yang sama dengan constructor namun terdapat
perbedaan yang lebih spesifik. Pada class Pilihan terdapat method
public void jurusan() yang tidak memiliki parameter sehingga didalam
method tersebut dideklarasikan variable jrs dengan tipe data string dan akan
menyimpan sebuah teks yaitu "Pendidikan Teknik Informatika".
Kemudian method kedua yang di overloading sebelumnya memiliki
parameter, sehingga didalam method tersbut tidak perlu di deklarasi
variabelnya karena sudah ada pada parameter. Agar dapat dieksekusi maka
diperlukan void main, sehingga dibuatlah class baru yaitu public class
OverloadMethod1. Disinilah pembeda antara method dengan constructor
 yaitu pada method tidak perlu membuat objek lagi untuk menampilkan
method overloadingnya. Sehingga hanya membutuhkan satu buah objek saja
kemudian memanggil method sesuai dengan parameternya, seperti
pilih.jurusan(); yang digunakan untuk memanggil method tanpa
parameter, sehingga akan menampilkan variable pada method tersebut dan
yang kedua pilih.jurusan("Pendidikan Matematika"); yaitu
memanggil method yang memiliki parameter, sehingga jurusan yang akan
ditampilkan pada method kedua ini adalah "Pendidikan Matematika"

5. Nama Program : Melakukan overloading terhadap method

Source Code :
class Matematika
{
static public int kuadrat(int nilai)
{
return nilai*nilai;
}

static public double kuadrat(double nilai)

{
return nilai*nilai;
}

static public double kuadrat(String nilai)

{
double bilangan;
bilangan=Double.valueOf(nilai).doubleValue();
return bilangan*bilangan;
}
}

public class OverloadingMethod

{
public static void main(String[] args)
{
System.out.println("\n\tPerhitungan
Matematika");

Matematika mat= new Matematika();

System.out.println("Kuadrat dari 4.5 adalah

"+mat.kuadrat(4.5));
System.out.println("Kuadrat dari 5.5 adalah
 "+mat.kuadrat(5.5));
System.out.println("Kuadrat dari 2.5 adalah
"+mat.kuadrat(2.5));
}
}

Hasil Program :

Penjelasan :
Pada program diatas menerapkan overloading pada method yang digunakan
untuk perhitungan matematika. Pada class Matematika terdapat tiga
method yang memiliki parameter yang berbeda beda dan tipe data yang
berbeda juga, namun sama sama menghitung kuadrat dari parameternya.
Pada method static public int kuadrat(int nilai) memiliki
parameter dengan tipe data integer. Kemudian pada method static public
double kuadrat(double nilai) memiliki parameter yang tipe datanya
adalah double dan static public double kuadrat(String nilai)
dimana parameternya memiliki tipe data string. Sehingga didalam method
tersebut terdapat bilangan=Double.valueOf(nilai).doubleValue();

yang berarti variable bilangan akan menyimpan pengembalian nilai double

yang ditampilkan oleh argument string, sehingga tipe data string tersebut
seperti dikonvert menjadi double dengan pemanggilan method tersebut. Agar
program dapat diekseusi, maka dibuat class baru yang berisikan void main.
Pada public class OverloadingMethod ini akan dibuat sebuah objek
untuk memanggil ketiga method pada class sebelumnya, kemudian mengisi
parameter dan hasilnya seluruh method akan menghasilkan angka dengan
 tipe data double semua termasuk ketka tipedatanya string. Hal ini dapat
terjadi karena adanya Double.valueOf(nilai).doubleValue() yang
membuat tipe data string menjadi double..
6. Nama Program : Membuat text Field
Source Code :
import javax.swing.JFrame;
import javax.swing.JTextField;

public class CreateTextField

{
public static void main(String[] aargs)
{
JFrame frame = new JFrame();
JTextField textfield = new JTextField();
frame.setTitle("CREATE TEXT FIELD");
frame.setBounds(200,200,300,200);
frame.add(textfield);
textfield.setBounds(50,50,150,25);
frame.setLayout(null);
frame.setVisible(true);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Hasil Program :

Penjelasan :
Program diatas menjelaskan tentang pembuatan JTextField dimana kita
dapat menginputkan text pada kolom yang disediakan lalu ditampilkan pada
 sebuah frame. Sebelum membuat class terlebih dahulu mengimport package
yang digunakan oleh frame dan JTextField yaitu package javax.swing.
kemudian buat class untuk membuat JTextField. Sebelum membuat
JTextFieldnya, dibuat dulu framenya dengan membuat objek JFrame frame
= new JFrame(); setelah itu buat JTextField dengan objek baru yaitu
JTextField textfield = new JTextField();. Buat ukuran frame
dengan frame.setBounds(200,200,300,200); dimana parameter tersebut
mewakili koordinat x,y, panjang, lebar sebagai ukuran dari frame. Mengeset
nama pada frame dengan frame.setTitle("CREATE TEXT FIELD");.
Lalu JTextField yang telah dibuat kemudian dimasukkan kedalam frame
dengan frame.add(textfield);. Setelah ditambahkan pada frame, dibuat
ukutan dari JTextField tersebut dengan
textfield.setBounds(50,50,150,25) dimana ukurannya mewakili x, y,
panjang, dan lebar.
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) digunakan
ketika frame di close, maka program akan berhenti setelah frame tersebut di
close.
.
7. Nama Program : Menampilkan kata dari text Field
Source Code :
import java.awt.event.*;
import javax.swing.*;

//class TryTextField mengimplementasikan interface

ActionListener
public class TryTextField implements ActionListener
{
//membuat objek dari class yang akan digunakan
private JTextField textfield;
private JButton btnTampil;
private JLabel label;

public TryTextField()
{
JFrame frame = new JFrame();
frame.setBounds(200,200,325,175);
frame.setTitle("TRY TEXT FIELD");
 label = new JLabel("Input Kata : ");
label.setBounds(25,25,100,25);
frame.add(label);

textfield = new JTextField();

textfield.setBounds(125,25,150,25);
frame.add(textfield);

btnTampil = new JButton("Tampilkan Kata");

//menugaskan objek btnTampil
frame.add(btnTampil);
btnTampil.setBounds(125,75,150,25);
frame.setLayout(null);
frame.setVisible(true);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
btnTampil.addActionListener(this); //mendeteksi
event pada btnTampil
}

public void actionPerformed(ActionEvent e)

{
if(e.getSource()==btnTampil)
{
String kata = textfield.getText();
//mengambil kata yang diinputkan oleh user
JOptionPane.showMessageDialog(null, "Anda
telah menginput kata : \n"+kata, "INFORMASI",
JOptionPane.INFORMATION_MESSAGE);
}
}

public static void main(String[] args)

{
TryTextField frame = new TryTextField();
}
}

Hasil Program :
Penjelasan :
Program diatas menampilkan kata dari Text Field dengan menggunakan
JFrame dan JButton untuk menampilkan hasil dari inputan. Sebelum
membuat class, diimport terlebih dahulu package yang akan digunakan,
yaitu import java.awt.event.* yang akan mengimport method yang
berfungsi sebagai penanganan kejadian dan import javax.swing.*

sebagai package untuk JLabel, JFrame, JButton dan juga JTextField. Ketika
membuat class TryTextField terdapat implements ActionListener
yang berarti class tersebut akan menerapkan interaksi dari user yang dapat
dilakukan yaitu menekan tombol atau mengetik di text. Tiap variable di buat
control aksesnya dengan menggunakan private. Setelah dideklarasikan
variable tersebut, kemudian membuat frame dengan membuat objek JFrame
frame = new JFrame(); serta mengeset ukuran dan nama dari frame
tersebut. Kemudian membuat label untuk memberikan keterangan didalam
frame dengan membuat objeknya label = new JLabel("Input Kata :
"). Setelah membuat dan mengatur ukuran labelnya, lalu membuat
textfieldnya dengan membuat objek textfield = new JTextField();
seluruh objek yang telah dibuat dari label hingga textfield ditambahkan pada
frame agar tampilannya berada didalam frame. Setelah itu membuat button
 dengan objek btnTampil = new JButton("Tampilkan Kata") dan
menampilkannya pada frame.
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) digunakan
ketika frame di close maka program akan menghentikan jalan program
tersebut. btnTampil.addActionListener(this); dgiunakan untuk
mendeteksi kejadian yang terjadi pada btnTampil. public void

actionPerformed(ActionEvent e) merupakan aksi yang dilakukan ketika

user menekan tombol, jika user menekan tombol tersebut, maka akan keluar
information message yang berisikan tampilan dari text yang sudah diinput.
Kemudian pada void main memanggil class TryTextField yang akan
disimpan pada objek baru.

IV. Tugas Praktikum

1. Nama Program : Melakukan overloading pada contructor dan method
Source Code :
import java.util.Scanner;

class Buku
{
public Buku(String penyusun, String tahun)
{

System.out.print(penyusun+". "+tahun+". ");

}

public void terbit(String judul)

{
System.out.print(judul+". ");
}
public void terbit(String kota, String penerbit)
{
System.out.print(kota+": "+penerbit);
}
}

public class DaftarPustaka

{
public static void main(String[] args)
{
String penyusun, judul, tahun, penerbit, kota;
Scanner inScnanner = new Scanner(System.in);
 System.out.println("\n*************************************
***********");
System.out.println("\n\tTAMPILAN DAFTAR
PUSTAKA");

System.out.println("\n*************************************
***********");

System.out.println("\n\tMasukkan Identitas Buku

:\n");
System.out.print("Judul Buku\t: ");
judul=inScnanner.nextLine();
System.out.print("Nama Penyusun\t: ");
penyusun=inScnanner.nextLine();
System.out.print("Kota Terbit\t: ");
kota=inScnanner.nextLine();
System.out.print("Nama Penerbit\t: ");
penerbit=inScnanner.nextLine();
System.out.print("Tahun Terbit\t: ");
tahun=inScnanner.nextLine();

System.out.println("\n*************************************
***********\n");
System.out.println("\tPenulisan Daftar
Pustaka :\n");
Buku book = new Buku(penyusun, tahun);
book.terbit(judul);
book.terbit(kota,penerbit);
}
}

Hasil Program :
Penjelasan :
Program diatas merupakan implementasi dari overloading method dan
constructor yang digunakan di dalam bidang kepustakaan. Program ini akan
membuat daftar pustaka dari data data yang diinputkan oleh user. Karena
terdapat inputan dari user, maka perlu adanya operasi input dengan
menggunakan input scanner. Maka sebelum membuat kelas, terlebih dahulu
mengimport java.util.Scanner; sebagai package dari input Scanner.
Didalam class Buku terdapat constructor bernama public Buku(String
penyusun, String tahun) yang memiliki dua parameter dengan tipe data
yang sama yaitu String, constructor ini akan menampilkan nama penyusun
dan tahun terbit dari buku sesuai dengan yang diinputkan oleh user. Selain
constructor terdapat overloading method yaitu public void

terbit(String judul) dan public void terbit(String kota,

String penerbit) yang masing masing memiliki satu parameter dan dua
parameter dengan tipe data yang sama pula, dimana untuk method public
void terbit(String judul) akan menampilkan judul buku dan public
void terbit(String kota, String penerbit) akan menampilkan kota
penerbit dan nama penerbit dari buku. Pada program diatas terdapat dua
class dimana class yang satu tidak memiliki void main atau hanya berisikan
 method dan contructor saja dan yang satu lagi memiliki void main untuk
mengeksekusi program. Karena terdapat dua class, maka nama file yang
digunakan untuk mengeksekusi adalah nama file class yang memiliki void
main, yaitu public class DaftarPustaka. Pada class tersebut, harus
dideklarasi terlebih dahulu variable yang ada pada class sebelumnya yaitu
String penyusun, judul, tahun, penerbit, kota;. Kemudian
membuat objek untuk inputScanner Scanner inScnanner = new

Scanner(System.in);. judul=inScnanner.nextLine(); digunakan

untuk menginputkan judul dari user kemudian menyimpannya di variable
judul. penyusun=inScnanner.nextLine(); digunakan untuk
menginputkan data dari user yang akan disimpan pada variable penyusun.
kota=inScnanner.nextLine(); yang merupakan variable untuk
menginputkan data dari user.penerbit=inScnanner.nextLine();
digunakan untuk menginputkan penerbit buku dan kemudian disimpan
didalam variable penerbit.tahun=inScnanner.nextLine();digunakan
untuk meninputkan tahun terbit buku dari user yangakan disimpan pada
variable tahun. Untuk menampilkan inputan dari user maka perlu
pemanggilan method dari class lain, sehingga membuat objek Buku book =
new Buku(penyusun, tahun); untuk memanggil constructor
Buku(penyusun, tahun) yang akan disimpan pada objek bernama book.
Kemudian memanggil method book.terbit(judul); untuk menampilkan
judul buku, dan book.terbit(kota,penerbit); untuk menampilkan kota
dan penerbit dari inputan user.
2. Nama Program : Melakukan perhitungan sederhana
Source Code :
import javax.swing.*;
import java.awt.event.*;

public class FourOperations implements ActionListener

{
private JTextField jTFinput1, jTFinput2, jTFHasil;
private JLabel label1, label2, labelHasil;
private JButton btnBagi, btnJumlah, btnKali,
btnKurang;

public FourOperations()
{
JFrame frame = new JFrame();
frame.setBounds(200,200,500,200);
frame.setTitle("SIMPLE PROGRAM TO COUNT");

label1 = new JLabel("Bilangan 1: ");

label1.setBounds(25,25,150,25);
frame.add(label1);

label2 = new JLabel("Bilangan 2: ");

label2.setBounds(25,55,150,25);
frame.add(label2);

labelHasil = new JLabel("Hasil : ");

labelHasil.setBounds(240,100,150,25);
frame.add(labelHasil);

jTFinput1 = new JTextField();

jTFinput1.setBounds(125,25,150,25);
frame.add(jTFinput1);

jTFinput2 = new JTextField();

jTFinput2.setBounds(125,55,150,25);
frame.add(jTFinput2);

jTFHasil = new JTextField();

jTFHasil.setBounds(300,100,150,25);
frame.add(jTFHasil);

btnJumlah = new JButton("+");

frame.add(btnJumlah);
btnJumlah.setBounds(300,25,50,25);

btnKurang = new JButton("-");

frame.add(btnKurang);
btnKurang.setBounds(300,55,50,25);

btnKali = new JButton("*");

frame.add(btnKali);
btnKali.setBounds(400,25,50,25);

btnBagi = new JButton("/");

frame.add(btnBagi);
btnBagi.setBounds(400,55,50,25);

frame.setLayout(null);
frame.setVisible(true);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 btnJumlah.addActionListener(this);
btnKurang.addActionListener(this);
btnBagi.addActionListener(this);
btnKali.addActionListener(this);
}

public void actionPerformed(ActionEvent e)

{
if(e.getSource()==btnKali)
{
int
bilangan1=(Integer.parseInt(jTFinput1.getText().trim()));
int
bilangan2=(Integer.parseInt(jTFinput2.getText().trim()));
int hasil=bilangan1*bilangan2;
jTFHasil.setText(String.valueOf(hasil));
}
else if(e.getSource()==btnBagi)
{
int
bilangan1=(Integer.parseInt(jTFinput1.getText().trim()));
int
bilangan2=(Integer.parseInt(jTFinput2.getText().trim()));
int hasil=bilangan1/bilangan2;
jTFHasil.setText(String.valueOf(hasil));
}
else if(e.getSource()==btnKurang)
{
int
bilangan1=(Integer.parseInt(jTFinput1.getText().trim()));
int
bilangan2=(Integer.parseInt(jTFinput2.getText().trim()));
int hasil=bilangan1-bilangan2;
jTFHasil.setText(String.valueOf(hasil));
}
else if(e.getSource()==btnJumlah)
{
int
bilangan1=(Integer.parseInt(jTFinput1.getText().trim()));
int
bilangan2=(Integer.parseInt(jTFinput2.getText().trim()));
int hasil=bilangan1+bilangan2;
jTFHasil.setText(String.valueOf(hasil));
}
}

public static void main(String[] args)

{
FourOperations frame = new FourOperations();
}
}
Hasil Program :

Penjelasan :
Program diatas merupakan kalkulator sederhana yang diimplementasikan
melalui JTextField, JButton, JLabel serta JFrame. Apabila bilangan 1 dan
bilangan 2 diinputkan sebuah angka kemudian user menekan tombol (+)
maka hasilnya akan menjumlahkan dua bilangan tersebut, begitupun ketika
menekaan tombol yang lain, maka operasinya akan sesuai dengan tombol.
Sebelum membuat class, terlebih dahulu mengimmport import

javax.swing.*; sebagai package dari JLabel, JButton, JFrame dan

JTextField dan import java.awt.event.*; sebagai package untuk action
listener. public class FourOperations implements ActionListener
artinya class tersebut mengimplementasikan ActionListener yang
digunakan untuk mendeteksi user sedang menekan tombola pa, sehingga
tidak terjadi kekeliruan ketika user menekan salah satu tombol dari empat
tombol diatas. Lalu medeklarasi JTextField, JLabel dan JButton dengan
penggunaan control akses private sehingga hanya dapat diakses pada internal
member dari class tersebut. Terdapat constructor FourOperations() yang
berisi pembuatan objek frame yang digunakan untuk membuat frame,
 kemudian objek label, btn dan TFinput untuk membuat label, button dan text
field. Setelah membuat, kemudian mengeset dan menambahkan pada frame
dengan frame.add(btnBagi). Mendeteksi adanya action listener pada
button dengan btnJumlah.addActionListener(this);. Agar ketika user
menekan tombol (+) akan melakukan perhitungan penjumlahan, maka butuh
method public void actionPerformed(ActionEvent e) yang berisi
pernyataan operasi kondisi dimana jika dideteksi user menekan tombol (+)
maka tombol tersebut akan melakukan perhitungan penjumlahan, begitupula
dengan yang lain.
bilangan1=(Integer.parseInt(jTFinput1.getText().trim()));
int merupakan konversi dari string ke integer dan disimpan pada variable
bilangan 1. jTFHasil.setText(String.valueOf(hasil)); merupakan
hasil dari konversi string ke integer yang akan ditampilkan. Lalu pada void
main terdapat pemanggilan class yang akan disimpan pada objek baru
FourOperations frame = new FourOperations();

V. Kesimpulan
Kesimpulan yang didapat dari praktikum ini adalah :
1. Polimorpisme adalah konsep sederhana dalam Bahasa pemrograman
berorientasi objek yang berarti kemampuan sebuah objek untuk
menghasilkan aksi yang berbeda.
2. Costructor method adalah method yang dapat digunakan untuk memberikan
nilai awal saat objek diciptakan, dimana nama yang digunakan sama dengan
nama class dan tidak memiliki nilai kembalian seperti void.
3. Overloading merupakan suatu mekanisme pembuatan method atau
konstruktor yang memiliki bentuk lebih dari satu dimana pembedanya
adalah parameter atau tipe data yang digunakan.
4. Pada overloading constructor ketika memanggil constructor pada objek baru
maka objek tersebut hanya bisa memanggil satu constructor saja, hal ini
terrjadi karena constructor dipanggil secara otomatis oleh java ketika
 keyword new dipakai, yang berarti satu objek hanya untuk satu constructor
saja. Sehingga jika ingin constructor lainnya juga bisa dipanggil maka harus
membuat objek baru lagi.
5. Berbeda dengan overloading method, dimana method dapat dipanggil dalam
satu objek secara bersamaan.
6. Class untuk method dan class untuk void main dapat dituliskan pada satu file
yang sama, namun penamaan file harus menyesuaikan dengan nama class
yang memiliki void main, karena jika bukan maka program tidak dapat
dieksekusi karena tidak memiliki void main atau void main berada pada
claas yang lain yang tidak dipanggil.
7. JTextField digunakan untuk membuat komponen berupa texfield dimana
user dapat menginputkan text pada kolom textField tersebut.
8. Jika ingin mendapatkan bilangan untuk perhitungan, maka perlu adanya
konversi dari string ke interger atau double dengan menggunakan
Integer.parseInt(objek.getText()) dan menampilkannya dengan
objek.setText(String.valueOf(nilai))

VI. Daftar Rujukan

Admin. 2017. Memahami Method Overriding dan Aturannya pada Java.
(Online).(http://www.bahasajava.com/2017/10/method-overriding-
Java.html) diakses pada 9 Oktober 2018
M Athoillah, Wildan. 2017. Belajar Overriding dan Kata Kunci Super pada
Java. (Online). (https://www.wildantechnoart.net/2017/11/belajar-
overriding-dan-super-pada-java.html ) diakses pada 9 Oktober 2018
Brianorman, Yulrio. 2015. Penjelasan Overloading dan Overrinding pada Java.
(http://onestringlab.com/penjelasan-overloading-dan-overriding-pada-
java/) diakses pada 9 Oktober 2018
Indrajani, S.Kom,MM dan Martin, S.Kom. 2004. Pemrograman Berorientasi
Objek dengan Java. Jakarta : PT Elex Media Komputindo.
Gunawan, Erik. 2014. Java: Mengenal Overloading (Method and Constructor).
(Online). (http://www.erikgunawan.com/java-mengenal-overloading-
method-constructor/ ) diakses pada 11 Oktober 2018