Menggunakan JOptionPane untuk mendapatkan input

Menggunakan BufferedReader untuk mendapatkan input

Pada bagian ini, kita akan menggunakan class BufferedReader yang berada di package
java.io untuk mendapatkan input dari keyboard.
Berikut ini adalah langkah-langkah yang diperlukan untuk mendapatkan input dari
keyboard:
1. Tambahkan di bagian paling atas code Anda:
import java.io.*;
2. Tambahkan statement berikut:
BufferedReader dataIn = new BufferedReader(new InputStreamReader( System.in) );
3. Deklarasikan variabel String temporary untuk mendapatkan input, dan gunakan
fungsi readLine() untuk mendapatkan input dari keyboard. Anda harus
mengetikkannya di dalam blok try-catch:
try{
String temp = dataIn.readLine();
}
catch( IOException e ){
System.out.println(“Error in getting input”);
}


Berikut ini adalah source code lengkapnya:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
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 +"!");
}
}
Berikutnya akan penjelasan setiap baris dari code tersebut:
Statement,
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
menjelaskan bahwa kita akan menggunakan class BufferedReader, InputStreamReader
dan IOException yang berada di java.io package. Java Application Programming
Interface (API) berisi ratusan class yang sudah didefinisikan sebelumnya yang dapat
digunakan untuk program Anda. Class-class tersebut dikumpulkan di dalam packages.
Packages berisi class yang mempunyai fungsi yang saling berhubungan. Seperti pada
contoh di atas, java.io package mengandung class-class yang memungkinkan
program untuk melakukan input dan output data. Pernyataan di atas juga dapat ditulis
sebagai berikut,
import java.io.*;
yang akan mengeluarkan semua class yang berada dalam package, dan selanjutnya kita
bisa menggunakan class-class tersebut dalam program kita.


