1. Pemrograman Terstruktur vs Pemrograman Berorientasi Objek
Konsep pemrograman terstruktur memandang sebuah program sebagai suatu prosedur besar yang selanjutnya dapat dibagi menjadi prosedur-prosedur yang lebih kecil dan saling berinteraksi satu sama lain. Sedangkan konsep pemrograman berorientasi objek (OOP) membagi program menjadi objek-objek yang saling berinteraksi satu sama lain. Objek dapat berupa benda yang nyata maupun tidak nyata (konsep).
2. Konvensi Pemrograman Java
Ketentuan- ketentuan dalam penamaan di Java
Konvensi selengkapnya ada di http://www.oracle.com/technetwork/java/codeconv-138413.html
3. Kelas
Kelas merupakan konsep atau deskripsi dari sesuatu. Bisa kita ibaratkan kelas ini seperti sebuah cetakan kue yang siap digunakan untuk menciptakan kue-kue (object).
Pendeklarasian Kelas dalam Java
Class NamaKelas
Contoh :
class Kue{
}
Di dalam kelas, kita dapat mendeklarasikan berbagai atribut (disebut sebagai variabel) dan perilaku (disebut sebagai methods) yang dimiliki oleh object yang akan diciptakan.
Contoh:
class Kue {
String warna, ukuran, rasa; //variabel
String ringan(){ //methods
String kondisi = "aku bisa terapung di air";
return kondisi;
}
}
4. Objek
Objek merupakan perwujudan (instansiasi) dari Kelas. Bila Kelas sebagai cetakan kue, maka objek merupakan kue yang diciptakan dari cetakan tersebut.
Deklarasi Object
//membuat objek dari suatu kelas menggunakan new
nama kelas nama_objek = new nama_kelas
//memanggil method dari objeknya
nama_objek.nama_method();
//mengeset atribut
nama_objek.nama_atribut=value;
Di dalam kelas kita mendeklarasikan berbagai variabel/properties dan method. Adapun objek merupakan instansiasi (perwujudan) dari kelas yang ada.
Contoh:
public class Kue {
//variabel
String warna, ukuran, rasa;
String ringan() { //methods
String kondisi = "aku bisa terapung di air";
return kondisi;
}
public static void main(String args[]) {
Kue bolu = new Kue(); //membuat objek kue bolu
//mengeset nilai variabel
bolu.warna = "cokelat";
bolu.ukuran = "sedang";
bolu.rasa = "manis";
bolu.ringan(); //memanggil methods
System.out.println("sku kue " + bolu.warna + ", " + bolu.ukuran + ", " + bolu.rasa
+ ", dan "+bolu.ringan());
}
}
5. Methods
Ada 2 jenis Methods dalam java :
1. Methods yang memiliki nilai kembalian (dalam pemrograman terstruktur disebut Fungsi).
2. Methods yang tidak memiliki nilai kembalian (dalam pemrograman terstruktur disebut Prosedur)
Contoh :
class Mobil {
void klakson() { //tidak memiliki nilai kembalian, ditandai dengan void
System.out.println("piiiiiiiiiim");
}
String ngebut(String aksi) { //memiliki nilai kembalian (ada return)
return aksi;
}
}
public class Transport {
public static void main(String args[]) {
Mobil lamborgini = new Mobil();
lamborgini.klakson();
System.out.println(lamborgini.ngebut("broooom"));
}
}
6. Variabel This
Variabel this merupakan variabel yang digunakan untuk mengacu kedalam class dimana kita coding. Jadi misalkan kita coding di class titik lalu di dalam salah satu method kita mengetikan this, berarti kita mengacu kepada class titik.
//penulisan variabel tanpa this
public class Titik{
int x = 0;
int y = 0;
//constructor
public Titik(int a, int b){
x = a;
y = b;
}
}
//penulisan variabel dengan this
public class Titik{
int x = 0;
int y = 0;
//constructor
public Titik(int x, int y){
this.x = x;
this.y = y;
}
}
7. Konstruktor
Konstruktor merupakan metode yang secara otomatis dipanggil ketika objek dipanggil. Cara membuat konstruktor : memiliki nama yang sama dengan kelas, tidak mengembalikan nilai dan tidak menggunakan kata kunci void.
public class Motor {
String bahan = "baja";
//konstruktor
public Motor() {
System.out.println("mesin pembuat rangka motor siap dijalankan");
}
public static void main(String args[]) {
Motor Yamaha = new Motor();
System.out.println(Yamaha.bahan);
}
}
8. Hak Akses Dalam Java
1. public : dapat digunakan dari luar kelas maupun package
2. protected : dapat digunakan dari sub-class atau class lain dalam satu package
3. private : hanya digunakan oleh class tersebut saja
4. tanpa hak akses (default): dapat digunakan class lain dalam satu package
secara lebih detail dapat dilihat pada tabel
Aksesibilitas
|
Public
|
Private
|
Protected
|
Default
|
Dari kelas yang sama
|
ya
|
ya
|
ya
|
ya
|
Dari sembarang kelas dalam package yang sama
|
ya
|
tidak
|
ya
|
ya
|
Dari sembarang kelas di luar package
|
ya
|
tidak
|
tidak
|
tidak
|
Dari sub kelas dalam package yang sama
|
ya
|
tidak
|
ya
|
ya
|
Dari sub kelas di luar package
|
ya
|
tidak
|
ya
|
tidak
|
9. Paket (Package)
Paket dalam java digunakan untuk mengelompokkan beberapa kelas agar lebih teratur dan mudah dalam melakukan maintenance.
Deklarasi :
Pembuatan paket :
Package NamaPackage
Nama paket tidak boleh diawali dengan nomor dan tidak boleh mengandung karakter unik dan spasi. Paket biasanya bertingkat, untuk memberikan tingkatan pada paket, dapat menggunakan tanda titik (.)
Bila Anda ingin menggunakan kelas yang berada di luar paket dimana Anda bekerja, maka Anda perlu mengimport paket dimana kelas tersebut berada
Import NamaPackage.NamaKelas
Contoh:
Misalkan kita mempunyai dua buah paket, paket kendaraan dan paket udara yang berada di dalam paket kendaraan.
a. Paket Udara
package kendaraan.udara;
public class Pesawat {
public Pesawat() {
System.out.println("Pesawat Ready");
}
public String terbang() {
String aksi = "wuuuuuuuuuush";
return aksi;
}
}
b. Paket Kendaraan
package kendaraan;
import kendaraan.udara.Pesawat;
public class Kendaraan {
public static void main(String args[]) {
Pesawat garuda = new Pesawat();
System.out.println(garuda.terbang());
}
}
10. Pewarisan (Inheritance)
Merupakan mekanisme dimana sebuah kelas dapat mewarisi seluruh atribut atau methods milik kelas lain dengan ketentuan tertentu. Ibaratnya kalau di dunia nyata, seorang anak pasti mewarisi sifat dari orang tuanya. Kelas yang mewariskan sifat disebut superclass, sedangkan kelas yang mewarisi sifat disebut subclass. Kelas yang ingin mewarisi sifat dari superclass menggunakan keyword extends, sedangkan untuk memanggil atribut atau method dari superclass menggunakan keyword super.
class Orang{
String nama,alamat;
public Orang(String n,String a){
nama=n;
alamat=a;
}
}
class Mahasiswa extends Orang { //mahasiswa mewarisi atribut dan method Orang
String nim;
Mahasiswa(String n,String a,String i){
super(n,a); //pemanggilan superclass menggunakan keyword super
nim=i;
}
void belajar(){
System.out.println("belajar sungguh-sungguh");
}
}
public class JenisOrang {
public static void main (String args[]){
Mahasiswa arif = new Mahasiswa("arif","baki","M0508031");
arif.belajar();
}
}
Pada contoh diatas, kelas Mahasiswa merupakan turunan dari kelas Orang. Jadi meskipun kelas Mahasiswa tidak memiliki atribut nama dan alamat, tetapi karena kelas Mahasiswa merupakan turunan dari kelas Orang, maka semua atribut maupun methods yang dimiliki kelas Orang juga ada pada kelas Mahasiswa.
11. Keyword Final
Keyword final merupakan keyword yang dapat digunakan untuk menandai bahwa suatu kelas, atribut, atau methods sudah tidak dapat diubah lagi. Selain itu ketika menggunakan keyword final, atribut harus langsung dideklarasikan. Jika tidak dideklarasikan langsung, akan terjadi kesalahan (error).
Contoh:
public class Final {
private final double pi = 3.14;
void ubahpi(double pi) {
this.pi = pi;
}
}
Ketika atribut pi kita deklarasikan ulang, akan muncul pesan kesalahan karena keyword final dideklarasikan ulang
12. Polimorfisme
Polimorfisme merupakan kemampuan untuk memperlakukan object yang memiliki bentuk atau perilaku yang berbeda.
Implementasi konsep polimorfisme : [a]Overloading dan, [b]Overriding
a. Overloading
Overloading ini ada 2 : Overloading pada konstruktor dan Overloading pada methods. Overloading merupakan mekanisme membuat lebih dari satu konstruktor atau methods pada sebuah kelas, dengan nama yang sama namun harus memiliki parameter yang berbeda.
Contoh:
public class Motor {
String bahan = "baja";
//konstruktor
public Motor() {
System.out.println("mesin pembuat rangka motor siap dijalankan");
}
public Motor(String warna){ //overloading konstruktor
System.out.println("bahan berwarna "+warna);
}
String aksi(){
String suara="broom";
return suara;
}
String aksi(String klakson){ //overloading methods
return klakson;
}
public static void main(String args[]) {
Motor Yamaha = new Motor("hitam");
System.out.println(Yamaha.aksi());
System.out.println(Yamaha.aksi("piiiiiiim"));
}
}
b. Overriding
Berbeda dengan Overloading, Overriding merupakan kemampuan subclass (kelas turunan) untuk menimpa methods dari superclass (kelas induk), yaitu dengan cara menggunakan nama dan parameter yang sama pada methods.
Contoh:
class Bayi{
void lari(){
System.out.println("Tidak bisa lari");
}
}
public class Remaja extends Bayi {
@Override
void lari() {
System.out.println("bisa lari");
}
public static void main (String args[]){
Remaja Arif = new Remaja();
Arif.lari();
}
}
13. Abstract dan Interface
Abstract merupakan kelas yang memiliki methods namun tidak dideklarasikan, pendeklarasian dilakukan pada kelas turunannya. Untuk mengimplementasikan abstraksi menggunakan keyword extends.
public abstract class Hewan {
public abstract void suara();
}
Contoh :
public abstract class Hewan {
public abstract void suara();
}
class Kucing extends Hewan {
public void suara() {
System.out.println("Meooong....");
}
}
class Ayam extends Hewan {
public void suara() {
System.out.println("kukuruyuuk....");
}
}
class HewanDarat {
public static void main(String args[]) {
Kucing anggora = new Kucing();
anggora.suara();
}
}
Interface : merupakan mekanisme dimana kita dapat menentukan methods yang harus ada pada kelas. Mirip dengan abstract tetapi memiliki sedikit perbedaan.
Abstract
|
Interface
|
Bisa berisi abstract dan non-abstract method.
|
Hanya boleh berisi abstract method.
|
Method boleh bersifat static.
|
Method tidak boleh bersifat static.
|
Method boleh bersifat final.
|
Method tidak boleh bersifat final.
|
Kita harus menuliskan sendiri modifiernya.
|
Kita tidak perlu susah2 menulis public abstract di depan nama method. Karena secara implisit, modifier untuk method di interface adalah public dan abstract.
|
Bisa mendeklarasikan constant dan instance variable.
|
Hanya bisa mendeklarasikan constant. Secara implisit variable yang dideklarasikan di interface bersifat public, static dan final.
|
Suatu abstact class hanya bisa meng-extend satu abstract class lainnya.
|
Suatu interface bisa meng-extend satu atau lebih interface lainnya.
|
Suatu abstract class hanya bisa meng-extend satu abstract class dan meng-implement beberapa interface.
|
Suatu interface hanya bisa meng-extend interface lainnya. Dan tidak bisa meng-implement class atau interface lainnya.
|
Untuk mengimplementasikan interface menggunakan keyword implements.
Contoh :
abstract class HewanDarat {
public abstract void jalan();
}
abstract class HewanLaut {
public abstract void berenang();
}
interface infHewanDarat {
public abstract void jalan();
}
interface infHewanLaut {
public abstract void berenang();
}
class Katak extends HewanDarat {
public void jalan() {
System.out.println("jalan diatas tanah");
}
}
class KatakHijau implements infHewanDarat, infHewanLaut {
public void jalan() {
System.out.println("jalan diatas tanah");
}
public void berenang(){
System.out.println("berenang di air");
}
}
public class Hewan {
public static void main(String args[]) {
Katak k1 = new Katak();
k1.jalan();
KatakHijau kh1 = new KatakHijau();
kh1.jalan();kh1.berenang();
}
}
Notes : baik pada abstract maupun interface, hak akses tidak boleh private.
14. Inner Class
Java mendukung pembuatan kelas di dalam kelas (inner class). Cara membuatnya seperti membuat kelas biasa, hanya saja letak kelas berada di dalam kelas lain.
Contoh :
public class Hitung {
class Tambah { //inner class
void tambah(double a, double b) {
double hasil = a + b;
System.out.println(hasil);
}
}
public static void main(String args[]) {
System.out.println("Selamat belajar");
//membuat objek dari inner class (kelas Tambah)
Hitung.Tambah bil = new Hitung().new Tambah();
bil.tambah(5, 7);
}
}
15. Keyword Static
Keyword static membolehkan kita untuk mengakses sebuah atribut atau metode dari kelas secara langsung tanpa harus membuat objek dari kelas tersebut.
Contoh :
public class Berhitung {
public static int tambah (int a, int b){ //static
return a+b;
}
public double tambah (double a, double b){ //non static
return a+b;
}
public static void main (String args[]){
int hasil1 = Berhitung.tambah(2, 3); //static
System.out.println(hasil1);
Berhitung hasil2 = new Berhitung(); //non static, perlu membuat objek
System.out.println(hasil2.tambah(5, 5));
}
}
Previous Article