Dua statement selanjutnya,
public class GetInputFromKeyboard
{
public static void main( String[] args ){
kita sudah mempelajari pada pelajaran sebelumnya. Pernyataan ini mendeklarasikan
class bernama GetInputFromKeyboard dan kita mendeklarasikan method main.
Dalam statement,
BufferedReader dataIn = new BufferedReader(new
InputStreamReader( System.in) );
kita mendeklarasikan sebuah variabel bernama dataIn dengan tipe class
BufferedReader. Jangan mengkhawatirkan tentang maksud dari syntax saat ini. Kita
akan menjelaskannya pada akhir pembahasan.
Sekarang, kita akan mendeklarasikan variabel String dengan identifier name,
String name = "";
Pernyataan di atas merupakan tempat untuk menyimpan input dari user. Nama variabel
diinisialisasi sebagai String kosong "". Sebaiknya kita selalu menginisialisasi sebuah
variabel setelah kita mendeklarasikannya.
Baris berikutnya adalah memberikan output sebuah String pada layar yang menanyakan
nama user.
System.out.print("Please Enter Your Name:");
Sekarang, blok di bawah ini merupakan try-catch block,
try{
name = dataIn.readLine();
}catch( IOException e ){
System.out.println("Error!");
}
Pada baris ini menjelaskan bahwa kemungkinan terjadi error pada pernyataan,
name = dataIn.readLine();
akan ditangkap. Kita akan membahas tentang penanganan exception pada bab
selanjutnya dari pembahasan ini, tetapi untuk sekarang, Anda cukup mencatat bahwa
Anda perlu menambahkan kode ini untuk menggunakan method readLine() dari
BufferedReader untuk mendapatkan input dari user.


Selanjutnya kembali ke pernyataan,
name = dataIn.readLine();
method diatas memanggil dataIn.readLine(), mendapatkan input dari user dan
memberikan sebuah nilai String. Nilai ini akan disimpan ke dalam variabel name, yang
akan kita gunakan pada statement akhir untuk menyambut user,
System.out.println("Hello " + name + "!");

Abstract Class

Misalnya kita ingin membuat superclass yang mempunyai method tertentu yang berisi
implementasi, dan juga beberapa method yang akan di-overridden oleh subclasses nya.
Sebagai contoh, kita akan membuat superclass bernama LivingThing. class ini mempunyai
method tertentu seperti breath, eat, sleep, dan walk. Akan tetapi, ada beberapa method di
dalam superclass yang sifatnya tidak dapat digeneralisasi. Kita ambil contoh, method walk.
Tidak semua kehidupan berjalan(walk) dalam cara yang sama. Ambil manusia sebagai
misal, kita manusia berjalan dengan dua kaki, dimana kehidupan lainnya seperti anjing
berjalan dengan empat kaki. Akan tetapi, beberapa ciri umum dalam kehidupan sudah
biasa, itulah kenapa kita inginkan membuat superclass umum dalam hal ini.

Kita dapat membuat superclass yang mempunyai beberapa method dengan implementasi
sedangkan yang lain tidak. Class jenis ini yang disebut dengan class abstract.
Sebuah class abstract adalah class yang tidak dapat di-instantiate. Seringkali muncul di
atas hirarki class pemrograman berbasis object, dan mendefinisikan keseluruhan aksi yang
mungkin pada object dari seluruh subclasses dalam class.
Method ini dalam class abstract yang tidak mempunyai implementasi dinamakan method
abstract. Untuk membuat method abstract, tinggal menulis deklarasi method tanpa tubuh
class dan digunakan menggunakan kata kunci abstract. Contohnya,

public abstract void someMethod();

Sekarang mari membuat contoh class abstract.
public abstract class LivingThing
{
public void breath(){
System.out.println("Living Thing breathing...");
}
public void eat(){
System.out.println("Living Thing eating...");
}
/**
* abstract method walk
* Kita ingin method ini di-overridden oleh subclasses
*/
public abstract void walk();
}
Ketika class meng-extend class abstract LivingThing, dibutuhkan untuk override method
abstract walk(), atau lainnya, juga subclass akan menjadi class abstract, oleh karena itu
tidak dapat di-instantiate. Contohnya,
public class Human extends LivingThing
{
public void walk(){
System.out.println("Human walks...");
}
}
Jika class Human tidak dapat overridde method walk, kita akan menemui pesan error
berikut ini,
Human.java:1: Human is not abstract and does not override
abstract method walk() in LivingThing
public class Human extends LivingThing
^
1 error




Petunjuk penulisan program:
Gunakan class abstract untuk mendefinisikan secara luas sifat-sifat dari class
tertinggi pada hirarki pemrograman berbasis object, dan gunakan subclassesnya
untuk menyediakan rincian dari class abstract.

Polimorfisme

Sekarang, class induk Person dan subclass Student dari contoh sebelumnya, kita
tambahkan subclass lain dari Person yaitu Employee.

Dalam Java, kita dapat membuat referensi yang merupakan tipe dari superclass ke sebuah
object dari subclass tersebut. Sebagai contohnya,


public static main( String[] args )
{
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person menunjuk kepada
// object Student
//beberapa kode di sini
}
Sekarang dimisalkan kita punya method getName dalam superclass Person kita, dan kita
override method ini dalam kedua subclasses Student dan Employee,
public class Person
{
public String getName(){
System.out.println(“Person Name:” + name);
return name;
}
}
public class Student extends Person
{
public String getName(){
System.out.println(“Student Name:” + name);
return name;
}
}

public class Employee extends Person
{
public String getName(){
System.out.println(“Employee Name:” + name);
return name;
}
Kembali ke method utama kita, ketika kita mencoba memanggil method getName dari
reference Person ref, method getName dari object Student akan dipanggil. Sekarang, jika
kita berikan ref ke object Employee, method getName dari Employee akan dipanggil.
public static main( String[] args )
{
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person menunjuk kepada
// object Student
String temp = ref.getName(); //getName dari Student
//class dipanggil
System.out.println( temp );
ref = employeeObject; //Person menunjuk kepada
// object Employee
String temp = ref.getName(); //getName dari Employee
//class dipanggil
System.out.println( temp );
}
Kemampuan dari reference 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
reference ke method. Misalkan kita punya method static printInformation yang
mengakibatkan object Person sebagai reference, kita dapat me-reference dari tipe
Employee dan tipe Student ke method ini selama itu masih subclass dari class Person.
public static main( String[] args )
{
Student studentObject = new Student();
Employee employeeObject = new Employee();
printInformation( studentObject );
printInformation( employeeObject );
}

public static printInformation( Person p ){
. . . .
}

Method final dan class final

Dalam Java, juga memungkinkan untuk mendeklarasikan class-class yang tidak lama
menjadi subclass. Class ini dinamakan class final. Untuk mendeklarasikan class untuk
menjadi final kita hanya menambahkan kata kunci final dalam deklarasi class. Sebagai
contoh, jika kita ingin class Person untuk dideklarasikan final, kita tulis,
public final class Person
{
//area kode
}
Beberapa class dalam Java API dideklarasikan secara final untuk memastikan sifatnya tidak
dapat di-override. Contoh-contoh dari class ini adalah Integer, Double, dan String.
Ini memungkinkan dalam Java membuat method yang tidak dapat di-override. Method ini
dapat kita panggil method final. Untuk mendeklarasikan method untuk menjadi final, kita
tambahkan kata kunci final ke dalam deklarasi method. Contohnya, jika kita ingin method
getName dalam class Person untuk dideklarasikan final, kita tulis,
public final String getName(){
return name;
}
Method static juga secara otomatis final. Ini artinya Anda tidak dapat membuatnya
override.

Overriding Method

Untuk beberapa pertimbangan, terkadang class asal perlu mempunyai implementasi
berbeda dari method yang khusus dari superclass tersebut. Oleh karena itulah, method
overriding digunakan. Subclass dapat mengesampingkan method yang didefinisikan dalam
superclass dengan menyediakan implementasi baru dari method tersebut.
Misalnya kita mempunyai implementasi berikut untuk method getName dalam superclass
Person,
public class Person
{
:
:
public String getName(){
System.out.println("Parent: getName");
return name;
}
:
}
Untuk override, method getName dalam subclass Student, kita tulis,
public class Student extends Person
{
:
:
public String getName(){
System.out.println("Student: getName");


}
:
}


Jadi, ketika kita meminta method getName dari object class Student, method overridde
akan dipanggil, keluarannya akan menjadi,
Student: getName

Kata Kunci Super

Subclass juga dapat memanggil constructor secara eksplisit dari superclass terdekat. Hal ini
dilakukan dengan pemanggil construktor super. Pemanggil constructor super dalam
constructor dari subclass akan menghasilkan eksekusi dari superclass constructor yang
bersangkutan, berdasar dari argumen sebelumnya.
Sebagai contoh, pada contoh class sebelumnya. Person dan Student, kita tunjukkan contoh
dari pemanggil constructor super. Diberikan kode berikut untuk Student,
public Student(){
super( "SomeName", "SomeAddress" );
System.out.println("Inside Student:Constructor");
}
Kode ini memanggil constructor kedua dari superclass terdekat (yaitu Person) dan
mengeksekusinya. Contoh kode lain ditunjukkan sebagai berikut,
public Student(){
super();
System.out.println("Inside Student:Constructor");



Kode ini memanggil default constructor dari superclass terdekat (yaitu Person) dan
mengeksekusinya.
Ada beberapa hal yang harus diingat ketika menggunakan pemanggil constuktor super:
1. Pemanggil super() HARUS DIJADIKAN PERNYATAAN PERTAMA DALAM constructor.
2. Pemanggil super() hanya dapat digunakan dalam definisi constructor.
3. Termasuk constructor this() dan pemanggil super() TIDAK BOLEH TERJADI DALAM
constructor YANG SAMA.
Pemakaian lain dari super adalah untuk menunjuk anggota dari superclass(seperti
reference this). Sebagai contoh,
public Student()
{
super.name = “somename”;
super.address = “some address”;
}